Dívida símples Comparable

Programação Java
#1

Bom dia galera, não se assuntem com o tamanho do código, a dúvida é simples.

import java.util.*;

public class Exe3CLassificando2 implements Comparable<Exe3CLassificando2> {
	
	String nome;
	
	Exe3CLassificando2(String nome) {
		this.nome = nome;
	}
	
	public String toString() {
		return nome;
	}
	
	public int compareTo(Exe3CLassificando2 exe) {
		int i = nome.compareTo(exe.nome);
		System.out.print(i + " ");
		return i;
	}
	
	public static void main(String[] args) {

		Exe3CLassificando2 a = new Exe3CLassificando2("z");
		Exe3CLassificando2 a1 = new Exe3CLassificando2("a");
		Exe3CLassificando2 a2 = new Exe3CLassificando2("x");
		Exe3CLassificando2 a3 = new Exe3CLassificando2("c");
		Exe3CLassificando2 a4 = new Exe3CLassificando2("b");

		List<Exe3CLassificando2> lista = new ArrayList<Exe3CLassificando2>();
		lista.add(a);
		lista.add(a1);
		lista.add(a2);
		lista.add(a3);
		lista.add(a4);
		
		Collections.sort(lista);
		
		System.out.println("\n");
		System.out.println("\n");
		System.out.println(lista);
	}

}

Eu já postei aqui uma vez essa dúvida, porém não consegui entender ainda como o método compareTo funfa !
Eu sei que ao classificar, o sort() chama o compareTo, e que da forma que fiz fica o nomeObjetoAtual.compareTo(objeto parâmetro)
porém não sei que é o objeto atual. E se esse muda conforme as chamadas de short() a compareTo();

Ele pega o primeiro objeto adicionado na lista e compara com o segundo?
ai o segundo passa a ser o objeto atual ?
depois pega o terceiro objeto na lista e compara com o 2º e com o 1° e aloca na lista ?

Escrevi bastânte para tentar mostrar o que não estou entendendo. Mais acho que a dúvida é simples.

A saída do código é a seguinte:

25 2 -23 23 21 -2 24 22 1 -1

[a, b, c, x, z]

CompareTo não retorna só:

-1 this < other
0 this == other
1 this > other

Grato a todos que ajudarem !

#2

Veja como eu poderia implementar um “BubbleSort” genérico com um comparator:

public &lt;T&gt; void bubbleSort(List&lt;T&gt; lista, Comparator&lt;? super T&gt; comparator) { for (int i = 0; i &lt; lista.size()-2; i++) { for (int j = i; j &lt; lista.size()-1; j++) { if (comparator.compareTo(lista.get(i), lista.get(j)) &gt; 0) { Collections.swap(lista, i, j); } } } }

Se o objeto fosse Comparable, não seria muito diferente:

public &lt;T&gt; void bubbleSort(List&lt;T extends Comparable&lt;T&gt;&gt; lista) { for (int i = 0; i &lt; lista.size()-2; i++) { for (int j = i; j &lt; lista.size()-1; j++) { if (lista.get(i).compareTo(lista.get(j)) &gt; 0) { Collections.swap(lista, i, j); } } } }

A diferença é só que o Java usa um algoritmo de ordenação muito melhor.

#3

Não sei de onde você tirou que é exatamente -1, 0 e +1.

Na definição de compareTo, diz-se que o método deve retornar um número < 0, == 0 ou > 0. Não há nada escrito que é exatamente -1, 0 ou +1.

Favor olhar em:
http://download-llnw.oracle.com/javase/6/docs/api/java/lang/Comparable.html#compareTo(T)

(OK, é difícil de entender, mesmo usando o Google Translator, já que está em pseudo-matematiquês. )

#4