Wat is een vergelijkingsinterface in Java met voorbeelden?
De Comparator-interface bevat de methoden Compare() en Equals(). De eerste methode wordt gebruikt om twee objecten te berekenen door een geheel getal terug te geven. De andere methode wordt gebruikt voor het berekenen van twee comparatorobjecten voor gelijkheid.
Hier volgen verschillende voorbeelden van het gebruik van de Comparator-interface in Java:
Voorbeeld 1: Sorteer een lijst op basis van de lengte
In dit voorbeeld wordt een lijst met tekenreeksen beschouwd en worden ze gesorteerd op lengte in plaats van op alfabetische volgorde:
importeren java.util.ArrayList ;
importeren java.util.Collecties ;
importeren java.util.Comparator ;
importeren java.util.Lijst ;
openbaar klas Voornaamst {
openbaar statisch leegte voornaamst ( Snaar [ ] argumenten ) {
Lijst < Snaar > lijst = nieuw ArrayLijst <> ( ) ;
lijst. toevoegen ( 'John' ) ;
lijst. toevoegen ( 'Bob' ) ;
lijst. toevoegen ( 'Alice' ) ;
Collecties . soort ( lijst ) ;
Systeem . uit . println ( lijst ) ;
Collecties . soort ( lijst, nieuw StringLengthComparator ( ) ) ;
Systeem . uit . println ( lijst ) ;
}
} // Er wordt een klasse gedefinieerd
klas StringLengthComparator implementeert Comparator < Snaar > {
openbaar int vergelijken ( Snaar s1, Snaar s2 ) {
opbrengst Geheel getal . vergelijken ( s1. lengte ( ) , s2. lengte ( ) ) ;
}
}
De beschrijving van de bovenstaande code wordt hieronder gegeven:
- Maak eerst een aangepaste Comparator-klasse met de naam StringLengthComparator die de Comparator
-interface implementeert. - Het vervangt de methode Compare() voor het vergelijken van de lengte van twee strings.
- Geef uiteindelijk een instantie door aan de methode.sort() om de lijst te sorteren met behulp van onze aangepaste vergelijker.
Uitgang
De eerste uitvoer is het resultaat van het sorteren van de lijst met behulp van natuurlijke volgorde, terwijl de tweede uitvoer het resultaat is van het sorteren van de lijst met behulp van onze aangepaste comparator op basis van de lengte van elke string.
Voorbeeld 2: Objecten sorteren op basis van een specifiek veld
Een ander voorbeeld wordt uitgevoerd om objecten te sorteren op basis van een specifiek veld. De Comparator-interface wordt gebruikt om dit te bereiken:
importeren java.util.ArrayList ;importeren java.util.Collecties ;
importeren java.util.Comparator ;
importeren java.util.Lijst ;
openbaar klas Voornaamst {
openbaar statisch leegte voornaamst ( Snaar [ ] argumenten ) {
Lijst < Persoon > personen = nieuw ArrayLijst <> ( ) ; // Wijs naam, leeftijd en salarissen toe
personen. toevoegen ( nieuw Persoon ( 'Alice' , 25 , 50000 ) ) ;
personen. toevoegen ( nieuw Persoon ( 'Bob' , 30 , 75000 ) ) ;
personen. toevoegen ( nieuw Persoon ( 'Charlie' , twintig , 40000 ) ) ;
Comparator < Persoon > salarisComparator = nieuw Comparator < Persoon > ( ) {
// Sorteer personen op basis van salaris
openbaar int vergelijken ( Persoon p1, Persoon p2 ) {
opbrengst Geheel getal . vergelijken ( p2. krijg Salaris ( ) , p1. krijg Salaris ( ) ) ;
}
} ;
Collecties . soort ( personen, salarisComparator ) ; opbrengst sorteer waarden
// Druk een gesorteerde lijst van personen af
voor ( Persoon persoon : personen ) {
Systeem . uit . println ( persoon ) ;
}
}
}
klas Persoon { // Definieer naam, leeftijd en salaris
privaat Snaar naam ; // bereik binnen in een klasse
privaat int leeftijd ;
privaat int salaris ;
openbaar Persoon ( Snaar naam, int leeftijd, int salaris ) {
dit . naam = naam ;
dit . leeftijd = leeftijd ;
dit . salaris = salaris ;
}
openbaar Snaar getNaam ( ) {
opbrengst naam ;
}
openbaar int getLeeftijd ( ) {
opbrengst leeftijd ;
}
openbaar int krijg Salaris ( ) {
opbrengst salaris ;
}
openbaar Snaar naarString ( ) {
opbrengst naam + ' (leeftijd ' + leeftijd + ', salaris $' + salaris + ')' ;
}
}
De beschrijving van de code wordt hieronder gegeven:
- Een klas genaamd ' Persoon ” met drie velden: “ naam ”, “ leeftijd ', En ' salaris ' wordt overwogen.
- Sorteer daarna een verzameling persoonsobjecten op basis van hun salaris in aflopende volgorde.
Uitgang
De uitvoer laat zien dat de salarissen in aflopende volgorde zijn gesorteerd.
Conclusie
In Java is de Comparator-interface een krachtige tool waarmee gebruikers objecten kunnen sorteren op basis van aangepaste criteria. Het overschrijft de vergelijk() methode, gebruikers kunnen hun eigen vergelijkingsfunctie definiëren en deze gebruiken om verzamelingen objecten op verschillende manieren te sorteren. Dit artikel heeft de Comparator-interface uitgelegd samen met praktische voorbeelden in Java.