Comment trier un ArrayList<Long>en Java par ordre décroissant?

Voici un moyen pour votre list:

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

Ou vous pouvez implémenter le vôtre Comparatorpour trier et éliminer l'étape inverse:

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

Ou encore plus simplement utiliser Collections.reverseOrder()puisque vous ne faites qu'inverser:

list.sort(Collections.reverseOrder());

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

Vous pouvez utiliser le code suivant qui est donné ci-dessous;

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

ou si vous allez utiliser un comparateur personnalisé, vous pouvez utiliser comme indiqué ci-dessous

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

Où CustomComparator est une classe de comparaison qui compare l'objet présent dans la liste.

Java 8

bien faire cela en java 8 est tellement amusant et plus facile

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

Les expressions lambda rockent ici !!!

au cas où vous auriez besoin d'une logique de plus d'une ligne pour comparer a et b, vous pourriez l'écrire comme ceci

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

Trier normalement et utiliser Collections.reverse();

Pour les lamdas où votre valeur longue est quelque part dans un objet, je recommande d'utiliser:

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

ou encore mieux:

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

Trier, puis inverser.

Une approche plus générale pour implémenter notre propre comparateur comme ci-dessous

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

En utilisant Collections.sort()avec un comparateur qui fournit l'ordre décroissant. Voir Javadoc pour Collections.sort .

L'approche suivante trier la liste par ordre décroissant et gère également les « nulles valeurs », juste au cas où si vous avez des valeurs nulles alors Collections.sort () jetteront 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);

        }
    });

Vous pouvez également trier un ArrayListavec un TreeSetau lieu d'un comparator. Voici un exemple d'une question que j'avais auparavant pour un tableau d'entiers. J'utilise "nombres" comme nom d'espace réservé pour le 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()+" ");
    }
}

Donc, il y a quelque chose que je voudrais soulever qui, à mon avis, est important et que vous devriez considérer. runtime et mémoire. Disons que vous avez une liste et que vous voulez la trier, eh bien, vous pouvez, il existe un tri intégré ou vous pouvez développer la vôtre. Ensuite, vous dites, voulez inverser la liste. Telle est la réponse qui est énumérée ci-dessus.

Si vous créez cette liste, il peut être bon d'utiliser une structure de données différente pour la stocker, puis de la vider dans un tableau.

Les tas font exactement cela. Vous filtrez les données et il gérera tout, puis vous pouvez tout retirer de l'objet et il serait trié.

Une autre option serait de comprendre le fonctionnement des cartes. Souvent, une carte ou un HashMap comme quelque chose que l'on appelle les choses, ont un concept sous-jacent.

Par exemple .... vous alimentez un tas de paires clé-valeur où la clé est la longue, et lorsque vous ajoutez tous les éléments, vous pouvez faire: .keyset il vous renverrait une liste triée automatiquement.

Cela dépend de la façon dont vous traitez les données avant de savoir comment je pense que vous devriez continuer votre tri et les inversions ultérieures.

La méthode de comparaison du comparateur peut être utilisée pour comparer les objets, puis la méthode reversed()peut être appliquée pour inverser l'ordre -

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