In Java Array ist eine Gruppe von Variablen gleichen Typs, auf die mit einem gemeinsamen Namen verwiesen wird. Arrays funktionieren in Java anders als in C/C++. Im Folgenden finden Sie einige wichtige Punkte zu Java-Arrays.

Arrays in Java

• In Java werden alle Arrays dynamisch zugewiesen. (nachfolgend diskutiert)
• Arrays können in einem zusammenhängenden Speicher [aufeinanderfolgenden Speicherorten] gespeichert werden.
• Da Arrays in Java Objekte sind, können wir ihre Länge mithilfe der Objekteigenschaft ermitteln Länge . Dies unterscheidet sich von C/C++, wo wir die Länge mithilfe von sizeof ermitteln.
• Eine Java-Array-Variable kann auch wie andere Variablen mit [] nach dem Datentyp deklariert werden.
• Die Variablen im Array sind geordnet und jede hat einen Index, der mit 0 beginnt.
• Java-Arrays können auch als statisches Feld, lokale Variable oder Methodenparameter verwendet werden.

Ein Array kann abhängig von der Definition des Arrays Primitive (int, char usw.) und Objektreferenzen (oder nicht-primitive Referenzen) einer Klasse enthalten. Bei primitiven Datentypen werden die tatsächlichen Werte möglicherweise an zusammenhängenden Speicherorten gespeichert (JVM garantiert dieses Verhalten nicht). Im Fall von Klassenobjekten Die eigentlichen Objekte werden in einem Heap-Segment gespeichert .

Python-Programm für die binäre Suche

Notiz: Diese Speicherung von Arrays hilft uns, zufällig auf die Elemente eines Arrays zuzugreifen [Unterstützung für wahlfreien Zugriff].

Erstellen, Initialisieren und Zugreifen auf Arrays

Eindimensionale Arrays

Die allgemeine Form einer eindimensionalen Array-Deklaration ist

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

Eine Array-Deklaration besteht aus zwei Komponenten: dem Typ und dem Namen. Typ deklariert den Elementtyp des Arrays. Der Elementtyp bestimmt den Datentyp jedes Elements, aus dem das Array besteht. Wie ein Array aus Ganzzahlen können wir auch ein Array aus anderen primitiven Datentypen wie char, float, double usw. oder benutzerdefinierten Datentypen (Objekten einer Klasse) erstellen. Somit bestimmt der Elementtyp für das Array, welche Art von Daten das Array enthalten soll.

Beispiel:

// 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;>

Obwohl die erste Deklaration festlegt, dass int Array eine Array-Variable ist, Es existiert kein tatsächliches Array . Es teilt dem Compiler lediglich mit, dass diese Variable (int Array) ein Array vom Typ Integer enthalten wird. Um ein int-Array mit einem tatsächlichen, physischen Array von Ganzzahlen zu verknüpfen, müssen Sie eines mit zuordnen neu und weisen Sie es dem int Array zu.

Instanziieren eines Arrays in Java

Wenn ein Array deklariert wird, wird nur eine Referenz eines Arrays erstellt. Um das Array zu erstellen oder ihm Speicher zu geben, erstellen Sie ein Array wie folgt: Die allgemeine Form von neu In Bezug auf eindimensionale Arrays sieht es wie folgt aus:

var-name = new type [size];>

Hier, Typ gibt die Art der zuzuordnenden Daten an, Größe bestimmt die Anzahl der Elemente im Array und Var-Name ist der Name der Array-Variablen, die mit dem Array verknüpft ist. Benutzen neu um ein Array zuzuweisen, Sie müssen den Typ und die Anzahl der zuzuordnenden Elemente angeben.

Beispiel:

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

Notiz: Die Elemente im Array, die von zugewiesen werden neu wird automatisch initialisiert null (für numerische Typen), FALSCH (für boolean), oder Null (für Referenztypen). Beziehen Sie sich auf Standard-Array-Werte in Java .

