In Java ist ein Array eine wichtige lineare Datenstruktur, die es uns ermöglicht, mehrere Werte desselben Typs zu speichern.

• Arrays in Java sind Objekte, die wie alle anderen Objekte in Java-Arrays implizit von der Klasse java.lang.Object erben. Dadurch können Sie in Object definierte Methoden aufrufen (z. B. toString() equal() und hashCode()).
• Arrays verfügen über eine integrierte Längeneigenschaft, die die Anzahl der Elemente im Array angibt

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 

Hauptmerkmale von Arrays

• Grundelemente und Objekte speichern: Java-Arrays können sowohl primitive Typen (wie int char boolean usw.) als auch Objekte (wie String Integer usw.) enthalten.
• Kontinuierliche Speicherzuweisung Wenn wir Arrays primitiver Typen verwenden, werden die Elemente an zusammenhängenden Orten gespeichert. Bei nicht-primitiven Typen werden Referenzen von Elementen an zusammenhängenden Orten gespeichert.
• Nullbasierte Indizierung: Das erste Element des Arrays hat den Index 0.
• Feste Länge: Nach dem Erstellen eines Arrays ist seine Größe festgelegt; wir können es nicht ändern.

Grundlagen zur Operation von Arrays in Java

1. Ein Array deklarieren

Die allgemeine Form der Array-Deklaration ist 

// Methode 1:
int arr[];

// Methode 2:
int[] arr;

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.

Verilog-Fallerklärung

Notiz: Es geht nur darum, wie wir eine Array-Variable erstellen können, es existiert kein tatsächliches Array. Es teilt dem Compiler lediglich mit, dass diese Variable (int Array) ein Array vom Typ Integer enthalten wird.

2. Initialisierung eines Arrays in Java

Wenn ein Array deklariert wird, wird nur eine Referenz eines Arrays erstellt. Wir verwenden new, um ein Array einer bestimmten Größe zuzuweisen.

int arr[] = new int[size];

• Die Array-Deklaration ist im Allgemeinen statisch, aber wenn die Größe nicht definiert ist, wird die Größe des Arrays dynamisch angepasst.
• Speicher für Arrays wird in Java immer dynamisch zugewiesen (im Heap-Segment). Dies unterscheidet sich von C/C++, wo Speicher entweder statisch oder dynamisch zugewiesen werden kann.
• Die durch new zugewiesenen Elemente im Array werden automatisch auf Null (für numerische Typen), false (für Boolean) oder Null (für Referenztypen) initialisiert.

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. 

Scrollrad funktioniert nicht

// Array-Literal deklarieren
int[] arr = new int[]{ 12345678910 };

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

3. Ändern Sie ein Array-Element

Um ein Element zu ändern, weisen Sie einem bestimmten Index einen neuen Wert zu. Der Index beginnt bei 0 und endet bei (Gesamtarraygröße)-1.

// Das erste Element auf 90 ändern
arr[0] = 90;

123Film

4. Array-Länge

Mit der Längeneigenschaft können wir die Länge eines Arrays ermitteln:

// Die Länge des Arrays ermitteln
int n = arr.length;

5. Zugriff auf und Aktualisierung aller Array-Elemente

• Auf alle Elemente des Arrays kann mit Java for Loop zugegriffen werden.
• Auf jedes Element im Array wird über seinen Index zugegriffen.

Ein Java-Programm zur Veranschaulichung der Erstellung eines Arrays von Ganzzahlen fügt einige Werte in das Array ein und gibt jeden Wert auf der Standardausgabe aus

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 von Objekten in Java

Ein Array von Objekten wird wie ein Array von Datenelementen primitiven Typs erstellt

Beispiel : Hier nehmen wir eine Student-Klasse und erstellen ein Array von Student mit fünf darin gespeicherten Student-Objekten. Die Student-Objekte müssen mit dem Konstruktor der Student-Klasse instanziiert werden und ihre Referenzen sollten den Array-Elementen zugewiesen werden.

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 } 

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

JVM löst eine ArrayIndexOutOfBoundsException aus, 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:

Java-Mathe

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

Ausgabe:

Ü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 sum, um die Summe der Array-Werte zu berechnen.

Beispiel:

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 

Erläuterung

• Dieses Java-Programm zeigt, wie ein Array an eine Methode übergeben wird.
• In der Hauptmethode wird ein ganzzahliges Array arr deklariert und initialisiert.
• Die Methode sum() wird mit arr als Argument aufgerufen.
• Innerhalb der sum()-Methode werden alle Array-Elemente mithilfe einer for-Schleife hinzugefügt.
• Die Endsumme wird dann auf der Konsole ausgegeben.

Rückgabe von Arrays aus Methoden

Wie üblich kann eine Methode auch ein Array zurückgeben. Das folgende Programm gibt beispielsweise ein Array von Methode m1 zurück. 

Java-Liste von

Beispiel:

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 

Vorteile von Java-Arrays

• Effizienter Zugriff: Der Zugriff auf ein Element über seinen Index ist schnell und hat eine konstante Zeitkomplexität O(1).
• Speicherverwaltung: Arrays haben eine feste Größe, was die Speicherverwaltung einfach und vorhersehbar macht.
• Datenorganisation: Arrays helfen dabei, Daten strukturiert zu organisieren und so die Verwaltung zusammengehöriger Elemente zu erleichtern.

Nachteile von Java-Arrays

• Feste Größe: Sobald ein Array erstellt wurde, kann seine Größe nicht mehr geändert werden, was zu Speicherverschwendung führen kann, wenn die Größe überschätzt wird, oder zu unzureichendem Speicher, wenn die Größe unterschätzt wird.
• Typhomogenität: Arrays können nur Elemente desselben Datentyps speichern, was bei gemischten Datentypen möglicherweise eine zusätzliche Behandlung erfordert.
• Einfügen und Löschen: Das Einfügen oder Löschen von Elementen, insbesondere in der Mitte eines Arrays, kann kostspielig sein, da möglicherweise Elemente verschoben werden müssen.

Verwandte Beiträge

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