Come ordinare un ArrayList<Long>in Java in ordine decrescente?

Ecco un modo per il tuo list:

list.sort(null);
Collections.reverse(list);

Oppure puoi implementare il tuo Comparatorper ordinare ed eliminare il passaggio inverso:

list.sort((o1, o2) -> o2.compareTo(o1));

O ancora più semplicemente usa Collections.reverseOrder()dato che stai solo invertendo:

list.sort(Collections.reverseOrder());

Comparator<Long> comparator = Collections.reverseOrder();
Collections.sort(arrayList, comparator);

È possibile utilizzare il seguente codice fornito di seguito;

Collections.sort(list, Collections.reverseOrder());

oppure, se intendi utilizzare un comparatore personalizzato, puoi utilizzarlo come indicato di seguito

Collections.sort(list, Collections.reverseOrder(new CustomComparator());

Dove CustomComparator è una classe di confronto che confronta l'oggetto presente nell'elenco.

Java 8

bene farlo in java 8 è molto divertente e facile

Collections.sort(variants,(a,b)->a.compareTo(b));
Collections.reverse(variants);

Le espressioni lambda rock qui !!!

nel caso in cui avevi bisogno di una logica più di una riga per il confronto di un e b si potrebbe scrivere in questo modo

Collections.sort(variants,(a,b)->{
    int result = a.compareTo(b);
    return result;
});

Ordina normalmente e usa Collections.reverse();

Per le lamda in cui il tuo valore lungo è da qualche parte in un oggetto ti consiglio di usare:

.sorted((o1, o2) -> Long.compare(o1.getLong(), o2.getLong()))

o anche meglio:

.sorted(Comparator.comparingLong(MyObject::getLong))

Ordina, quindi inverti.

Un approccio più generale per implementare il nostro comparatore come di seguito

Collections.sort(lst,new Comparator<Long>(){
                public int compare(Long o1, Long o2) {
                    return o2.compareTo(o1);
                }
            });

Usando Collections.sort()con un comparatore che fornisce l'ordine decrescente. Vedere Javadoc per Collections.sort .

Il seguente approccio ordinerà l'elenco in ordine decrescente e gestirà anche i valori " null ", nel caso in cui se si dispone di valori null, Collections.sort () genererà NullPointerException

      Collections.sort(list, new Comparator<Long>() {
          public int compare(Long o1, Long o2) {
                  return o1==null?Integer.MAX_VALUE:o2==null?Integer.MIN_VALUE:o2.compareTo(o1);

        }
    });

Puoi anche ordinare un ArrayListcon a TreeSetinvece di comparator. Ecco un esempio da una domanda che avevo prima per un array di numeri interi. Sto usando "numeri" come nome segnaposto per ArrayList.

     import.java.util.*;
        class MyClass{
        public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        ArrayList<Integer> numbers = new ArrayList<Integer>(); 

        TreeSet<Integer> ts = new TreeSet<Integer>(numbers);
        numbers = new ArrayList<Integer>(ts);
        System.out.println("\nThe numbers in ascending order are:");
        for(int i=0; i<numbers.size(); i++)
        System.out.print(numbers.get(i).intValue()+" ");
        System.out.println("\nThe numbers in descending order are:");
        for(int i=numbers.size()-1; i>=0; i--)
        System.out.print(numbers.get(i).intValue()+" ");
    }
}

Quindi, c'è qualcosa che vorrei sollevare che penso sia importante e penso che dovresti considerare. runtime e memoria. Supponiamo che tu abbia un elenco e desideri ordinarlo, beh puoi, c'è un ordinamento integrato o potresti svilupparne uno tuo. Quindi dici, vuoi invertire l'elenco. Questa è la risposta che è elencata sopra.

Se stai creando quell'elenco, potrebbe essere utile utilizzare una struttura dati diversa per memorizzarlo e quindi scaricarlo in un array.

I cumuli fanno proprio questo. Filtra i dati e gestirà tutto, quindi puoi estrarre tutto dall'oggetto e verrà ordinato.

Un'altra opzione sarebbe capire come funzionano le mappe. Molte volte, una mappa o una mappa hash come vengono chiamate le cose, hanno un concetto di base dietro di esso.

Ad esempio ... inserisci un gruppo di coppie chiave-valore in cui la chiave è la lunga, e quando aggiungi tutti gli elementi, puoi fare: .keyse ti restituirà automaticamente un elenco ordinato.

Dipende da come elabori i dati prima di come penso che dovresti continuare con l'ordinamento e le successive inversioni

Il metodo di confronto di Comparator può essere utilizzato per confrontare gli oggetti e quindi il metodo reversed()può essere applicato per invertire l'ordine -

list.stream().sorted(Comparator.comparing(Employee::getName).reversed()).collect(toList());