Beim Programmieren geht es häufig um die Verwaltung und Bearbeitung großer Datenmengen, wofür effiziente und effektive Datenstrukturen von entscheidender Bedeutung sind. Arrays sind eine grundlegende Datenstruktur in der Informatik und bieten die Möglichkeit, eine Folge fester Größe von Elementen desselben Typs zu speichern. In diesem Blog unternehmen wir eine ausführliche Reise durch Arrays in Java: Wir verstehen, was sie sind, ihre Syntax, wie man mit ihnen umgeht und wie sie ihre Speicherverwaltung verwalten.

Warum brauchen wir Arrays?

Wenn Sie mit Variablen in Java arbeiten, können Sie jede einzeln deklarieren und initialisieren, wie zum Beispiel:

java
int a = 19;
String name = "John Doe";

Dieser Ansatz wird jedoch ineffizient, wenn Sie mehrere Werte desselben Typs verarbeiten müssen. Wenn Sie beispielsweise mehrere Rollennummern oder -namen speichern, ist eine feste Codierung jedes Werts nicht praktikabel. Arrays sind praktisch, da sie es Ihnen ermöglichen, eine Sammlung von Werten effizient zu speichern. Wenn Sie beispielsweise fünf Rollennummern speichern müssen, können Sie Arrays verwenden.

Was sind Arrays?

Ein Array ist im Wesentlichen eine Sammlung von Datenelementen desselben Typs. Arrays können primitive Datentypen wie Ganzzahlen, Gleitkommazahlen und Zeichen sowie Objekte speichern. Zum Beispiel:

int[] rollNumbers = new int[5];
String[] names = {"Alice", "Bob", "Charlie"};

Syntax von Arrays

Die Syntax zum Deklarieren eines Arrays in Java ist einfach:

dataType[] arrayName = new dataType[size];

Um beispielsweise ein Array mit fünf Ganzzahlen zu erstellen:

int[] rollNumbers = new int[5];

Alternativ können Sie ein Array in einer einzigen Zeile deklarieren und initialisieren:

int[] rollNumbers = {23, 55, 9, 18, 45};

Eigenschaften von Arrays

Homogene Elemente

In einem Array müssen alle Elemente vom gleichen Typ sein. Sie können keine Typen innerhalb eines einzelnen Arrays mischen. Zum Beispiel:

int[] nums = {1, 2, "three"}; // Will cause a compile-time error

Feste Größe

Sobald ein Array erstellt wurde, ist seine Größe festgelegt. Sie können die Größe nicht vergrößern oder verkleinern. Diese Einschränkung kann häufig zur Auswahl anderer Datenstrukturen wie ArrayList für dynamischere Datenanforderungen führen.

Interne Speicherverwaltung

Arrays in Java bestehen aus:

• Stapelspeicher: Speichert die Referenzvariable des Arrays.
• Heap-Speicher: Speichert das eigentliche Array-Objekt und seine Elemente.

Wenn Sie ein Array deklarieren, wird die Referenz im Stapelspeicher erstellt und das Array-Objekt im Heap-Speicher gespeichert.

Speicherzuweisung

Es gibt zwei kritische Phasen bei der Speicherzuweisung eines Arrays:

1. Deklaration: Die Referenzvariable wird erstellt, zeigt aber nirgendwo hin.
2. Initialisierung: Die Referenzvariable zeigt auf das tatsächliche Array-Objekt im Heap, das die Elemente enthält.

Zum Beispiel:

int[] rollNumbers; // Declaration
rollNumbers = new int[5]; // Initialization

Dynamische Speicherzuweisung

Java führt eine dynamische Speicherzuweisung durch, was bedeutet, dass es zur Laufzeit Speicher nach Bedarf zuweist, was die Speicherverwaltung effizient macht.

Eingabe und Ausgabe in Arrays

Input annehmen

Um ein Array mit Benutzereingaben zu füllen, können Sie eine Schleife zusammen mit einem Scanner verwenden, um Eingaben von der Konsole zu lesen.

