In Java is een array een belangrijke lineaire gegevensstructuur waarmee we meerdere waarden van hetzelfde type kunnen opslaan.

• Arrays in Java zijn objecten zoals alle andere objecten in Java-arrays die impliciet overerven van de klasse java.lang.Object. Hierdoor kunt u methoden aanroepen die zijn gedefinieerd in Object (zoals toString() equals() en hashCode()).
• Arrays hebben een ingebouwde lengte-eigenschap die het aantal elementen in de array aangeeft

   public     class   Geeks     {      public     static     void     main  (  String  []     args  )      {      // initializing array      int  []     arr     =     {  40       55       63       17       22  };      // size of array      int     n     =     arr  .  length  ;      // traversing array      for     (  int     i     =     0  ;     i      <     n  ;     i  ++  )      System  .  out  .  print  (  arr  [  i  ]     +     ' '  );      }   }   

40 55 63 17 22  

Belangrijkste kenmerken van arrays

• Bewaar primitieven en objecten: Java-arrays kunnen zowel primitieve typen (zoals int char boolean enz.) als objecten (zoals String Integer enz.) bevatten.
• Aaneengesloten geheugentoewijzing Wanneer we arrays van primitieve typen gebruiken, worden de elementen op aaneengesloten locaties opgeslagen. Voor niet-primitieve typen worden referenties van items op aaneengesloten locaties opgeslagen.
• Op nul gebaseerde indexering: Het eerste element van de array bevindt zich op index 0.
• Vaste lengte: Nadat een array is gemaakt, staat de grootte ervan vast; wij kunnen het niet veranderen.

Basisbewerkingen op arrays in Java

1. Een array declareren

De algemene vorm van array-declaratie is 

// Methode 1:
int arr[];

// Methode 2:
int[] arr;

Het elementtype bepaalt het gegevenstype van elk element waaruit de array bestaat. Net als een array met gehele getallen kunnen we ook een array met andere primitieve gegevenstypen maken, zoals char float double etc. of door de gebruiker gedefinieerde gegevenstypen (objecten van een klasse).

Opmerking: Het is precies hoe we een arrayvariabele kunnen maken, er bestaat geen echte array. Het vertelt de compiler alleen dat deze variabele (int Array) een array van het integer-type zal bevatten.

2. Initialisatie van een array in Java

Wanneer een array wordt gedeclareerd, wordt er alleen een verwijzing naar een array gemaakt. We gebruiken new om een ​​array van een bepaalde grootte toe te wijzen.

int arr[] = nieuwe int[grootte];

• Array-declaratie is over het algemeen statisch, maar als de grootte niet is gedefinieerd, heeft de array een dynamische grootte.
• Geheugen voor arrays wordt in Java altijd dynamisch toegewezen (op heap-segment). Dit verschilt van C/C++, waarbij geheugen statisch of dynamisch kan worden toegewezen.
• De elementen in de array die door new worden toegewezen, worden automatisch geïnitialiseerd op nul (voor numerieke typen), false (voor boolean) of null (voor referentietypen).

Array Letterlijk in Java

In een situatie waarin de grootte van de array en de variabelen van de array al bekend zijn, kunnen arrayliterals worden gebruikt. 

// Array letterlijk declareren
int[] arr = nieuwe int[]{ 12345678910 };

• De lengte van deze array bepaalt de lengte van de gemaakte array.
• Het is niet nodig om het nieuwe int[]-gedeelte in de nieuwste versies van Java te schrijven.

3. Wijzig een arrayelement

Om een ​​element te wijzigen, wijst u een nieuwe waarde toe aan een specifieke index. De index begint met 0 en eindigt bij (totale arraygrootte) -1.

// Het eerste element wijzigen in 90
arr[0] = 90;

4. Arraylengte

We kunnen de lengte van een array verkrijgen met behulp van de eigenschap length:

// De lengte van de array ophalen
int n = arr.lengte;

5. Toegang tot en bijwerken van alle array-elementen

• Alle elementen van de array zijn toegankelijk via Java for Loop.
• Elk element in de array is toegankelijk via de index.

Een Java-programma ter illustratie van het maken van een array met gehele getallen plaatst enkele waarden in de array en drukt elke waarde af naar standaarduitvoer

   class   Geeks     {      public     static     void     main  (  String  []     args  )      {      // declares an Array of integers.      int  []     arr  ;      // allocating memory for 5 integers.      arr     =     new     int  [  5  ]  ;      // initialize the elements of the array      // first to last(fifth) element      arr  [  0  ]     =     2  ;      arr  [  1  ]     =     4  ;      arr  [  2  ]     =     8  ;      arr  [  3  ]     =     12  ;      arr  [  4  ]     =     16  ;      // accessing the elements of the specified array      for     (  int     i     =     0  ;     i      <     arr  .  length  ;     i  ++  )      System  .  out  .  println  (  'Element at index '     +      i     +     ' : '     +     arr  [  i  ]  );      }   }   

Element at index 0 : 2 Element at index 1 : 4 Element at index 2 : 8 Element at index 3 : 12 Element at index 4 : 16  

Arrays van objecten op Java

Een array van objecten wordt gemaakt als een array van gegevensitems van het primitieve type

Voorbeeld : Hier nemen we een studentenklas en maken we een array van Student met vijf Student-objecten opgeslagen in de array. De Student-objecten moeten worden geïnstantieerd met behulp van de constructor van de Student-klasse en hun referenties moeten worden toegewezen aan de array-elementen.

   class   Student     {      public     int     roll_no  ;      public     String     name  ;          Student  (  int     roll_no       String     name  ){      this  .  roll_no     =     roll_no  ;      this  .  name     =     name  ;      }   }   public     class   Geeks     {      public     static     void     main  (  String  []     args  ){          // declares an Array of Student      Student  []     arr  ;      // allocating memory for 5 objects of type Student.      arr     =     new     Student  [  5  ]  ;      // initialize the elements of the array      arr  [  0  ]     =     new     Student  (  1       'aman'  );      arr  [  1  ]     =     new     Student  (  2       'vaibhav'  );      arr  [  2  ]     =     new     Student  (  3       'shikar'  );      arr  [  3  ]     =     new     Student  (  4       'dharmesh'  );      arr  [  4  ]     =     new     Student  (  5       'mohit'  );      // accessing the elements of the specified array      for     (  int     i     =     0  ;     i      <     arr  .  length  ;     i  ++  )      System  .  out  .  println  (  'Element at '     +     i     +     ' : { '      +     arr  [  i  ]  .  roll_no     +     ' '      +     arr  [  i  ]  .  name  +  ' }'  );      }   }   

Element at 0 : { 1 aman } Element at 1 : { 2 vaibhav } Element at 2 : { 3 shikar } Element at 3 : { 4 dharmesh } Element at 4 : { 5 mohit }  

Wat gebeurt er als we toegang proberen te krijgen tot elementen buiten de arraygrootte?

JVM genereert ArrayIndexOutOfBoundsException om aan te geven dat toegang tot de array is verkregen met een illegale index. De index is negatief of groter dan of gelijk aan de grootte van een array.

Onderstaande code laat zien wat er gebeurt als we toegang proberen te krijgen tot elementen buiten de arraygrootte:

   public     class   Geeks     {      public     static     void     main  (  String  []     args  )      {      int  []     arr     =     new     int  [  4  ]  ;      arr  [  0  ]     =     10  ;      arr  [  1  ]     =     20  ;      arr  [  2  ]     =     30  ;      arr  [  3  ]     =     40  ;      System  .  out  .  println  (      'Trying to access element outside the size of array'  );      System  .  out  .  println  (  arr  [  5  ]  );      }   }   

Uitgang:

Arrays doorgeven aan methoden

Net als variabelen kunnen we ook arrays doorgeven aan methoden. Het onderstaande programma geeft bijvoorbeeld de array door aan de methode som om de som van de waarden van de array te berekenen.

Voorbeeld:

   public     class   Geeks     {      // Driver method      public     static     void     main  (  String     args  []  )      {      int     arr  []     =     {     3       1       2       5       4     };      // passing array to method m1      sum  (  arr  );      }      public     static     void     sum  (  int  []     arr  )      {      // getting sum of array values      int     sum     =     0  ;      for     (  int     i     =     0  ;     i      <     arr  .  length  ;     i  ++  )      sum     +=     arr  [  i  ]  ;      System  .  out  .  println  (  'sum of array values : '     +     sum  );      }   }   

sum of array values : 15  

Uitleg

• Dit Java-programma laat zien hoe u een array aan een methode kunt doorgeven.
• Een integer-array arr wordt gedeclareerd en geïnitialiseerd in de hoofdmethode.
• De methode sum() wordt aangeroepen met arr als argument.
• Binnen de sum()-methode worden alle array-elementen toegevoegd met behulp van een for-lus.
• Het uiteindelijke bedrag wordt vervolgens naar de console afgedrukt.

Arrays retourneren uit methoden

Zoals gebruikelijk kan een methode ook een array retourneren. Het onderstaande programma retourneert bijvoorbeeld een array van methode m1. 

Voorbeeld:

   class   Geeks     {      // Driver method      public     static     void     main  (  String     args  []  )      {      int     arr  []     =     m1  ();      for     (  int     i     =     0  ;     i      <     arr  .  length  ;     i  ++  )      System  .  out  .  print  (  arr  [  i  ]     +     ' '  );      }      public     static     int  []     m1  ()      {      // returning array      return     new     int  []     {     1       2       3     };      }   }   

1 2 3  

Voordelen van Java-arrays

• Efficiënte toegang: Toegang tot een element via zijn index is snel en heeft een constante tijdscomplexiteit O(1).
• Geheugenbeheer: Arrays hebben een vaste grootte, waardoor geheugenbeheer eenvoudig en voorspelbaar is.
• Gegevensorganisatie: Arrays helpen gegevens op een gestructureerde manier te ordenen, waardoor het gemakkelijker wordt om gerelateerde elementen te beheren.

Nadelen van Java-arrays

• Vaste maat: Zodra een array is gemaakt, kan de grootte ervan niet meer worden gewijzigd, wat kan leiden tot geheugenverspilling als de grootte wordt overschat of tot onvoldoende opslagruimte als deze wordt onderschat.
• Type homogeniteit: Arrays kunnen alleen elementen van hetzelfde gegevenstype opslaan, wat mogelijk extra verwerking vereist voor gemengde gegevenstypen.
• Invoegen en verwijderen: Het invoegen of verwijderen van elementen, vooral in het midden van een array, kan kostbaar zijn, omdat er mogelijk elementen moeten worden verschoven.

Gerelateerde berichten

• Gekartelde array op Java
• Voor elke lus in Java
• Arrays-klasse in Java