Welkom terug! :) In de les van vandaag zullen we het hebben over de klasse Arrays in Java. In de vorige les hebben we kennis gemaakt met zo'n datastructuur die we een array noemen. We hebben geleerd hoe we ze kunnen maken en vullen met gegevens. En we hebben gekeken hoe ze in het geheugen zijn opgeslagen. Vandaag kijken we naar enkele taken en voorbeelden van het werken met arrays die je vaak in het echte werk zult zien. Stel je bijvoorbeeld deze situatie voor: we hebben een reeks van 10 willekeurige getallen.
Onze taak is om deze array in oplopende volgorde te sorteren: van klein naar groot. Uiteindelijk zou het er zo uit moeten zien: [-234, -2, 16, 26, 35, 43, 92, 99, 167] Hoe doen we dat? Deze taak is niet triviaal. We hebben dit nog nooit eerder gedaan :/ Enig idee? Probeer te raden. Hier is een oplossing:
Doorloop alle elementen van de array. Vergelijk elk element met het volgende ([0] met [1], [1] met [2], [2] met [3], enz.). Als het huidige element groter is dan het volgende, wisselen we ze om en gaan we verder met het volgende element. Zo niet, laat ze dan zoals ze zijn en ga verder
Dus na de eerste passage door de elementen bevindt de grootste waarde (167) zich gegarandeerd in de laatste cel.
Nu gaan we alle elementen nog een keer doornemen, maar deze keer beginnen we met de index [0] tot het voorlaatste element (het grootste getal staat al op zijn plaats) en maken we dezelfde vergelijkingen en verwisselingen. Na deze pass, in de voorlaatste cel, hebben we de op een na grootste waarde (99).
Herhaal dit proces zo vaak als we array-elementen hebben.
We hebben het idee. Nu hoeven we alleen nog maar de code te schrijven. Het ziet er zo uit:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
for (int i = numbers.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
/* Compare the elements in pairs.
If they are not in the right order,
then swap them */
if (numbers[j] > numbers[j + 1]) {
int tmp = numbers[j];
numbers[j] = numbers[j + 1];
numbers[j + 1] = tmp;
}
}
}
}
}
Uh ... Het ziet er een beetje ingewikkeld uit -_- Zelfs als het algemene principe begrijpelijk is, moeten we nog steeds behoorlijk wat code schrijven om zo'n eenvoudige taak op te lossen. Oké, misschien hebben we onszelf gewoon overschat? De taak die we hebben aangepakt, is waarschijnlijk nog te ingewikkeld voor ons. Laten we iets eenvoudiger proberen. Neem bijvoorbeeld dezelfde getallenreeks.
Onze taak is om de inhoud ervan naar een andere array te kopiëren.
int [] numbersCopy = new int[10];
Denk na over hoe je het zou doen met wat je al weet over arrays? U kunt bijvoorbeeld de getallenreeks in een lus doorlopen en de elementen achtereenvolgens in numbersCopy schrijven :
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = new int[10];
for (int i = 0; i < numbers.length; i++) {
numbersCopy[i] = numbers[i];
}
}
}
Nou, uh, hier hebben we het eigenlijk gedaan! Het lijkt erop dat we het probleem hebben opgelost. Als u dit echter vaak moet doen, heeft uw code een aantal identieke lussen. In feite zijn deze (en andere) taken al lang opgelost door de makers van Java. We hoeven niet "het wiel opnieuw uit te vinden" en onze eigen oplossing te coderen. Er is een speciale statische klasse ( Arrays ) om u te helpen bij het uitvoeren van algemene taken bij het werken met arrays. Aan deze klasse zijn methoden toegevoegd voor het uitvoeren van de meest voorkomende taken waarmee Java-programmeurs worden geconfronteerd. De taak van het sorteren van een array, die we probeerden te verwerken, wordt bijvoorbeeld opgelost in een enkele regel:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers));
}
}
De methode Arrays.sort() sorteert de array. En het algoritme is veel efficiënter dan de code die we hebben geschreven. Console-uitvoer: [-234, -2, 16, 26, 35, 43, 80, 92, 99, 167] Opmerking: om de array naar een tekenreeks te converteren, hebben we een andere methode van de klasse Arrays gebruikt: Arrays.toString() . Arrays in Java overschrijven de methode toString() niet zelf. Dus als je gewoon schrijft
System.out.println(numbers.toString());
De toString() van de klasse Object wordt aangeroepen. Voor een array zal de uitvoer ongeveer zo zijn: [I@4554617c We zullen nu niet in detail treden over waarom dit precies de uitvoer is. Het belangrijkste is dat het duidelijk niet is wat we nodig hebben. Maar Arrays.toString() doet precies wat we willen. Kopiëren is overigens ook gemakkelijk met de klasse Arrays :
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = Arrays.copyOf(numbers, numbers.length);
System.out.println(Arrays.toString(numbersCopy));
}
}
We geven aan de methode Arrays.copyOf() onze originele array (waarvan we waarden willen kopiëren) en de lengte van de nieuwe array waarnaar we gegevens kopiëren. In dit geval hebben we numbers.length aangegeven als de lengte, omdat we de hele array willen kopiëren. Als we alleen de eerste paar elementen willen kopiëren, kunnen we de lengte van een nieuwe kleinere array specificeren:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = Arrays.copyOf(numbers, 4);
System.out.println(Arrays.toString(numbersCopy));
}
}
Hier hebben we 4 gespecificeerd als de lengte van de nieuwe array. Dienovereenkomstig worden alleen de eerste 4 elementen van getallen naar de nieuwe array gekopieerd. Console-uitvoer: [167, -2, 16, 99] Trouwens, met Arrays kun je ook een deel van een array kopiëren vanuit het midden in plaats van het begin van de array:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = Arrays.copyOfRange(numbers, 2,6);
System.out.println(Arrays.toString(numbersCopy));
}
}
Uitvoer: [16, 99, 26, 92] Getallen zijn in de nieuwe array gekopieerd van de tweede array van het tweede (inclusief) tot het zesde (niet inclusief) element. Mogelijk moeten we ook twee arrays vergelijken. Net als bij de methode toString() overschrijven de arrays zelf de methode equals() niet . Dus als we ze zo proberen te vergelijken
public class Main {
public static void main(String[] args) {
int[] numbers = {1, 2, 3};
int[] numbers2 = {1, 2, 3};
System.out.println(numbers.equals(numbers2));
}
}
dan worden we vals. Dit komt doordat Object.equals() , dat referenties vergelijkt, wordt aangeroepen. En natuurlijk zijn ze anders! Maar wat we nodig hebben, is de inhoud van arrays vergelijken, geen referenties. De klasse Arrays overschrijft de methode equals() zodat deze precies doet wat we willen:
public class Main {
public static void main(String[] args) {
int[] numbers = {1, 2, 3};
int[] numbers2 = {1, 2, 3};
System.out.println(Arrays.equals(numbers, numbers2));
}
}
Uitvoer: true Overigens werkt de klasse Arrays niet alleen met gewone arrays, maar ook met tweedimensionale arrays:
public class Main {
public static void main(String[] args) {
int[][] numbers = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int[][] numbersCopy = Arrays.copyOf(numbers, numbers.length);
System.out.println("Are these two-dimensional arrays equal?");
System.out.println(Arrays.deepEquals(numbers, numbersCopy));
System.out.println(Arrays.deepToString(numbersCopy));
}
}
Uitvoer: zijn deze tweedimensionale arrays gelijk? true [[1, 2, 3], [4, 5, 6], [7, 8, 9]] Zoals u kunt zien, kon de methode Arrays.copyOf() een tweedimensionale array kopiëren. En de klasse heeft speciale methoden voor het vergelijken en weergeven van tweedimensionale arrays: deepEquals en deepToString() . In de toekomst zul je herhaaldelijk zien (en je verheugen in het feit dat) dat de makers van Java veel situaties hebben geanticipeerd waarmee programmeurs vaak worden geconfronteerd, en kant-en-klare oplossingen voor hen in de taal hebben geïmplementeerd. Het gebruik van deze oplossingen is veel gemakkelijker en handiger dan het wiel opnieuw uitvinden, toch? :) Lees zeker de documentatie voor de klasse Arrays op de Oracle- website. Veel succes met je studie!
GO TO FULL VERSION