Arrays-klasse, deel 2

1.Arrays.fill()

Bij het werken met arrays moeten Java-programmeurs de array vaak met dezelfde waarde vullen. Je kunt natuurlijk een lus schrijven en eenvoudig een waarde toekennen aan elke cel van de array in de lus:

int[] x = new int[100];
for (int i = 0; i < x.length; i++)
x[i] = 999;

Of je kunt gewoon de methode aanroepen Arrays.fill(), die precies hetzelfde doet: het vult de doorgegeven array met de doorgegeven waarde. Zo ziet het eruit:

Arrays.fill(name, value)

En de code in bovenstaand voorbeeld kan iets compacter en duidelijker gemaakt worden:

int[] x = new int[100];
Arrays.fill(x, 999);

Je kunt de Arrays.fill()methode ook gebruiken om niet de hele array, maar een deel ervan met een bepaalde waarde te vullen:

Arrays.fill(name, first, last, value)

Waar eerst en laatste de indices zijn van de eerste en laatste cellen die moeten worden gevuld.

Voorbeeld:

int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

Arrays.fill(x, 3, 7, 999);


String str = Arrays.toString(x);

"[1, 2, 3, 999, 999, 999, 999, 8, 9, 10]"

De Arrays.fill()methode werkt alleen met eendimensionale arrays. Als u een tweedimensionale array aan de methode doorgeeft, wordt deze als eendimensionaal behandeld, met alle gevolgen van dien.

2.Arrays.copyOf()

Zoals u al weet, kunt u de grootte van een array niet wijzigen nadat deze is gemaakt.

Maar wat als je het echt wilt?

Nou, als je het echt wilt, dan kan het!

• Maak een nieuwe array van de gewenste lengte
• Kopieer alle elementen van de eerste array erin.

Dit is trouwens precies wat de Arrays.copyOf()methode doet. Zo ziet bellen eruit:

Type[] name2 = Arrays.copyOf(name, length);

Deze methode verandert de bestaande array niet , maar maakt in plaats daarvan een nieuwe array en kopieert de elementen van de oude array erin.

Als de elementen niet passen (de lengte is kleiner dan de lengte van de bestaande array ), worden de extra waarden genegeerd.

Als de lengte van de nieuwe array groter is dan de lengte van de oude, worden de cellen gevuld met nullen.

Voorbeeld:

int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

int[] x2 = Arrays.copyOf(x, 5);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOf(x, 15);
String str3 = Arrays.toString(x3);

"[1, 2, 3, 4, 5]"

"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0]"

3.Arrays.copyOfRange()

En wat als u een array met lengte 5 wilt krijgen uit een array met lengte 10, maar u wilt dat deze de laatste 5 elementen bevat in plaats van de eerste 5?

In dit geval Arrayskomt een andere methode van de klasse goed van pas: de Arrays.copyOfRange(). Zo ziet het eruit als we het noemen:

Type[] name2 = Arrays.copyOfRange(name, first, last);

Deze methode creëert ook een nieuwe array, maar vult deze met elementen van een willekeurige plaats in de originele array. Waar eerste en laatste de indices zijn van de eerste en laatste elementen die in de nieuwe array moeten worden geplaatst.

Voorbeeld:

int[] x = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20};

int[] x2 = Arrays.copyOfRange(x, 5, 10);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOfRange(x, 5, 15);
String str3 = Arrays.toString(x3);

"[16, 17, 18, 19, 20]"

"[16, 17, 18, 19, 20, 0, 0, 0, 0, 0]"

4.Arrays.sort()

Ah, de lekkerste traktatie: sorteren . Arrays worden tijdens het programmeren vrij vaak gesorteerd. De drie meest voorkomende acties bij het werken met arrays zijn:

• Een array sorteren
• Het minimale (of maximale) element van een array vinden
• De index van een element in een array bepalen (een element in een array vinden)

Dit is precies waarom de makers van Java de sort()methode in de Arraysklas hebben opgenomen. Zo ziet bellen eruit:

Arrays.sort(name);

