streamalism.org

1. Overzicht

In deze zelfstudie bespreken we veelgebruikte methoden om arrays in oplopende en aflopende volgorde te sorteren.

We zullen kijken naar het gebruik van Java's Arrays class sorteermethode en het implementeren van onze eigen Comparator om de waarden van onze arrays te ordenen.

2. Objectdefinities

Laten we, voordat we beginnen, snel een paar arrays definiëren die we in deze tutorial zullen sorteren. Eerst maken we een reeks ints en een reeks strings:

int [] nummers = nieuwe int [] {-8, 7, 5, 9, 10, -2, 3}; String [] strings = nieuwe String [] {"learning", "java", "with", "baeldung"};

En laten we ook een reeks Werknemer objecten waar elke werknemer een ID kaart en een naam attribuut:

Medewerker john = nieuwe medewerker (6; "Jan"); Medewerker mary = nieuwe medewerker (3, "Mary"); Werknemer david = nieuwe werknemer (4, "David"); Werknemer [] werknemers = nieuwe werknemer [] {john, mary, david};

3. Sorteren in oplopende volgorde

Java's util.Arrays.sort methode biedt ons een snelle en eenvoudige manier om een ​​reeks primitieven of objecten te sorteren die de Vergelijkbaar interface in oplopende volgorde.

Bij het sorteren van primitieven, de Arrays.sort methode maakt gebruik van een Dual-Pivot-implementatie van Quicksort. Bij het sorteren van objecten wordt echter een iteratieve implementatie van MergeSort gebruikt.

3.1. Primitieven

Om een ​​primitieve array in oplopende volgorde te sorteren, geven we onze array door aan de soort methode:

Arrays.sort (getallen); assertArrayEquals (new int [] {-8, -2, 3, 5, 7, 9, 10}, getallen); 

3.2. Objecten die vergelijkbare implementeren

Voor objecten die het Vergelijkbaar interface, net als bij onze primitieve array, kunnen we onze array ook gewoon doorgeven aan de soort methode:

Arrays.sort (strings); assertArrayEquals (new String [] {"baeldung", "java", "learning", "with"}, strings);

3.3. Objecten die niet vergelijkbaar zijn

Objecten sorteren die het Vergelijkbaar Interface, zoals onze reeks Werknemers, vereist dat we onze eigen comparator specificeren.

We kunnen dit heel gemakkelijk doen in Java 8 door de eigenschap te specificeren die we onze willen vergelijken Werknemer objecten op binnen onze Comparator:

Arrays.sort (werknemers, Comparator.comparing (Employee :: getName)); assertArrayEquals (nieuwe werknemer [] {david, john, mary}, werknemers);

In dit geval hebben we aangegeven dat we onze medewerkers graag bij hun bestellen naam attributen.

We kunnen onze objecten ook sorteren op meer dan één attribuut door onze vergelijkingen aan elkaar te koppelen met De vergelijker is dan het vergelijken methode:

Arrays.sort (werknemers, Comparator.comparing (Employee :: getName) .thenComparing (Employee :: getId));

4. Sorteren in aflopende volgorde

4.1. Primitieven

Het sorteren van een primitieve array in aflopende volgorde is niet zo eenvoudig als het in oplopende volgorde sorteren, omdat Java het gebruik van Vergelijkers op primitieve typen. Om dit tekort te verhelpen, hebben we een aantal opties.

Ten eerste zouden we dat kunnen sorteer onze array in oplopende volgorde en voer vervolgens een in-place omkering uit van de array.

Ten tweede, zou onze array kunnen converteren naar een lijst, gebruik Guava's Lists.reverse () methode en converteer vervolgens onze lijst weer naar een array.

Ten slotte kunnen we onze array transformeren naar een Stroom en wijs het vervolgens weer toe aan een int array. Het heeft een mooi voordeel om te zijn een one-liner en alleen core Java gebruiken:

nummers = IntStream.of (nummers) .boxed (). gesorteerd (Comparator.reverseOrder ()). mapToInt (i -> i) .toArray (); assertArrayEquals (new int [] {10, 9, 7, 5, 3, -2, -8}, getallen);

De reden dat dit werkt, is dat Verpakt draait elk int in een Geheel getal, welke doet implementeren Comparator.

4.2. Objecten die vergelijkbare implementeren

Het sorteren van een objectarray die de Vergelijkbaar interface in aflopende volgorde is vrij eenvoudig. Het enige wat we hoeven te doen is een Comparator als de tweede parameter van onze soort methode.

In Java 8 kunnen we gebruiken Comparator.reverseOrder () om aan te geven dat we willen dat onze array in aflopende volgorde wordt gesorteerd:

Arrays.sort (strings, Comparator.reverseOrder ()); assertArrayEquals (new String [] {"with", "learning", "java", "baeldung"}, strings);

4.3. Objecten die niet vergelijkbaar zijn

Net als bij het sorteren van objecten die vergelijkbare implementeren, kunnen we de volgorde van onze gewoonte omkeren Comparator door toe te voegen omgekeerd() aan het einde van onze vergelijkingsdefinitie:

Arrays.sort (werknemers, Comparator.comparing (Employee :: getName) .reversed ()); assertArrayEquals (nieuwe werknemer [] {mary, john, david}, werknemers);

5. Conclusie

In dit artikel hebben we besproken hoe arrays van primitieven en objecten in oplopende en aflopende volgorde kunnen worden gesorteerd met behulp van de Arrays.sort methode.

Zoals gewoonlijk is de broncode van dit artikel te vinden op Github.