Das Erhalten eines Arrays ist ein zweistufiger Prozess. Zunächst müssen Sie eine Variable des gewünschten Array-Typs deklarieren. Zweitens müssen Sie mit new den Speicher für das Array zuweisen und ihn der Array-Variablen zuweisen. Daher, in Java , Alle Arrays werden dynamisch zugewiesen.

Array-Literal in Java

In einer Situation, in der die Größe des Arrays und die Variablen des Arrays bereits bekannt sind, können Array-Literale verwendet werden.

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

• Die Länge dieses Arrays bestimmt die Länge des erstellten Arrays.
• In den neuesten Java-Versionen ist es nicht erforderlich, den neuen int[]-Teil zu schreiben.

Zugriff auf Java-Array-Elemente mithilfe der for-Schleife

Auf jedes Element im Array wird über seinen Index zugegriffen. Der Index beginnt bei 0 und endet bei (Gesamtarraygröße)-1. Auf alle Elemente des Arrays kann mit Java for Loop zugegriffen werden.

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

Implementierung:

// 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>

Komplexität der oben genannten Methode:

Zeitkomplexität: O(n)
Hilfsraum: O(1)

Sie können auch mit auf Java-Arrays zugreifen für jede Schleife .

Datenstrukturen in Java

Arrays von Objekten in Java

Ein Array von Objekten wird auf folgende Weise wie ein Array von Datenelementen primitiven Typs erstellt.

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

Syntax:

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

Beispiel für Arrays von Objekten

Beispiel 1:

Nachfolgend finden Sie die Umsetzung des oben genannten Themas:

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>

Das Student-Array enthält fünf Speicherplätze mit der Größe einer Student-Klasse, in denen die Adressen von fünf Student-Objekten gespeichert werden können. Die Student-Objekte müssen mit dem Konstruktor der Student-Klasse instanziiert werden und ihre Referenzen sollten den Array-Elementen wie folgt zugewiesen werden.

Beispiel 2:

Nachfolgend finden Sie die Umsetzung des oben genannten Themas:

// 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>

Komplexität der oben genannten Methode:

Zeitkomplexität: O(n)
Hilfsraum: O(1)

Beispiel 3

Es wird auch ein Array von Objekten erstellt wie:

// 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>

Was passiert, wenn wir versuchen, auf Elemente außerhalb der Array-Größe zuzugreifen?

JVM wirft ArrayIndexOutOfBoundsException um anzuzeigen, dass mit einem unzulässigen Index auf das Array zugegriffen wurde. Der Index ist entweder negativ oder größer oder gleich der Größe eines Arrays.

Der folgende Code zeigt, was passiert, wenn wir versuchen, auf Elemente außerhalb der Array-Größe zuzugreifen:

// 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]); } }>

Ausgabe

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

Beispiel (Iterieren des Arrays):

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>

Komplexität der oben genannten Methode:

Zeitkomplexität: O(n), Hier ist n die Größe des Arrays.
Hilfsraum: O(1) , da kein zusätzlicher Platzbedarf besteht.

Mehrdimensionale Arrays in Java

Mehrdimensionale Arrays sind Arrays von Arrays wobei jedes Element des Arrays die Referenz anderer Arrays enthält. Diese werden auch als bezeichnet Gezackte Arrays . Ein mehrdimensionales Array wird erstellt, indem pro Dimension ein Satz eckiger Klammern ([]) angehängt wird.

Syntax des mehrdimensionalen Java-Arrays

Es gibt zwei Methoden zum Deklarieren von mehrdimensionalen Java-Arrays, wie unten erwähnt:

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

Beispiel:

ein Array von Objekten 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>

Mehrdimensionale Array-Deklaration

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

Beispiel eines mehrdimensionalen Arrays in Java

Beispiel 1:

Nachfolgend finden Sie die Implementierung der oben genannten 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>

Übergabe von Arrays an Methoden

