Op Java, Array is een groep variabelen van hetzelfde type waarnaar wordt verwezen met een algemene naam. Arrays in Java werken anders dan in C/C++. Hieronder volgen enkele belangrijke punten over Java-arrays.

Arrays op Java

• In Java worden alle arrays dynamisch toegewezen. (hieronder besproken)
• Arrays kunnen worden opgeslagen in aaneengesloten geheugen [opeenvolgende geheugenlocaties].
• Omdat arrays objecten zijn in Java, kunnen we hun lengte vinden met behulp van de objecteigenschap lengte . Dit verschilt van C/C++, waar we lengte vinden met behulp van sizeof.
• Een Java-arrayvariabele kan ook net als andere variabelen worden gedeclareerd, met [] achter het gegevenstype.
• De variabelen in de array zijn geordend en hebben elk een index die begint met 0.
• Java-array kan ook worden gebruikt als een statisch veld, een lokale variabele of een methodeparameter.

Een array kan primitieven (int, char, enz.) en objectreferenties (of niet-primitieve) referenties van een klasse bevatten, afhankelijk van de definitie van de array. In het geval van primitieve gegevenstypen kunnen de werkelijke waarden worden opgeslagen op aaneengesloten geheugenlocaties (JVM garandeert dit gedrag niet). In het geval van klasseobjecten, de feitelijke objecten worden opgeslagen in een heap-segment .

lang naar int java

Opmerking: Deze opslag van arrays helpt ons willekeurig toegang te krijgen tot de elementen van een array [Ondersteuning van willekeurige toegang].

Arrays maken, initialiseren en openen

Eendimensionale arrays

De algemene vorm van een eendimensionale array-declaratie is

-- type var-name[]; -- type[] var-name;>

Een arraydeclaratie bestaat uit twee componenten: het type en de naam. type declareert het elementtype van de array. 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, enz., of door de gebruiker gedefinieerde gegevenstypen (objecten van een klasse). Het elementtype voor de array bepaalt dus welk type gegevens de array zal bevatten.

Voorbeeld:

// both are valid declarations int intArray[]; int[] intArray; // similar to int we can declare // byte , short, boolean, long, float // double, char // an array of references to objects of // the class MyClass (a class created by user) MyClass myClassArray[]; // array of Object Object[] ao, // array of Collection // of unknown type Collection[] ca;>

Hoewel de eerste declaratie vaststelt dat int Array een arrayvariabele is, er bestaat geen echte array . Het vertelt de compiler alleen dat deze variabele (int Array) een array van het integer-type zal bevatten. Om int Array te koppelen aan een daadwerkelijke, fysieke array van gehele getallen, moet u er één toewijzen met behulp van nieuw en wijs het toe aan int Array.

Instantiëren van een array in Java

Wanneer een array wordt gedeclareerd, wordt alleen een verwijzing naar een array gemaakt. Om geheugen aan de array te maken of eraan te geven, maakt u een array als volgt: De algemene vorm van nieuw zoals van toepassing op eendimensionale arrays ziet het er als volgt uit:

var-name = new type [size];>

Hier, type specificeert het type gegevens dat wordt toegewezen, maat bepaalt het aantal elementen in de array, en var-naam is de naam van de arrayvariabele die aan de array is gekoppeld. Gebruiken nieuw een array toewijzen, u moet het type en het aantal toe te wijzen elementen specificeren.

Voorbeeld:

//declaring array int intArray[]; // allocating memory to array intArray = new int[20]; // combining both statements in one int[] intArray = new int[20];>

Opmerking: De elementen in de array toegewezen door nieuw wordt automatisch geïnitialiseerd nul (voor numerieke typen), vals (voor boolean), of nul (voor referentietypen). Raadpleeg standaardarraywaarden in Java .

Het verkrijgen van een array bestaat uit twee stappen. Eerst moet u een variabele van het gewenste arraytype declareren. Ten tweede moet u het geheugen toewijzen om de array op te slaan, met behulp van new, en dit toewijzen aan de arrayvariabele. Dus, op Java , alle arrays worden dynamisch toegewezen.

Array Letterlijk in Java

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

// Declaring array literal int[] intArray = new int[]{ 1,2,3,4,5,6,7,8,9,10 };>

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

Toegang krijgen tot Java Array-elementen met behulp van for Loop

Elk element in de array is toegankelijk via de index. De index begint met 0 en eindigt bij (totale arraygrootte) -1. Alle elementen van de array zijn toegankelijk via Java for Loop.

 // accessing the elements of the specified array for (int i = 0; i>

Implementatie:

// Java program to illustrate creating an array // of integers, puts some values in the array, // and prints each value to standard output. class GFG { public static void main(String[] args) { // declares an Array of integers. int[] arr; // allocating memory for 5 integers. arr = new int[5]; // initialize the first elements of the array arr[0] = 10; // initialize the second elements of the array arr[1] = 20; // so on... arr[2] = 30; arr[3] = 40; arr[4] = 50; // 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 : 10 Element at index 1 : 20 Element at index 2 : 30 Element at index 3 : 40 Element at index 4 : 50>

