Arrays-klasse, deel 2

"Rishi, ik kijk er echt naar uit om de rest van de methoden van de klasse Arrays te leren kennen.

"Zo'n leergierigheid zal je oude leraar alleen maar plezieren! Maar als je echt alles wilt weten, zal een vriendelijke tovenaar genaamd Google je dag en nacht helpen."

"Eh..."

"Grapje. Een beetje. Natuurlijk zal ik alles beter uitleggen, maar als er iets opkomt, denk dan aan de goede tovenaar. Ik zal de les van vandaag beginnen met de Arrays.fillmethode

"Bij het werken met arrays moeten Java-programmeurs heel vaak de array 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 in plaats van dit alles kun je de Arrays.fill()methode aanroepen, 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);

"Mooi!"

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

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

"Waar eerste en laatste zijn de indexen van de eerste en laatste cellen die moeten worden gevuld.

" In overeenstemming met Java's goede (of slechte) oude traditie, onthoud dat het laatste element niet in het assortiment is opgenomen.

Voorbeeld:

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

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


String str = Arrays.toString(x);

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

Arrays.copyOf()

"Amigo, vertel me alsjeblieft hoe ik de grootte van een array kan wijzigen nadat deze is gemaakt?"

"Umm... Dat is een strikvraag, toch? Zo onervaren ben ik niet meer. Het juiste antwoord is dat dat niet kan! Je kunt de grootte van een array niet wijzigen nadat deze is gemaakt."

"Maar wat als je het echt wilt?"

"Het is nog steeds onmogelijk!

"Eigenlijk, als je het echt wilt, dan kan het! Met behulp van een programmeertruc:

1. Eerst maak je een nieuwe array van de gewenste lengte aan
2. Vervolgens kopieer je alle elementen uit de eerste array erin.

"Dit zijn de twee dingen die de Arrays.copyOf()methode doet. Dit is hoe bellen eruit ziet:

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

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

"Wat als de lengte van de nieuwe array kleiner is dan de lengte van de bestaande ?

"Goede vraag, Amigo! Als de elementen niet passen, dan worden de extra waarden gewoon genegeerd."

"En als er daarentegen extra cellen zijn, wat zijn hun beginwaarden?

"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);

Arrays.copyOfRange()

"En wat als je een array met lengte 5 wilt krijgen uit een array met lengte 10, maar je wilt dat het de laatste 5 elementen bevat in plaats van de eerste 5? In dit geval heb je een andere methode van de klasse nodig. Het Arraysis Arrays.copyOfRange()Dit is hoe bellen eruit ziet:

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 de eerste en laatste zijn de indices van de eerste en laatste elementen die in de nieuwe array moeten worden geplaatst. Kunt u mij vertellen of het laatste element is opgenomen in dit bereik?"

"Ha! Zoals mijn grote leraar placht te zeggen, ' in overeenstemming met Java's goede (of slechte) oude traditie, onthoud dat het laatste element niet is opgenomen in het bereik '."

"Amigo, je groeit recht voor onze ogen.

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);

Arrays.sort()

"En tot slot heb ik de meest... mmm... plezierige methode voor het laatst gelaten: sorteren . Arrays worden nogal vaak gesorteerd tijdens het programmeren. Hier is de top 3 van meest populaire acties bij het werken met arrays:

• 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)

"Goed presterende sorteeralgoritmen, moet ik zeggen, zijn niet zo eenvoudig om te schrijven. Om precies te zijn, dit is een standaardtaak, en als student kan het geen kwaad om af en toe te oefenen met het schrijven van sorteeralgoritmen. Maar op het werk is het het is beter om geen tijd te verspillen aan het opnieuw uitvinden van het wiel. De makers van Java hebben de sort()methode in de klas opgenomen Arrays. Dit is hoe het eruit ziet:

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);

"Uitstekend! Ik heb maar één methode aangeroepen en de array is gesorteerd. Een ding van schoonheid!"

"Trouwens, je kunt niet alleen de hele array sorteren, maar ook slechts een deel ervan. Zo ziet de aanroep eruit:

Arrays.sort(name, first, last);

"Waar eerste en laatste zijn de indexen van de eerste en laatste cellen die de sortering zou moeten raken. EN...

"Ik weet al wat je gaat zeggen! 'In overeenstemming met Java's goede (of slechte) oude traditie, onthoud dat het laatste element niet in het assortiment is opgenomen' .

Voorbeeld:

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

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

"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 zal ongeveer 10.000 vergelijkingen van array-elementen met zich meebrengen. Het sorteren van een array van een miljoen elementen zal ongeveer 20 miljoen vergelijkingen met zich meebrengen."

" Niet te veel vergelijkingen als je kijkt naar het aantal elementen!"

"Dat is precies wat ik bedoel. Het QuickSort- algoritme is zeer efficiënt.

Arrays.binarySearch()

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

• Eerst wordt de array gesorteerd.
• Vervolgens wordt het middelste element van de array vergeleken met degene 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 een enkele vergelijking te elimineren. In de volgende stap gooien we nog een helft weg, enzovoort."

"Fantastisch! We gaan heel snel recht op het doel af!"

“Precies. In een array van een miljoen (!) elementen kan het binaire zoekalgoritme in slechts 20 vergelijkingen de index van het gewenste element vinden. De tekortkoming van het algoritme is dat de array eerst gesorteerd moet worden, en ook het sorteren kost 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);

"Wat als het gewenste element meerdere keren in de array voorkomt ?"

"Dat is een geldige vraag, Amigo. In dit geval zal het algoritme de index van een van hen teruggeven (er is geen garantie dat dit bijvoorbeeld de allereerste is, of vice versa - de allerlaatste van deze dubbele elementen) ."

"Wat als de array helemaal niet het gewenste element bevat?"

"In dit geval zal het algoritme een negatieve index teruggeven .

Documentatie

"Alles is duidelijk, Rishi! Dit was erg interessant."

"Als je dit echt heel interessant vond, blader dan op je gemak door de officiële documentatie van de Arraysklasse en zijn methoden op de Oracle-website .

Arrays.mismatch()“Je kunt bijvoorbeeld de methoden en onder de loep nemen Arrays.compare(). Die kun je waarschijnlijk goed gebruiken.

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