Como classificar um ArrayList<Long>em Java em ordem decrescente?

Esta é uma maneira de list:

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

Ou você pode implementar o seu próprio Comparatorpara classificar e eliminar a etapa inversa:

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

Ou ainda mais simplesmente use, Collections.reverseOrder()já que você está apenas revertendo:

list.sort(Collections.reverseOrder());

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

Você pode usar o código a seguir, fornecido a seguir;

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

ou se você for usar um comparador personalizado, você pode usar como é fornecido abaixo

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

Onde CustomComparator é uma classe comparadora que compara o objeto que está presente na lista.

Java 8

bem fazer isso em java 8 é muito divertido e fácil

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

Expressões lambda arrasam aqui !!!

no caso de você precisava de uma lógica mais de uma linha para comparar um e b você poderia escrevê-lo como este

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

Classifique normalmente e use Collections.reverse();

Para lamdas em que o valor longo está em algum lugar de um objeto, recomendo usar:

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

ou ainda melhor:

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

Classifique e depois inverta.

Uma abordagem mais geral para implementar nosso próprio Comparador conforme abaixo

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

Usando Collections.sort()com um comparador que fornece a ordem decrescente. Consulte Javadoc para Collections.sort .

A abordagem a seguir classificará a lista em ordem decrescente e também lida com os valores ' nulos ', apenas no caso de você ter algum valor nulo, Collections.sort () lançará 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);

        }
    });

Você também pode classificar um ArrayListcom um em TreeSetvez de um comparator. Aqui está um exemplo de uma pergunta que tive antes sobre uma matriz de inteiros. Estou usando "números" como um nome de espaço reservado para o 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()+" ");
    }
}

Portanto, há algo que gostaria de mencionar que considero importante e que você deve considerar. tempo de execução e memória. Digamos que você tenha uma lista e queira classificá-la, bem, você pode; existe uma classificação incorporada ou você poderia desenvolver a sua própria. Então você diz, quer reverter a lista. Essa é a resposta listada acima.

No entanto, se você estiver criando essa lista, pode ser bom usar uma estrutura de dados diferente para armazená-la e depois apenas despejá-la em um array.

Montes fazem exatamente isso. Você filtra os dados e ele tratará de tudo, então você pode retirar tudo do objeto e seria classificado.

Outra opção seria entender como funcionam os mapas. Muitas vezes, um mapa ou HashMap, como as coisas são chamadas, tem um conceito subjacente por trás dele.

Por exemplo ... você alimenta um monte de pares de valores-chave onde a chave é longa, e quando você adiciona todos os elementos, você pode fazer: .keyse ele retornaria para você uma lista classificada automaticamente.

Depende de como você processa os dados antes de como eu acho que você deve continuar com sua classificação e reversões subsequentes

O método de comparação do comparador pode ser usado para comparar os objetos e, em seguida, o método reversed()pode ser aplicado para inverter a ordem -

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