Qu'est-ce que l'interface de comparaison en Java avec des exemples ?
L'interface Comparator contient les méthodes compare() et equals(). La première méthode est utilisée pour calculer deux objets en retournant une valeur entière. L'autre méthode est utilisée pour calculer l'égalité de deux objets comparateurs.
Voici différents exemples d'utilisation de l'interface Comparator en Java :
Exemple 1 : Trier une liste en fonction de la longueur
Dans cet exemple, une liste de chaînes est considérée et triée en fonction de leur longueur au lieu de l'ordre alphabétique :
importer java.util.ArrayList ;
importer java.util.Collections ;
importer java.util.Comparator ;
importer java.util.List ;
public classe Principal {
public statique annuler principal ( Chaîne [ ] arguments ) {
Liste < Chaîne > liste = nouveau Liste des tableaux <> ( ) ;
liste. ajouter ( 'John' ) ;
liste. ajouter ( 'Bob' ) ;
liste. ajouter ( 'Alice' ) ;
Collections . trier ( liste ) ;
Système . dehors . println ( liste ) ;
Collections . trier ( liste, nouveau StringLengthComparator ( ) ) ;
Système . dehors . println ( liste ) ;
}
} // Une classe est définie
classe StringLengthComparator met en oeuvre Comparateur < Chaîne > {
public entier comparer ( Chaîne s1, Chaîne s2 ) {
retour Entier . comparer ( s1. longueur ( ) , s2. longueur ( ) ) ;
}
}
La description du code ci-dessus est donnée ci-dessous :
- Tout d'abord, créez une classe Comparator personnalisée appelée StringLengthComparator qui implémente l'interface Comparator
. - Elle remplace la méthode compare() pour comparer la longueur de deux chaînes.
- À la fin, passez une instance à la méthode.sort() pour trier la liste à l'aide de notre comparateur personnalisé.
Sortir
La première sortie est le résultat du tri de la liste en utilisant l'ordre naturel, tandis que la seconde sortie est le résultat du tri de la liste à l'aide de notre comparateur personnalisé en fonction de la longueur de chaque chaîne.
Exemple 2 : Trier des objets en fonction d'un champ spécifique
Un autre exemple est réalisé pour trier des objets en fonction d'un champ spécifique. L'interface Comparator est utilisée pour y parvenir :
importer java.util.ArrayList ;importer java.util.Collections ;
importer java.util.Comparator ;
importer java.util.List ;
public classe Principal {
public statique annuler principal ( Chaîne [ ] arguments ) {
Liste < Personne > personnes = nouveau Liste des tableaux <> ( ) ; // Attribuez le nom, l'âge et les salaires
personnes. ajouter ( nouveau Personne ( 'Alice' , 25 , 50000 ) ) ;
personnes. ajouter ( nouveau Personne ( 'Bob' , 30 , 75000 ) ) ;
personnes. ajouter ( nouveau Personne ( 'Charlie' , vingt , 40000 ) ) ;
Comparateur < Personne > comparateur de salaire = nouveau Comparateur < Personne > ( ) {
// Trier les personnes en fonction du salaire
public entier comparer ( Personne p1, Personne p2 ) {
retour Entier . comparer ( p2. obtenirSalaire ( ) , p1. obtenirSalaire ( ) ) ;
}
} ;
Collections . trier ( personnes, salaireComparateur ) ; retour trier les valeurs
// Imprimer une liste triée de personnes
pour ( Personne personne : personnes ) {
Système . dehors . println ( personne ) ;
}
}
}
classe Personne { // Définir le nom, l'âge et le salaire
privé Chaîne nom ; // portée dans une classe
privé entier âge ;
privé entier salaire ;
public Personne ( Chaîne nom, entier âge, entier salaire ) {
ce . nom = nom ;
ce . âge = âge ;
ce . salaire = salaire ;
}
public Chaîne obtenirNom ( ) {
retour nom ;
}
public entier obtenirÂge ( ) {
retour âge ;
}
public entier obtenirSalaire ( ) {
retour salaire ;
}
public Chaîne toString ( ) {
retour nom + ' (âge ' + âge + ', salaire $' + salaire + ')' ;
}
}
La description du code est donnée ci-dessous :
- Une classe appelée ' Personne ' avec trois champs : ' nom ”, “ âge ', et ' salaire ' est considéré.
- Après cela, triez une collection d'objets Person en fonction de leur salaire par ordre décroissant.
Sortir
La sortie montre que les salaires ont été triés par ordre décroissant.
Conclusion
En Java, l'interface Comparator est un outil puissant qui permet aux utilisateurs de trier des objets en fonction de critères personnalisés. Elle remplace la méthode compare(), les utilisateurs peuvent définir leur propre fonction de comparaison et l'utiliser pour trier des collections d'objets de différentes manières. Cet article a expliqué l'interface Comparator avec des exemples pratiques en Java.