Iets met arrays

Hoi! Eerder in uw training hebben we gewerkt met enkele objecten (en primitieve typen). Maar wat als we met een hele groep objecten moeten werken in plaats van slechts één? Stel dat we bijvoorbeeld een lijst willen maken met de verjaardagen van alle medewerkers van ons bedrijf. Het zou 30 strings moeten bevatten die als volgt zijn opgemaakt: "Sarah Huffman, 25 januari" We zullen profiteren van een speciale gegevensstructuur die een array wordt genoemd . Als we een array vergelijken met een echt object, dan lijkt het sterk op een bankkluis met kluisjes: een array bestaat ook uit "dozen". Je kunt iets (een element) in elk vak stoppen. Om toegang te krijgen tot een element, moet u het vaknummer (index) weten. Zo wordt een array gemaakt:

public class Main {

   public static void main(String[] args) {

       String [] birthdays = new String[10];
      
   }
}

Hier maken we een array met 10 elementen. U kunt meteen enkele kenmerken van de array opmerken:

1. Het slaat elementen op van een goed gedefinieerd gegevenstype . Als we een String-array maken, kunnen we er niets anders in opslaan. Het gegevenstype wordt opgegeven wanneer de array wordt gemaakt . Hierin verschilt het van een kluisje (waarin een klant kan opbergen wat hij of zij wil).


2. De grootte ervan moet worden opgegeven wanneer de array wordt gemaakt . U kunt het later niet aangeven of de grootte wijzigen nadat de array is gemaakt .

Het feit dat we een array maken, wordt aangegeven door vierkante haken aan beide zijden van de uitdrukking. Ze kunnen voor of achter de naam van de referentievariabele worden opgegeven. Hoe dan ook zal werken:

String [] birthdays = new String[10];
String birthdays [] = new String[10];

Als u iets in een array wilt schrijven, moet u de index specificeren van het vak waarin de waarde wordt geschreven. De vakjes in een array zijn genummerd vanaf 0. Tellen vanaf nul is een veel voorkomende praktijk bij het programmeren. Hoe sneller je eraan went, hoe beter :) Dit betekent dat als je wat waarde in het eerste vakje wilt stoppen , je dit doet:

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
   }
}

Nu wordt de verjaardag van Jana opgeslagen in de eerste cel van onze reeks verjaardagen van werknemers: U kunt op dezelfde manier andere waarden toevoegen:

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[7] = "Rosie Mills, January 3";
   }
}

Merk op dat we Rosie's verjaardag hebben toegevoegd aan de achtste doos (je bent toch niet vergeten waarom doos nr. 7 de achtste doos is?) . U kunt zien dat we niet alle andere cellen hebben gevuld. We hoeven geen waarden in volgorde in een array te schrijven. Zo'n vereiste is er niet. Door elementen op volgorde te schrijven, is het natuurlijk veel gemakkelijker om bij te houden hoeveel vakken er vrij zijn en hoeveel er bezet zijn, en het voorkomt dat de array "gaten" heeft. Als je de inhoud van een van de dozen wilt weten, dan moet je (net als bij een kluisje) het nummer weten. Dit is hoe het gedaan is:

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[7] = "Rosie Mills, January 3";

       String rosieBirthday = birthdays[7];
       System.out.println(rosieBirthday);
   }
}

Console-uitvoer: Rosie Mills, 3 januari We hebben een Stringvariabele gemaakt en tegen de compiler gezegd: "Zoek het vak met index 7 in de reeks verjaardagen en wijs de waarde die daarin staat toe aan de Stringvariabele rosieBirthday ". En dat is precies wat het deed. Bij het werken met arrays kunnen we eenvoudig hun lengte vinden met behulp van een speciale eigenschap: length .

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[7] = "Rosie Mills, January 3";

       int birthdaysLength = birthdays.length;
       System.out.println(birthdaysLength);
   }
}

Console-uitvoer: 10 Opmerking: de lengtheigenschap slaat de arraygrootte op, niet het aantal dozen dat vol is. Onze array slaat slechts 3 waarden op, maar we hebben de grootte aangegeven als 10 toen we het maakten. En dit is precies de waarde die het lengthveld retourneert. Waarom zou dit van pas komen? Stel dat u een lijst met alle verjaardagen wilt weergeven (om te controleren of niemand is vergeten). U kunt dit in één eenvoudige lus doen:

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[2] = "Jeremiah Leonard, July 12";
       birthdays [3] = "Kenny Russo, September 7";
       birthdays[4] = "Tommie Barnes, November 9";
       birthdays [5] = "Roman Baranov, August 14";
       birthdays [6] = "Chanice Andersen, April 1";
       birthdays[7] = "Rosie Mills, January 3";
       birthdays [8] = "Keenan West, October 19";
       birthdays [9] = "Abraham McArthur, May 3";

       for (int i = 0; i < birthdays.length; i++) {
           System.out.println(birthdays[i]);
       }
   }
}

In de lus declareren we de variabele i, die is geïnitialiseerd op nul. Bij elke passage halen we het element met index i uit onze array en geven de waarde weer. De lus zal 10 iteraties doen, en ik zal toenemen van 0 tot 9 - en getallen zijn toevallig de indices van de elementen van onze array! Als gevolg hiervan zullen we alle waarden van birthdays[0] tot birthdays[9] weergeven . Er is eigenlijk een andere manier om een ​​array te maken. U kunt bijvoorbeeld een array van ints als volgt maken:

public class Main {