Wie Variablen können wir auch Arrays an Methoden übergeben. Das folgende Programm übergibt beispielsweise das Array an die Methode Summe um die Summe der Werte des Arrays zu berechnen.

// 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>

Komplexität der oben genannten Methode:

Zeitkomplexität: An)
Hilfsraum: O(1)

Rückgabe von Arrays aus Methoden

Wie üblich kann eine Methode auch ein Array zurückgeben. Das folgende Programm gibt beispielsweise ein Array aus der Methode zurück 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>

Komplexität der oben genannten Methode:

Zeitkomplexität: O(n)
Hilfsraum: O(1)

Klassenobjekte für Arrays

Jedem Array ist ein Klassenobjekt zugeordnet, das mit allen anderen Arrays mit demselben Komponententyp geteilt wird.

// 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;>

Erläuterung der obigen Methode:

1. Die Zeichenfolge [I ist die Laufzeittypsignatur für das Klassenobjektarray mit Komponententyp int .
2. Die einzige direkte Oberklasse eines Array-Typs ist java.lang.Object .
3. Die Zeichenfolge [B ist die Laufzeittypsignatur für das Klassenobjektarray mit Komponententyp Byte .
4. Die Zeichenfolge [S ist die Laufzeittypsignatur für das Klassenobjektarray mit Komponententyp kurz .
5. Die Zeichenfolge [L ist die Laufzeittypsignatur für das Klassenobjektarray mit dem Komponententyp einer Klasse. Anschließend folgt der Klassenname.

Java-Array-Mitglieder

Nun wissen Sie, dass Arrays Objekte einer Klasse sind und eine direkte Oberklasse von Arrays ein Klassenobjekt ist. Die Mitglieder eines Array-Typs sind alle die folgenden:

• Das öffentliche letzte Feld Länge enthält die Anzahl der Komponenten des Arrays. Die Länge kann positiv oder null sein.
• Alle Mitglieder werden von der Klasse Object geerbt; Die einzige Methode von Object, die nicht vererbt wird, ist its Klon Methode.
• Die öffentliche Methode Klon() überschreibt die Klonmethode in der Klasse Object und löst Nein aus geprüfte Ausnahmen .

Array-Typen und ihre zulässigen Elementtypen

Klonen eines eindimensionalen Arrays in Java

Wenn Sie ein eindimensionales Array wie Object[] klonen, wird eine tiefe Kopie durchgeführt, wobei das neue Array Kopien der Elemente des ursprünglichen Arrays und keine Referenzen enthält.

Diskette

Nachfolgend finden Sie die Implementierung der oben genannten 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>

Klonen eines mehrdimensionalen Arrays in Java

Ein Klon eines mehrdimensionalen Arrays (wie Object[][]) ist jedoch eine flache Kopie, das heißt, es wird nur ein einzelnes neues Array erstellt, wobei jedes Elementarray eine Referenz auf ein ursprüngliches Elementarray darstellt, Unterarrays jedoch geteilt.

// 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>

Häufig gestellte Fragen zu Java-Arrays

1. Können wir die Größe des Arrays so lange angeben?

Nein, wir können die Größe des Arrays nicht als „long“ angeben, aber wir können sie als „int“ oder „short“ angeben.

2. Welches ist die direkte Oberklasse eines Arrays in Java?

Ein Objekt ist eine direkte Oberklasse eines Arrays in Java.

3. Welche Schnittstellen werden von Arrays in Java implementiert?

Jeder Array-Typ implementiert die Schnittstellen Cloneable und java.io.Serializable .

4. Können wir die Größe des Arrays ändern?

Die Größe des Arrays kann (nach der Initialisierung) nicht geändert werden. Es kann jedoch ein Array-Verweis erstellt werden, der auf ein anderes Array verweist.

Verwandte Artikel zum Thema

• Gezacktes Array in Java
• For-each-Schleife in Java
• Arrays-Klasse in Java