Ordenar List por Dependencia entre Classes

http://docs.oracle.com/javase/6/docs/api/java/lang/Class.html#isAssignableFrom(java.lang.Class)

Fiz um exemplo bem rápido, portanto não sei se está certo

import java.util.*;

class C {
	public String toString() { return getClass().getName(); }
}
class C1 extends C {
}
class C2 extends C1 {
}
class C3 extends C1 {
}
class C4 extends C2 {
}
class C5 extends C3 {
}
class C6 extends C4 {
}

class OrderBySubclass {
    public static void main (String[] args) {
		List <C> elements = new ArrayList<C>();
		elements.add (new C6());
		elements.add (new C5());
		elements.add (new C4());
		elements.add (new C3());
		elements.add (new C2());
		elements.add (new C1());
		System.out.println (elements);
		SortedSet <C> sorted = new TreeSet <C> (new Comparator <C> () {
			public int compare (C c1, C c2) {
				if (c1.getClass().equals (c2.getClass())) return 0; 
				if (c1.getClass().isAssignableFrom (c2.getClass())) return -1;
				if (c2.getClass().isAssignableFrom (c1.getClass())) return +1;
				return c1.getClass().getName().compareTo (c2.getClass().getName());
			}
		});
		sorted.addAll (elements);
		System.out.println (sorted);
	}
}

A rigor, seu problema é um pouco mais chato que parece.

Por exemplo, C2 e C3 não são uma subclasse um do outro, então não são diretamente comparáveis. No caso acima eu simplesmente, para simplificar, comparei os nomes das classes.

Na verdade, eu teria que levar em conta a composição também, no caso de um Estado compor uma Cidade. Mas a herança também seria um fator.

Você quer fazer um diagrama de classes então, certo? Para começar, não dá para fazer uma ordenação porque nesse caso você não tem algo linear, e sim em forma de um diagrama (nem de uma árvore é possível, uma vez que você tem composição, não somente herança).

Use algum pacote como o Astah ( http://astah.net/ ).

Curiosidade: o nome desse software é uma forma distorcida de dizer “amanhã” (ashita) em japonês. Outra forma de dizer amanhã (e que aparece em alguns nomes próprios) é “asu” - como o nome desta personagem, Asuna Kagurazaka: http://pt.wikipedia.org/wiki/Asuna_Kagurazaka

É que a companhia que produz esse software é japonesa.

Na verdade, quero simplesmente ordenar um List, de acordo com as dependencias.

Você pode criar uma árvore com as relações de herança e depois percorrer essa árvore (use "breadth-first tree traversal - http://en.wikipedia.org/wiki/Tree_traversal - não sei como é que se diz isso em português), pondo os elementos em uma lista. É mais confiável que a solução que lhe passei (e que tem problemas se duas classes não são subclasses uma da outra).

Entao, estou procurando alguma implementação de Comparable que verifique as dependências e ordene. Usando o método Collections.sort().

Você pode usar a implementação que lhe passei e que checa apenas a dependência de herança. Quanto à dependência de composição, você deve concordar que a relação não pode ser posta como uma árvore e sim como um grafo, portanto não dá para ordenar do jeito que você quer. OK?