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

c structuur in structuur

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.

onderstrepen met css

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;

123film

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

Java-iterator voor kaart

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.

vos of wolf

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