Essayer de passer un comparateur via le constructeur d'un HashSet

Vous pouvez utiliser un TreeSet qui garantit un Set ordonné basé sur le Comparator

Queue<Employee> list = new PriorityQueue<>(Comparator.comparingInt(Employee::getAge));

Le HashSet d'autre part n'accepte pas un comparateur dans son constructeur pour l'initialisation.

Modifier :

Set<Employee> employeeSet = new TreeSet<>(Comparator.comparingInt(Employee::getAge));
// (a, b) -> a.getAge() - b.getAge() >>> Comparator.comparingInt(Employee::getAge

fonctionne bien puisque, PriorityQueue est à nouveau une collection ordonnée qui accepte un comparateur dans l'un des ses constructeurs.

D'un point de vue mécanique, un HashSet ne repose pas sur un comparateur ou sur l'interface Comparable pour déterminer l'ordre ou l'unicité; à la place, il repose sur le hashCode des éléments individuels que vous placez à l'intérieur.

C'est pourquoi vous ne pouvez pas l'ajouter comme paramètre de constructeur; cela n'a aucun sens d'essayer d'insérer dans une carte de hachage des valeurs qui ont un ordre naturel. Sauf indication contraire de l'implémentation de l'ensemble, les ensembles sont par défaut non ordonnés ; HashSet est une implémentation non ordonnée d'un ensemble.

La raison pour laquelle PriorityQueue et TreeMap fonctionnent avec des comparateurs et des éléments Comparables est due à la façon dont ils sont structurés. Les éléments de commande PriorityQueue et TreeMap dans l'ordre naturel , donc avoir un Comparateur pour piloter cela en l'absence de vos éléments implémentant Comparable peut être souhaitable. Ces structures de données sont ordonnées , donc imposer un ordre personnalisé est une fonctionnalité pour celles-ci.

Comme d'autres l'ont noté, HashSet est un ensemble non ordonné, et il ne peut donc pas prendre un comparateur qui fournit un ordre de tri. Vous voudrez peut-être utiliser un ensemble trié tel que TreeSet à la place.

    [Employee{name=Chris, age=26}, Employee{name=Kelly, age=26}, Employee{name=Brett, age=32}, Employee{name=Terry, age=37}]

Une note rapide sur les comparaisons numériques. L'utilisation de la soustraction pour comparer les valeurs int est dangereuse, car elle peut donner des résultats incorrects si la soustraction déborde. Cela ne se produira pas avec l'âge des personnes dont la fourchette typique n'entraînera pas de débordement. Mais si quelqu'un copiait ce code et l'appliquait à des valeurs différentes, cela pourrait entraîner des bogues. Au lieu de cela, je recommande d'utiliser les méthodes utilitaires Comparator pour construire la bonne fonction de comparaison:

    Set<Employee> employeeSet = new TreeSet<>(Comparator.comparingInt(Employee::getAge)
                                                        .thenComparing(Employee::getName));

Cela triera effectivement les employés par âge. Cependant ...

    employeeList.sort(Comparator.comparingInt(Employee::getAge));

    // before
    [Employee{name=Terry, age=37}, Employee{name=Kelly, age=26}, Employee{name=Brett, age=32}, Employee{name=Chris, age=26}]

    // after
    [Employee{name=Kelly, age=26}, Employee{name=Chris, age=26}, Employee{name=Brett, age=32}, Employee{name=Terry, age=37}]

Nous avons ajouté quatre employés, mais il n'y a que trois employés dans l'ensemble! Aussi:

    System.out.println(employeeSet.contains(kelly)); // true
    System.out.println(employeeSet.contains(chris)); // true

Comment est-ce possible? Le comparateur fourni est utilisé non seulement pour la commande , mais il est également utilisé pour déterminer l'appartenance à l'ensemble . Puisque Kelly et Chris ont le même âge, ce comparateur les considère comme égaux, donc un seul d'entre eux se retrouve dans l'ensemble.

Vous ne voulez probablement pas utiliser un TreeSet pour faire le tri par valeurs qui peuvent avoir des doublons, car cela entraînera la perte d'éléments. Vous pouvez faire plusieurs choses. Premièrement, vous pouvez mettre les employés dans une liste puis trier la liste:

    Employee terry = new Employee("Terry", 37);
    Employee kelly = new Employee("Kelly", 26);
    Employee brett = new Employee("Brett", 32);
    Employee chris = new Employee("Chris", 26);
    List<Employee> employeeList = Arrays.asList(terry, kelly, brett, chris);
    Set<Employee> employeeSet = new TreeSet<>(Comparator.comparingInt(Employee::getAge));
    employeeSet.addAll(employeeList);
    System.out.println(employeeSet);

    [Employee{name=Kelly, age=26}, Employee{name=Brett, age=32}, Employee{name=Terry, age=37}]

Ou, vous pouvez écrire un comparateur plus complexe qui différencie chaque élément des données d'entrée, de sorte qu'aucun deux ne soit considéré comme un double. Dans un exemple réaliste, les employés peuvent avoir le même nom, nous pouvons donc également souhaiter inclure une comparaison de quelque chose de vraiment unique, comme un identifiant d'employé. Cependant, pour cet exemple simple, nous pouvons simplement trier le nom de l'employé:

    Set<Employee> employeeSet = new TreeSet<>(Comparator.comparingInt(Employee::getAge));

Lorsque tous les employés sont ajoutés, le résultat est:

    Set<Employee> employeeSet = new TreeSet<>((a,b)->a.getAge()-b.getAge());