Comparateur de tri en Java

1. Utilisez le DepartmentComparator pour trier les éléments en Java
2. Modifier le programme ci-dessus à l’aide de la fonction lambda dans Java 8

Cet article définit ce qu’est un comparateur de tri en Java et montre comment l’utiliser dans les processus. Nous avons inclus des programmes que vous pouvez suivre pour vous aider à mieux comprendre ce concept.

Utilisez le DepartmentComparator pour trier les éléments en Java

Le tri est le processus d’organisation des structures de données comme un tableau liste dans un ordre séquentiel défini. Le processus fonctionne en comparant les éléments de données, définissant ainsi les nouvelles positions. Il existe différents types d’algorithmes de tri définis en Java qui sont utiles en fonction de la complexité de la structure.

Vous trouverez ci-dessous le bloc de code qui définit le remplacement de l’interface du comparateur pour donner notre implémentation pour le tri des éléments.

import java.util.*;

public class DepartmentComparator {
  public static void main(String[] args) {
    List<Department> departments = Arrays.asList(new Department("dept1", 2001),
        new Department("dept2", 1998), new Department("dept3", 2021));
    Collections.sort(departments, new LexicographicComparator());
    System.out.println("Sorting on the basis of name: " + departments);
    Collections.sort(departments, new YearComparator());
    System.out.println("Sorting on the basis of year: " + departments);
  }

  static class LexicographicComparator implements Comparator<Department> {
    @Override
    public int compare(Department a, Department b) {
      return a.name.compareToIgnoreCase(b.name);
    }
  }

  static class YearComparator implements Comparator<Department> {
    @Override
    public int compare(Department a, Department b) {
      return a.establish_year < b.establish_year ? -1
          : a.establish_year == b.establish_year ? 0
                                                 : 1;
    }
  }

  static class Department {
    String name;
    int establish_year;

    Department(String n, int a) {
      name = n;
      establish_year = a;
    }

    @Override
    public String toString() {
      return String.format("{name=%s, Establish Year=%d}", name, establish_year);
    }
  }
}

Dans le programme ci-dessus, la classe DepartmentComparator est une classe publique qui contient la méthode principale et agit comme le code du pilote. Outre la classe principale, le code contient des classes non publiques qui ont été ajoutées pour montrer la fonctionnalité. La classe Department est un POJO qui contient un nom de champ et la variable establish_year et la fonction toString() surchargée. Outre la classe bean, une classe LexicographicComparator et une classe YearComparator implémentent l’interface Comparator.

Dans la méthode statique, une Liste est initialisée avec trois éléments. Le Array.asList est une méthode statique qui renvoie une List de taille fixe. La fonction prend des instances de la classe à transformer en liste. Ainsi, l’instance department class est créée à l’aide d’un nouveau mot-clé et est maintenant appelée le constructeur parameterized. Ce constructeur initialise le nom et établit une année à partir des paramètres passés.

Une fois la liste créée, la méthode sort est invoquée de la classe Collections. Il trie la liste ou la collection définie en fonction du comparateur donné. La méthode prend un comparateur manuel et retourne void mais modifie la collection passée en argument. La méthode lève une ClassCastException lorsque les éléments sont d’un type différent. La méthode prend une collection de liste comme premier argument et un comparateur manuel comme deuxième argument.

Les classes LexicographicComparator et YearComparator sont créées pour une comparaison manuelle. Les classes implémentent une interface fonctionnelle qui est Comparator avec une seule méthode compare qui renvoie une valeur int basée sur la comparaison. La méthode est remplacée dans la classe définie par l’utilisateur où l’implémentation spécifiée par l’utilisateur peut être définie.

Dans la classe LexicographicComparator, la méthode spécifie une condition basée sur le nom, compare les arguments passés et renvoie -1, 0 ou -1 selon que l’entrée est inférieure, supérieure ou égale l’un à l’autre. De même, la méthode YearComparator est surchargée pour comparer l’année passée en argument.

Vous trouverez ci-dessous la sortie classée par noms, par ordre croissant et par année.

Sorting on the basis of name: [{name=dept1, Establish Year=2001}, {name=dept2, Establish Year=1998}, {name=dept3, Establish Year=2021}]
Sorting on the basis of year: [{name=dept2, Establish Year=1998}, {name=dept1, Establish Year=2001}, {name=dept3, Establish Year=2021}]

Modifier le programme ci-dessus à l’aide de la fonction lambda dans Java 8

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class DepartmentCompareUsingJava8 {
  public static void main(String[] args) {
    List<DepartmentComparator.Department> departments =
        Arrays.asList(new DepartmentComparator.Department("dept1", 2001),
            new DepartmentComparator.Department("dept2", 1998),
            new DepartmentComparator.Department("dept3", 2021));
    Collections.sort(departments, (a, b) -> a.name.compareToIgnoreCase(b.name));
    System.out.println(departments);
    Collections.sort(departments,
        (a, b)
            -> a.establish_year < b.establish_year ? -1
            : a.establish_year == b.establish_year ? 0
                                                   : 1);
    System.out.println(departments);
  }
}

La différence dans ce programme est qu’au lieu de définir les nouvelles classes qui implémentent l’interface Comparator, Java 8 functional interface permet de réduire la surcharge de traitement dans une nouvelle classe à chaque fois. Functional Interface a une seule méthode non implémentée ou méthode abstract. Il réduit la surcharge de création d’une classe qui implémente des interfaces et donne sa propre version de méthode.

Il utilise les fonctions lambda ()-> pour appeler directement la méthode. Les lambdas traitent les fonctions comme un argument et ne nécessitent aucune classe pour l’instanciation. La fonction prend des paramètres et donne l’implémentation dans la même ligne plutôt que dans une classe séparée.

La sortie du programme ci-dessus est la même que celle du premier code.