Comparable e Comparator

[newutente]

Forse inizio a capire però mi sfugge ancora una cosa.
Cerco di spiegarmi con un esercizio che ho fatto e che richiedeva l'ordinamento al contrario degli elementi interi di un array.
Vi posto sia la mia soluzione, così come l'ho pensata, sia quella del manuale:

SOLUZIONE MIA:

import java.util.*;

public class Vettore {
        public static void main(String args[]) {
            
            int[] vettore = {168,789,167,125,698};
            Arrays.sort(vettore);
            
            
            List<Integer> vettore2 = new ArrayList<Integer>();
            
            for(int i=0; i<vettore.length; i++) {
                vettore2.add(vettore[i]);
            }
            
            Collections.reverse(vettore2);
            
            
            System.out.println("Array ordinato al contrario:");
            
            Iterator<Integer> i = vettore2.iterator();
            while(i.hasNext()) {            
                 Integer numero = i.next();
                 System.out.println(numero);
             }
            
            
        }    
}

SOLUZIONE MANUALE:

import java.util.Arrays;

public class TestIntegerComparator {
    public static void main(String args[]) {
        Integer []array = {1942, 1947, 1971, 1984, 1976, 1974};
        Arrays.sort(array, new IntegerComparator());
        for (int intero : array) {
            System.out.println(intero);
        }
    }
}

import java.util.Comparator;

public class IntegerComparator implements Comparator<Integer>{
    @Override
    public int compare(Integer o1, Integer o2) {
        return -(o1.compareTo(o2));
    }   
}

Quello che mi sfugge è il perchè ha utilizzato il metodo sort nella sua seconda forma (quindi quello dove è richiesto l'oggetto della classe che implementa Comparator) quando poteva utilizzare il metodo reverse per invertire l'ordine degli elementi.
Probabilmente l'ha fatto per evitare di dover creare un'altra struttura oltre alla array dichiarato all'inizio e quindi immagino per risparmiare memoria.

In ogni caso vorrei cercare di comprendere meglio la logica di funzionamento di compare. In poche parole, qualsiasi siano gli elementi (ovviamente Integer) confrontati lui restituisce sempre un valore negativo? In teoria questo dovrebbe indicare che l'elemento (o1) sul quale si invoca il metodo è minore dell'elemento (o2) passato in input. Ma a quel punto non capisco il nesso.

[andbin]

Quello che mi sfugge è il perchè ha utilizzato il metodo sort nella sua seconda forma (quindi quello dove è richiesto l'oggetto della classe che implementa Comparator) quando poteva utilizzare il metodo reverse per invertire l'ordine degli elementi.
Probabilmente l'ha fatto per evitare di dover creare un'altra struttura oltre alla array dichiarato all'inizio e quindi immagino per risparmiare memoria.

No. Dato un array di interi "disordinato", ordinarlo in senso crescente e poi rovesciarlo (come hai fatto tu) è concettualmente la stessa cosa che ordinarlo applicando già un criterio di ordinamento al contrario (come la soluzione del manuale)!

Le differenze tecniche tra le due soluzioni ovviamente ci sono: tu parti da un int[] e in Arrays c'è un sort(int[] a). Ma non c'è un reverse per gli array. Quindi hai dovuto passarlo in un List<Integer> e poi usare il reverse di Collections.
Il manuale invece è partito da un Integer[] ed essendo un array di oggetti, esiste un sort per cui specificare un Comparator esplicito.
Presumibilmente il manuale voleva proprio mostrare un esempio di comparatore esplicito.

In poche parole, qualsiasi siano gli elementi (ovviamente Integer) confrontati lui restituisce sempre un valore negativo?

No, semplicemente "gira" il segno del risultato di compareTo. compareTo può restituire un valore 0, <0 o >0.
Se o1 è minore di o2, compareTo restituisce <0 (ovvero appunto o1 è minore di o2). Girando il segno, il sort vede >0 e lo interpreta come "o1 deve venire dopo di o2". Che appunto significa ordinare i numeri in senso decrescente.

Tra l'altro la soluzione del manuale, con il '-' personalmente non mi piace. Quando devo fare io cose del genere faccio semplicemente:

return o2.compareTo(o1);

che rende più chiaro il fatto che l'ordinamento è in senso contrario.