Collection.Reverseorder () en Java avec des exemples

La méthode Collections.reverseOrder() en Java fournit un moyen pratique d'inverser l'ordre naturel des éléments au sein d'une collection. Cette méthode renvoie un Comparator qui impose l'ordre inverse à une collection donnée. Il existe deux variations: une sans paramètres et une acceptant un Comparator.

existant

Collections.reverseOrder() (pas d'arguments)

Cette version renvoie un Comparator qui inverse l'ordre naturel des éléments. Il suppose que les éléments implémentent l'interface Comparable.

public static Comparator<Object> reverseOrder()

Collections.reverseOrder(Comparator<? super T> comp) (avec argument)

Cette version prend un Comparator (comp) existant en entrée et renvoie un nouveau Comparator qui inverse la commande définie par l'entrée Comparator.

public static <T> Comparator<T> reverseOrder(Comparator<? super T> comp)

Considérations clés pour l'utilisation de Comparator s:

• Paramètre: La méthode Comparator S compare "prend deux objets en entrée et renvoie un entier négatif, zéro ou un entier positif selon que le premier objet soit inférieur, égal à , ou supérieur au deuxième objet, respectivement. reverseOrder() inverse simplement le signe de ce résultat.
• Valeur de retour: Les méthodes reverseOrder() renvoient un objet Comparator. Cet objet est ensuite utilisé avec des méthodes de tri comme Collections.sort() ou Arrays.sort().

Algorithme (illustratif):

La logique centrale derrière Collections.reverseOrder() implique l'inversion du résultat de comparaison fourni par l'implémentation sous-jacente Comparable ou la fourniture Comparator. Cela inverse efficacement l'ordre de tri.

Exemples de syntaxe:

Exemple 1: Utilisation reverseOrder() avec une liste d'entiers:

List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 9);
Collections.sort(numbers, Collections.reverseOrder());
System.out.println(numbers); // Output: [9, 8, 5, 2, 1]

Exemple 2: Utilisation reverseOrder() avec un comparateur personnalisé:

Disons que nous avons une classe Student:

class Student implements Comparable<Student> {
    String name;
    int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Student other) {
        return Integer.compare(this.age, other.age); // Compare by age
    }
}

Nous pouvons trier une liste d'objets Student dans l'ordre inverse de l'âge:

List<Student> students = Arrays.asList(new Student("Alice", 20), new Student("Bob", 25), new Student("Charlie", 18));
Collections.sort(students, Collections.reverseOrder());
for (Student s : students) {
    System.out.println(s.name + ": " + s.age);
}
// Output (order may vary slightly depending on JVM):
// Bob: 25
// Alice: 20
// Charlie: 18

Exemple 3: Utilisation reverseOrder(Comparator c):

List<String> strings = Arrays.asList("apple", "banana", "orange");
Comparator<String> lengthComparator = Comparator.comparingInt(String::length);
Collections.sort(strings, Collections.reverseOrder(lengthComparator));
System.out.println(strings); // Output: [banana, orange, apple] (sorted by length in descending order)

En résumé, Collections.reverseOrder() offre un moyen concis et efficace d'inverser l'ordre des éléments dans les collections Java, s'adaptant à la fois à la commande naturelle et à la logique de comparaison personnalisée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!