Scanner scanner = new Scanner(System.in);
int[] arr = new int[5];
for (int i = 0; i 




  
  
  Arrays drucken


Sie können Arrays mithilfe von Schleifen oder der Dienstprogrammmethode Arrays.toString() drucken, um eine besser lesbare Ausgabe zu erzielen.


for (int i = 0; i 



oder


System.out.println(Arrays.toString(arr));





  
  
  Mehrdimensionale Arrays


Zweidimensionale Arrays oder Matrizen sind Arrays von Arrays. Die Syntax für ein 2D-Array sieht folgendermaßen aus:


int[][] matrix = new int[3][3];





  
  
  Beispiel




int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};




Für eine dynamische Eingabe von Elementen in ein 2D-Array werden verschachtelte Schleifen verwendet.


  
  
  ArrayList: Eine dynamische Alternative


Arrays in Java haben eine feste Größe, was zu Ineffizienzen führt, wenn die Anzahl der Elemente zur Kompilierungszeit unbekannt ist. Diese Einschränkung kann durch die Verwendung der ArrayList-Klasse, Teil des Java Collections Framework, überwunden werden.


  
  
  Verwenden von ArrayList


Die ArrayList-Klasse ermöglicht eine dynamische Größenänderung. Hier ist die Syntax zum Erstellen einer ArrayList:


ArrayList numbers = new ArrayList();




Sie können Elemente dynamisch hinzufügen und bearbeiten:


numbers.add(1);
numbers.add(2);
numbers.add(3);
System.out.println(numbers); // Output: [1, 2, 3]

numbers.set(1, 10); // Change element at index 1
System.out.println(numbers); // Output: [1, 10, 3]

numbers.remove(0); // Remove element at index 0
System.out.println(numbers); // Output: [10, 3]

boolean contains = numbers.contains(10); // Check if the list contains 10
System.out.println(contains); // Output: true





  
  
  Interne Funktionsweise von ArrayList


Intern verwendet ArrayList dynamische Arrays mit einer anfänglichen festen Kapazität. Wenn diese Kapazität erschöpft ist, wird ein neues Array mit größerer Kapazität erstellt und vorhandene Elemente werden kopiert. Dieser Prozess stellt sicher, dass die ArrayList dynamisch wachsen kann, wenn Elemente hinzugefügt werden.


  
  
  Allgemeine Array-Operationen



  
  
  Maximale Elemente finden


Um das maximale Element in einem Array zu finden, durchlaufen Sie das Array und behalten Sie den höchsten Wert im Auge:


int max = arr[0];
for (int i = 1; i  max) {
        max = arr[i];
    }
}
System.out.println("Maximum value: "   max);





  
  
  Umkehren eines Arrays


Um ein Array umzukehren, verwenden Sie eine Zwei-Zeiger-Technik:


public static void reverse(int[] arr) {
    int start = 0;
    int end = arr.length - 1;
    while (start 



Aufruf der Umkehrfunktion:


int[] arr = {1, 2, 3, 4, 5};
reverse(arr);
System.out.println(Arrays.toString(arr)); // Output: [5, 4, 3, 2, 1]





  
  
  Abschluss


Arrays sind eine wichtige Datenstruktur in Java, die die effiziente Speicherung und Bearbeitung von Datensätzen ermöglicht. Obwohl sie eine feste Größe haben, sind Arrays leistungsstark und vielseitig beim Umgang mit homogenen Datentypen. Für dynamische Datenanforderungen bietet ArrayList zusätzliche Flexibilität und ermöglicht ein beliebiges Größenwachstum. Das Verständnis dieser Strukturen und ihrer Abläufe bildet die Grundlage für eine fortschrittlichere Programmierung und Datenverwaltung. Darüber hinaus hilft das Üben von Array-Operationen und das Verständnis der zugrunde liegenden Speicherverwaltung dabei, effizienteren und optimierten Code zu schreiben.