   public static void main(String[] args) {
       int numbers [] = {7, 12, 8, 4, 33, 79, 1, 16, 2};
   }
}

Deze techniek wordt "shortcut initialisatie" genoemd. Het is best handig, omdat we tegelijkertijd een array maken en deze vullen met waarden. We hoeven de grootte van de array niet expliciet op te geven: met snelkoppelingsinitialisatie lengthwordt het veld automatisch ingesteld.

public class Main {

   public static void main(String[] args) {
       int numbers [] = {7, 12, 8, 4, 33, 79, 1, 16, 2};
       System.out.println(numbers.length);
   }
}

Console-uitvoer: 9 Nu iets over hoe arrays in het geheugen worden opgeslagen. Laten we zeggen dat we een array van drie Catobjecten hebben:

public class Cat {

   private String name;

   public Cat(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

       Cat[] cats = new Cat[3];
       cats[0] = new Cat("Thomas");
       cats[1] = new Cat("Behemoth");
       cats[2] = new Cat("Lionel Messi");
   }
}

U moet hier een paar dingen begrijpen:

1. In het geval van primitieven slaat een array een reeks specifieke waarden op (bijv. ints). In het geval van objecten slaat een array een set referenties op .
   De catsarray bestaat uit drie elementen, die elk een verwijzing naar een Catobject zijn. Elk van de referenties verwijst naar het geheugenadres waar het corresponderende object is opgeslagen.

2. Array-elementen zijn gerangschikt in een enkel blok in het geheugen. Dit wordt gedaan om ervoor te zorgen dat ze snel en efficiënt toegankelijk zijn.

Verwijst dus catsnaar het geheugenblok waar alle objecten (array-elementen) zijn opgeslagen. Cats[0]verwijst naar een specifiek adres binnen dit blok. Het is belangrijk om te begrijpen dat een array niet alleen objecten opslaat: het is zelf een object. Dit brengt ons bij de vraag of we niet alleen een array van strings of getallen kunnen maken, maar ook arrays van arrays . En het antwoord is ja, dat kunnen we! Een array kan alle objecten opslaan, inclusief andere arrays. Zo'n array wordt tweedimensionaal genoemd . Als we het visueel zouden weergeven, lijkt het erg op een gewone tafel. Stel dat we een array willen maken van 3 arrays die elk 10 ints kunnen opslaan. Het zou er zo uitzien: Elke regel vertegenwoordigt een intarray. De eerste reeks bevat getallen van 1 tot 10, de tweede reeks - van -1 tot -10 en de derde - een reeks willekeurige getallen. Elk van deze arrays wordt opgeslagen in de dozen van onze tweedimensionale array. In code ziet de initialisatie van een tweedimensionale array er als volgt uit:

public static void main(String[] args) {
   Cat[][] cats = new Cat[3][5];
}

Onze tweedimensionale array- katten slaan 3 arrays op met 5 dozen in elke array. Als we een object in het derde vak van de tweede array willen plaatsen , doen we dit:

public static void main(String[] args) {
   Cat[][] cats = new Cat[3][5];
   cats[1][2] = new Cat("Fluffy");
}

[1]geeft de tweede array aan en [2]geeft de derde box van die array aan. Omdat een tweedimensionale array uit verschillende arrays bestaat, hebben we een geneste lus nodig om er doorheen te kunnen lopen en al zijn waarden weer te geven (of alle elementen ervan te vullen):

for (int i = 0; i < cats.length; i++) {
   for (int j = 0; j < cats[i].length; j++) {
       System.out.println(cats[i][j]);
   }
}

In de buitenste lus (variabele i) herhalen we alle arrays in onze tweedimensionale array. In de binnenste lus (variabele j) passeren we alle elementen van elke array. Het resultaat is dat cats[0][0] (eerste array, eerste element) als eerste wordt weergegeven, gevolgd door cats[0][1] (eerste array, tweede element). Nadat we de eerste array hebben doorlopen, geven we cats[1][0] , cats[1][1] , cats[1][2] , enz. weer. Tweedimensionale arrays ondersteunen trouwens ook verkorte initialisatie:

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

Gewoonlijk declareren we de tweedimensionale array numbersals een int[3][3], maar met deze afkorting kunnen we de waarden onmiddellijk specificeren. Waarom zou je een tweedimensionale array nodig hebben? Nou, je zou er een kunnen gebruiken om gemakkelijk het beroemde "Battleship" -spel na te bootsen: in "Battleship" kan de structuur van het speelveld eenvoudig worden beschreven: een tweedimensionale reeks van 10 reeksen met elk 10 elementen. Je maakt twee van deze arrays (één voor jou en één voor je tegenstander)

int[][] battleshipBoard1 = new int[10][10];
int[][] battleshipBoard2 = new int[10][10];

gebruik enkele waarden (bijv. getallen of symbolen) om de elementen in te vullen die overeenkomen met de locatie van uw schepen, en roep vervolgens om de beurt de coördinaten voor specifieke elementen op:

• slagschipBord1[0][2]!
• Missen! slagschipBord2[2][4]!
• Hit!
• slagschipBord2[2][5]!
• Hit!
• slagschipBord2[2][6]!,
• gezonken!

Dit is het einde van onze eerste introductie van arrays, maar het is nog maar het begin van onze interactie ermee. In de volgende lessen zullen we interessante manieren zien waarop ze kunnen worden gebruikt, en ook leren welke ingebouwde functies Java heeft om ons gemakkelijker met deze gegevensstructuur te laten werken :)