Complexiteit van de bovenstaande methode:

Tijdcomplexiteit: O(n)
Hulpruimte: O(1)

U kunt ook toegang krijgen tot Java-arrays met behulp van voor elke lus .

datastructuren in Java

Arrays van objecten op Java

Een array van objecten wordt op de volgende manier gemaakt als een array van gegevensitems van het primitieve type.

Student[] arr = new Student[5]; //student is a user-defined class>

Syntaxis:

-- data type[] arrName; -- datatype arrName[]; -- datatype [] arrName;>

Voorbeeld van arrays van objecten

Voorbeeld 1:

Hieronder vindt u de implementatie van het bovengenoemde onderwerp:

import java.io.*; class GFG { public static void main (String[] args) { int [] arr=new int [4]; // 4 is the size of arr System.out.println('Array Size:'+arr.length); } }>

Array Size:4>

De Student Array bevat vijf geheugenruimten, elk ter grootte van een studentenklas, waarin het adres van vijf Student-objecten kan worden opgeslagen. De Student-objecten moeten worden geïnstantieerd met behulp van de constructor van de Student-klasse, en hun referenties moeten op de volgende manier aan de array-elementen worden toegewezen.

Voorbeeld 2:

Hieronder vindt u de implementatie van het bovengenoemde onderwerp:

// Java program to illustrate creating // an array of objects class Student { public int roll_no; public String name; Student(int roll_no, String name) { this.roll_no = roll_no; this.name = name; } } // Elements of the array are objects of a class Student. public class GFG { public static void main(String[] args) { // declares an Array of Students Student[] arr; // allocating memory for 5 objects of type Student. arr = new Student[5]; // initialize the first elements of the array arr[0] = new Student(1, 'aman'); // initialize the second elements of the array arr[1] = new Student(2, 'vaibhav'); // so on... 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>

Complexiteit van de bovenstaande methode:

Tijdcomplexiteit: O(n)
Hulpruimte: O(1)

Voorbeeld 3

Er wordt ook een array met objecten gemaakt, zoals:

// Java program to illustrate creating // an array of objects class Student { public String name; Student(String name) { this.name = name; } @Override public String toString(){ return name; } } // Elements of the array are objects of a class Student. public class GFG { public static void main (String[] args) { // declares an Array and initializing the elements of the array Student[] myStudents = new Student[]{new Student('Dharma'),new Student('sanvi'),new Student('Rupa'),new Student('Ajay')}; // accessing the elements of the specified array for(Student m:myStudents){ System.out.println(m); } } }>

Dharma sanvi Rupa Ajay>

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

JVM gooit 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:

// Code for showing error 'ArrayIndexOutOfBoundsException' public class GFG { 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]); } }>

Uitvoer

Trying to access element outside the size of array Exception in thread 'main' java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 4 at GFG.main(GFG.java:13)>

Voorbeeld (de array herhalen):

public class GFG { public static void main(String[] args) { int[] arr = new int[2]; arr[0] = 10; arr[1] = 20; for (int i = 0; i < arr.length; i++) System.out.println(arr[i]); } }>

10 20>

Complexiteit van de bovenstaande methode:

Tijdcomplexiteit: O(n), hier is n de grootte van de array.
Hulpruimte: O(1) , omdat er geen extra ruimte nodig is.

Multidimensionale arrays in Java

Multidimensionale arrays zijn dat wel arrays van arrays waarbij elk element van de array de referentie van andere arrays bevat. Deze staan ​​ook bekend als Gekartelde arrays . Er wordt een multidimensionale array gemaakt door één set vierkante haken ([]) per dimensie toe te voegen.

Syntaxis van Java Multidimensional Array

Er zijn 2 methoden om Java Multidimensional Arrays te declareren, zoals hieronder vermeld:

-- datatype [][] arrayrefvariable; -- datatype arrayrefvariable[][];>

Voorbeeld:

converteer tekenreeks int java

// Java Program to demonstrate // Java Multidimensional Array import java.io.*; // Driver class class GFG { public static void main(String[] args) { // Syntax int[][] arr = new int[3][3]; // 3 row and 3 column // Number of Rows System.out.println('Number of Rows:'+ arr.length); // Number of Columns System.out.println('Number of Columns:'+ arr[0].length); } }>

Number of Rows:3 Number of Columns:3>

Multidimensionale array-verklaring

int[][] intArray = new int[10][20]; //a 2D array or matrix int[][][] intArray = new int[10][20][10]; //a 3D array>

Voorbeeld van Muilti Dimensional Array in Java

Voorbeeld 1:

Hieronder vindt u de implementatie van de bovenstaande methode:

// Java Program to Multidimensional Array // Driver Class public class multiDimensional { // main function public static void main(String args[]) { // declaring and initializing 2D array int arr[][] = { { 2, 7, 9 }, { 3, 6, 1 }, { 7, 4, 2 } }; // printing 2D array for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) System.out.print(arr[i][j] + ' '); System.out.println(); } } }>

2 7 9 3 6 1 7 4 2>

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.

// Java program to demonstrate // passing of array to method public class Test { // 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>

Complexiteit van de bovenstaande methode:

Tijdcomplexiteit: Op)
Hulpruimte: O(1)

Arrays retourneren uit methoden

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

// Java program to demonstrate // return of array from method class Test { // 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>

Complexiteit van de bovenstaande methode:

Tijdcomplexiteit: O(n)
Hulpruimte: O(1)

Klasseobjecten voor arrays

Elke array heeft een bijbehorend Class-object, gedeeld met alle andere arrays met hetzelfde componenttype.

// Java program to demonstrate // Class Objects for Arrays class Test { public static void main(String args[]) { int intArray[] = new int[3]; byte byteArray[] = new byte[3]; short shortsArray[] = new short[3]; // array of Strings String[] strArray = new String[3]; System.out.println(intArray.getClass()); System.out.println( intArray.getClass().getSuperclass()); System.out.println(byteArray.getClass()); System.out.println(shortsArray.getClass()); System.out.println(strArray.getClass()); } }>

class [I class java.lang.Object class [B class [S class [Ljava.lang.String;>

Uitleg van bovenstaande methode:

1. De tekenreeks [I is de handtekening van het runtimetype voor de klasseobjectarray met componenttype int .
2. De enige directe superklasse van een arraytype is java.lang.Object .
3. De tekenreeks [B is de handtekening van het runtimetype voor de klasseobjectarray met componenttype byte .
4. De tekenreeks [S is de handtekening van het runtimetype voor de klasseobjectarray met componenttype kort .
5. De string [L is de handtekening van het runtimetype voor de klasseobjectarray met componenttype van een klasse. Vervolgens wordt de klassenaam gevolgd.

Java Array-leden

Zoals u weet, zijn arrays objecten van een klasse, en is een directe superklasse van arrays een klasseobject. De leden van een arraytype zijn allemaal:

• Het publieke eindveld lengte bevat het aantal componenten van de array. De lengte kan positief of nul zijn.
• Alle leden worden geërfd van de klasse Object; de enige methode van Object die niet wordt geërfd, is zijn kloon methode.
• De publieke methode kloon() overschrijft de kloonmethode in de klasse Object en gooit nee gecontroleerde uitzonderingen .

Arraytypen en hun toegestane elementtypen

Klonen van eendimensionale array in Java

Wanneer u een eendimensionale array, zoals Object[], kloont, wordt er een diepe kopie uitgevoerd met de nieuwe array die kopieën bevat van de elementen van de originele array in plaats van referenties.

arraylist sorteren

Hieronder vindt u de implementatie van de bovenstaande methode:

// Java program to demonstrate // cloning of one-dimensional arrays class Test { public static void main(String args[]) { int intArray[] = { 1, 2, 3 }; int cloneArray[] = intArray.clone(); // will print false as deep copy is created // for one-dimensional array System.out.println(intArray == cloneArray); for (int i = 0; i < cloneArray.length; i++) { System.out.print(cloneArray[i] + ' '); } } }>

false 1 2 3>

Multidimensionale array klonen in Java

Een kloon van een multidimensionale array (zoals Object[][]) is echter een ondiepe kopie, dat wil zeggen dat er slechts één nieuwe array wordt gemaakt waarbij elke elementarray een verwijzing is naar een originele elementarray, maar subarrays zijn dat wel. gedeeld.

// Java program to demonstrate // cloning of multi-dimensional arrays class Test { public static void main(String args[]) { int intArray[][] = { { 1, 2, 3 }, { 4, 5 } }; int cloneArray[][] = intArray.clone(); // will print false System.out.println(intArray == cloneArray); // will print true as shallow copy is created // i.e. sub-arrays are shared System.out.println(intArray[0] == cloneArray[0]); System.out.println(intArray[1] == cloneArray[1]); } }>

false true true>

Veelgestelde vragen in Java-arrays

1. Kunnen we de grootte van de array zo lang specificeren?

Nee, we kunnen de grootte van de array niet zo lang specificeren, maar we kunnen deze specificeren als int of short.

2. Wat is de directe superklasse van een array in Java?

Een Voorwerp is een directe superklasse van een array in Java.

3. Welke interfaces worden door arrays in Java geïmplementeerd?

Elk arraytype implementeert de interfaces Cloneable en java.io.Serializeerbaar .

4. Kunnen we de grootte van Array wijzigen?

De grootte van de array kan niet worden gewijzigd (eenmaal geïnitialiseerd). Er kan echter een arrayverwijzing worden gemaakt om naar een andere array te verwijzen.

Gerelateerde artikelen over het onderwerp

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