¿Cómo ordenar un ArrayList<Long>en Java en orden decreciente?

Aquí tienes una forma de list:

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

O puede implementar el suyo propio Comparatorpara ordenar y eliminar el paso inverso:

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

O incluso más simplemente úselo Collections.reverseOrder()ya que solo está invirtiendo:

list.sort(Collections.reverseOrder());

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

Puede utilizar el siguiente código que se proporciona a continuación;

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

o si va a utilizar un comparador personalizado, puede utilizarlo como se indica a continuación

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

Donde CustomComparator es una clase de comparador que compara el objeto que está presente en la lista.

Java 8

Bueno, hacer esto en Java 8 es mucho más divertido y fácil.

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

¡¡¡Las expresiones lambda se mueven aquí !!!

en caso de que necesitaba una lógica más de una línea para comparar una y b se puede escribir como este

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

Ordene normalmente y use Collections.reverse();

Para lamdas donde su valor largo está en algún lugar de un objeto, recomiendo usar:

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

o mejor:

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

Ordene, luego invierta.

Un enfoque más general para implementar nuestro propio comparador como se muestra a continuación

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

Utilizándolo Collections.sort()con un comparador que proporciona el orden decreciente. Consulte Javadoc para Collections.sort .

El siguiente enfoque ordenará la lista en orden descendente y también manejará los valores ' nulos ', en caso de que tenga algún valor nulo, Collections.sort () arrojará 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);

        }
    });

También puede ordenar un ArrayListcon a en TreeSetlugar de a comparator. Aquí hay un ejemplo de una pregunta que tenía antes para una matriz de enteros. Estoy usando "números" como nombre de marcador de posición para 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()+" ");
    }
}

Entonces, hay algo que me gustaría mencionar que creo que es importante y creo que debería considerar. tiempo de ejecución y memoria. Digamos que tiene una lista y quiere ordenarla, bueno, puede, hay una lista incorporada o podría desarrollar la suya propia. Entonces dices, quieres invertir la lista. Esa es la respuesta que se enumera arriba.

Sin embargo, si está creando esa lista, podría ser bueno usar una estructura de datos diferente para almacenarla y luego simplemente volcarla en una matriz.

Montones hacen precisamente esto. Filtra los datos y se encargará de todo, luego puede sacar todo del objeto y se ordenará.

Otra opción sería comprender cómo funcionan los mapas. Muchas veces, un Mapa o HashMap, como se llaman las cosas, tiene un concepto subyacente detrás.

Por ejemplo ... ingresa un grupo de pares clave-valor donde la clave es la larga, y cuando agrega todos los elementos, puede hacer: .keysy le devolverá una lista ordenada automáticamente.

Depende de cómo procese los datos antes de cómo creo que debe continuar con su clasificación y posteriores reversiones

El método de comparación del comparador se puede utilizar para comparar los objetos y luego reversed()se puede aplicar el método para invertir el orden:

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