Deze methode sorteert de doorgegeven array in oplopende volgorde.

Voorbeeld:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x);

String str = Arrays.toString(x);

"[-20, -20, -20, -2, 0, 3, 8, 11, 99, 999]"

Uitstekend, toch? Je hebt één methode aangeroepen en nu heb je een gesorteerde array. Mooi.

Overigens kun je deze methode gebruiken om niet alleen de hele array te sorteren, maar slechts een deel ervan. Zo ziet bellen eruit:

Arrays.sort(name, first, last);

Waar eerste en laatste de indices zijn van de eerste en laatste cellen die de sortering zou moeten raken.

Voorbeeld:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x, 4, 8);
String str = Arrays.toString(x);

"[11, -2, 3, 0, -20, -20, 8, 999, 99, -20]"

Om arrays te sorteren, gebruikt Java het snelste sorteeralgoritme: QuickSort . De computationele complexiteit hangt af van de grootte van de array en wordt berekend met de formule N log(N).

Het sorteren van een array van 1000 elementen omvat ongeveer 3000 vergelijkingen van array-elementen. Het sorteren van een reeks van een miljoen elementen zal ongeveer 6 miljoen vergelijkingen met zich meebrengen.

5.Arrays.binarySearch()

Welnu, en de laatste van de meest interessante methoden van de Arraysklasse is in staat om naar een bepaalde waarde in een array te zoeken. Dit is geen gewone zoekopdracht - het is de geliefde binaire zoekopdracht . Het komt hier op neer:

• Eerst wordt de array gesorteerd.
• Vervolgens wordt het middelste element van de array vergeleken met het element waarnaar we op zoek zijn.
• Als het element groter is dan het middelste element, gaat het zoeken verder in de rechterhelft van de array.
• Als het element waarnaar we zoeken kleiner is dan het middelste element, gaat het zoeken verder in de linkerhelft van de array.

Omdat de array gesorteerd is, is het mogelijk om de helft ervan in één vergelijking te elimineren. In de volgende stap gooien we nog een helft weg, enzovoort.

Deze benadering maakt binair zoeken erg snel. In een reeks van een miljoen (!) elementen kan het de index van het gewenste element vinden in slechts 20 vergelijkingen. De tekortkoming van de aanpak is dat de array eerst moet worden gesorteerd, en sorteren kost ook tijd.

Zo ziet bellen eruit:

int index = Arrays.binarySearch(name, value);

Waar nameis de naam van de array, die al gesorteerd moet worden doorgegeven (bijvoorbeeld met behulp van de Arrays.sort()methode). En valueis het element waarnaar we zoeken in de array. Het resultaat dat door de methode wordt geretourneerd, is de index van het gewenste array-element .

Voorbeelden:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};
Arrays.sort(x);

int index1 = Arrays.binarySearch(x, 0);
int index2 = Arrays.binarySearch(x, -20);
int index3 = Arrays.binarySearch(x, 99);
int index4 = Arrays.binarySearch(x, 5);

{-20, -20, -20, -2, 0, 3, 8, 11, 99, 999}

Als de array meerdere instanties bevat van het element waarnaar wordt gezocht, dan retourneert het algoritme eenvoudigweg de index van een van hen (er is geen garantie dat dit bijvoorbeeld de allereerste is, of vice versa - de allerlaatste hiervan). dubbele elementen)."

Als het element niet in de array wordt gevonden, is de index negatief.

6. Link naar Oracle-documentatie over de Arraysklasse

Als je erg geïnteresseerd bent, kun je alles over de Arraysklasse en al zijn methoden lezen in de officiële documentatie a href="https://docs.oracle.com/en/java/javase/14/docs/api/java.base /java/util/Arrays.html">op de Oracle-website.

U kunt bijvoorbeeld lezen over de methoden Arrays.mismatch()en Arrays.compare(). Misschien vind je ze op de een of andere manier nuttig.

En laat u niet verwarren door het aantal methoden. Elke methode heeft 5-10 varianten, die alleen verschillen in hun parametertypes.