LabEx
LoginBeitreten

Java-Arrays und ArrayLists

JavaBeginner
Jetzt üben

Einführung

In diesem Lab werden wir uns mit zwei grundlegenden Datenstrukturen in Java befassen: Arrays und ArrayLists. Diese Strukturen ermöglichen es uns, Datenmengen zu speichern und zu manipulieren, was für viele Programmieraufgaben von entscheidender Bedeutung ist. Wir beginnen mit dem einfachen Array und gehen dann zu der flexibleren ArrayList über. Am Ende dieses Labs können Sie Arrays und ArrayLists in Java erstellen, manipulieren und damit arbeiten.

Wir werden folgende Themen behandeln:

  1. Erstellen und Verwenden von Arrays
  2. Zugreifen auf und Modifizieren von Array-Elementen
  3. Einführung in ArrayLists
  4. Hinzufügen, Entfernen und Zugreifen auf Elemente in ArrayLists
  5. Konvertieren zwischen Arrays und ArrayLists

Lassen Sie uns beginnen, unsere Daten zu organisieren!

Erstellen und Verwenden von Arrays

Arrays sind eine grundlegende Datenstruktur in Java, die es Ihnen ermöglicht, mehrere Elemente desselben Typs zu speichern. Stellen Sie sich ein Array wie eine Reihe von Kisten vor, wobei jede Kiste ein Element eines bestimmten Typs aufnehmen kann.

  1. Öffnen Sie die Datei ArrayDemo.java in Ihrem Projektverzeichnis.

    public class ArrayDemo {
    public static void main(String[] args) {
        // We'll add our code here
    }
}

    Dies ist die Grundstruktur unseres Java-Programms. Die main-Methode ist der Einstiegspunkt unseres Programms.

  2. Deklarieren und initialisieren Sie nun ein Array von Ganzzahlen. Fügen Sie die folgende Zeile in die main-Methode ein:

    int[] numbers = {1, 2, 3, 4, 5};

    Diese Zeile erstellt ein Array von Ganzzahlen namens numbers und initialisiert es mit den Werten 1, 2, 3, 4 und 5. Die eckigen Klammern [] sagen Java, dass numbers ein Array ist.

  3. Geben Sie die Elemente unseres Arrays aus. Fügen Sie diese Zeilen nach der Array-Deklaration hinzu:

    System.out.println("The elements of the array are:");
for (int i = 0; i < numbers.length; i++) {
    System.out.println("Element at index " + i + ": " + numbers[i]);
}

    Dieser Code verwendet eine for-Schleife, um durch das Array zu iterieren. numbers.length gibt uns die Größe des Arrays, und numbers[i] greift auf das Element am Index i zu.

Java array elements output

  1. Speichern Sie die Datei, kompilieren und starten Sie das Programm:

    javac ~/project/ArrayDemo.java
java -cp ~/project ArrayDemo

    Sie sollten eine Ausgabe ähnlich dieser sehen:

    The elements of the array are:
Element at index 0: 1
Element at index 1: 2
Element at index 2: 3
Element at index 3: 4
Element at index 4: 5

  2. Berechnen Sie nun die Summe aller Elemente im Array. Fügen Sie diesen Code nach der vorherigen Schleife hinzu:

    int sum = 0;
for (int number : numbers) {
    sum += number;
}
System.out.println("The sum of the elements is: " + sum);

    Dieser Code verwendet eine erweiterte for-Schleife (auch als for-each-Schleife bekannt), um durch das Array zu iterieren. Es ist eine einfachere Möglichkeit, alle Elemente zu durchlaufen, wenn Sie nicht den Index benötigen.

  3. Finden Sie schließlich den maximalen Wert im Array. Fügen Sie diesen Code hinzu:

    int max = numbers[0];
for (int i = 1; i < numbers.length; i++) {
    if (numbers[i] > max) {
        max = numbers[i];
    }
}
System.out.println("The maximum value in the array is: " + max);

    Dieser Code geht davon aus, dass das erste Element der maximale Wert ist, vergleicht dann jedes nachfolgende Element mit dem aktuellen Maximum und aktualisiert das Maximum, wenn ein größerer Wert gefunden wird.

  4. Speichern Sie, kompilieren und starten Sie das Programm erneut. Sie sollten die zusätzliche Ausgabe sehen:

    The sum of the elements is: 15
The maximum value in the array is: 5

Java array output example

  1. Arrays in Java haben eine feste Größe, aber wir können ihre Elemente ändern. Ändern Sie ein Element und geben Sie das modifizierte Array aus. Fügen Sie diesen Code am Ende der main-Methode hinzu:

    numbers[2] = 10;
System.out.println("\nAfter modifying the third element:");
for (int number : numbers) {
    System.out.print(number + " ");
}
System.out.println();

    Dies ändert den Wert des dritten Elements (Index 2) auf 10 und gibt dann das modifizierte Array aus.

  2. Speichern Sie, kompilieren und starten Sie das Programm noch einmal. Sie sollten die zusätzliche Ausgabe sehen:

    After modifying the third element:
1 2 10 4 5

Herzlichen Glückwunsch! Sie haben nun ein Array erstellt, auf seine Elemente zugegriffen, Berechnungen mit seinen Werten durchgeführt und ein Element geändert. Denken Sie daran, dass Arrays in Java eine feste Größe haben, d. h., dass Sie die Länge eines Arrays nach der Erstellung nicht ändern können. Sie können jedoch die Werte seiner Elemente ändern.

Einführung in ArrayLists

Nachdem wir uns mit Arrays beschäftigt haben, wollen wir uns nun ArrayLists vorstellen. ArrayLists sind Teil des Java Collections Frameworks und bieten eine flexiblere Möglichkeit, mit Listen von Objekten zu arbeiten. Im Gegensatz zu Arrays können ArrayLists dynamisch an Größe wachsen oder schrumpfen.

  1. Öffnen Sie die Datei ArrayListDemo.java in Ihrem Projektverzeichnis.

    import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String[] args) {
        // We'll add our code here
    }
}

    Beachten Sie die import-Anweisung oben. Diese teilt Java mit, dass wir die ArrayList-Klasse in unserem Programm verwenden möchten.

  2. Erstellen wir nun eine ArrayList von Strings. Fügen Sie diese Zeile in die main-Methode ein:

    ArrayList<String> fruits = new ArrayList<>();

    Dies erstellt eine leere ArrayList, die String-Objekte enthalten kann. Der <String>-Teil wird "Generics" genannt und gibt den Typ der Elemente an, die die ArrayList enthalten wird.

  3. Fügen wir einige Elemente zu unserer ArrayList hinzu. Fügen Sie diese Zeilen hinzu:

    fruits.add("Apple");
fruits.add("Banana");
fruits.add("Cherry");

    Die add()-Methode fügt Elemente am Ende der Liste hinzu.

  4. Geben wir nun unsere ArrayList aus. Fügen Sie diesen Code hinzu:

    System.out.println("Fruits in the list:");
for (String fruit : fruits) {
    System.out.println(fruit);
}

    Dies verwendet eine erweiterte for-Schleife, um durch die ArrayList zu iterieren, ähnlich wie wir es mit Arrays getan haben.

    Tipp: Sie können Ihr Programm jederzeit kompilieren und ausführen, um die Ausgabe zu sehen. Oder Sie können weiter Code hinzufügen und alles am Ende ausführen.

  5. ArrayLists haben viele nützliche Methoden. Probieren wir einige aus. Fügen Sie diesen Code hinzu:

    System.out.println("\nNumber of fruits: " + fruits.size());
System.out.println("The second fruit is: " + fruits.get(1));

    size() gibt die Anzahl der Elemente in der ArrayList zurück, und get(index) ruft das Element am angegebenen Index ab.

  6. Wir können auch Elemente in einer ArrayList mit der set()-Methode ersetzen. Fügen Sie diesen Code hinzu:

    // Before: [Apple, Banana, Cherry]
fruits.set(1, "Blueberry");    // Replaces "Banana" with "Blueberry"
System.out.println("\nAfter replacing the second fruit:");
System.out.println(fruits);     // [Apple, Blueberry, Cherry]

    set(index, element) ersetzt das Element am angegebenen Index durch ein neues Element. Die Größe der ArrayList bleibt dabei gleich.

  7. Im Gegensatz zu Arrays ermöglichen es uns ArrayLists, Elemente an beliebiger Position mit der add(index, element)-Methode einzufügen. Dies unterscheidet sich von der set()-Methode, die wir zuvor gesehen haben. Schauen wir uns an, wie add() funktioniert:

    // Before: [Apple, Blueberry, Cherry]
fruits.add(1, "Blackberry");
System.out.println("\nAfter inserting Blackberry at index 1:");
System.out.println(fruits);
// After: [Apple, Blackberry, Blueberry, Cherry]

    Lassen Sie uns verstehen, was passiert ist:

    • add(1, "Blackberry") fügt "Blackberry" an Index 1 ein.
    • Die vorhandenen Elemente ab Index 1 (Blueberry, Cherry) werden automatisch um eine Position nach rechts verschoben.
    • Die Größe der ArrayList erhöht sich um 1.
    • Dies unterscheidet sich von set(), das das vorhandene Element ersetzen würde, ohne zu verschieben oder die Größe zu ändern.

    Um den Unterschied zu visualisieren:

    // Using add(index, element) - inserts and shifts
fruits.add(1, "Blackberry");    // [Apple, Blackberry, Blueberry, Cherry]

// Using set(index, element) - replaces without shifting
fruits.set(1, "Blackberry");    // [Apple, Blackberry, Cherry]

  8. Wir können auch Elemente aus einer ArrayList entfernen. Fügen Sie diesen Code hinzu:

    fruits.remove("Cherry");
System.out.println("\nAfter removing Cherry:");
System.out.println(fruits);

    Dies entfernt das erste Vorkommen von "Cherry" aus der ArrayList. Wenn ein Element entfernt wird, werden alle nachfolgenden Elemente nach links verschoben, um die Lücke zu schließen.

  9. Überprüfen wir schließlich, ob bestimmte Elemente in unserer ArrayList enthalten sind:

    System.out.println("\nDoes the list contain Apple? " + fruits.contains("Apple"));
System.out.println("Does the list contain Cherry? " + fruits.contains("Cherry"));

    Die contains()-Methode überprüft, ob die ArrayList ein bestimmtes Element enthält, und gibt einen booleschen Wert zurück.

  10. Speichern Sie die Datei, kompilieren und führen Sie das Programm aus:

    javac ~/project/ArrayListDemo.java
java -cp ~/project ArrayListDemo

    Sie sollten eine Ausgabe ähnlich dieser sehen:

    Fruits in the list:
Apple
Banana
Cherry

Number of fruits: 3
The second fruit is: Banana

After replacing the second fruit:
[Apple, Blueberry, Cherry]

After inserting Blackberry at index 1:
[Apple, Blackberry, Blueberry, Cherry]

After removing Cherry:
[Apple, Blackberry, Blueberry]

Does the list contain Apple? true
Does the list contain Cherry? false

Herzlichen Glückwunsch! Sie haben nun eine ArrayList erstellt, Elemente hinzugefügt und entfernt, auf Elemente über den Index zugegriffen und verschiedene ArrayList-Methoden verwendet. Sie haben die wichtigen Unterschiede zwischen Operationen wie add(), die Elemente einfügt und verschiebt, und set(), die Elemente ersetzt, gelernt. ArrayLists bieten mehr Flexibilität als Arrays, da sie je nach Bedarf wachsen und schrumpfen können. Dies macht sie sehr nützlich, wenn Sie nicht im Voraus wissen, wie viele Elemente Sie verarbeiten werden.

Konvertieren zwischen Arrays und ArrayLists

Manchmal müssen Sie möglicherweise zwischen Arrays und ArrayLists konvertieren. Java bietet bequeme Methoden dafür. Lassen Sie uns untersuchen, wie man ein Array in eine ArrayList und umgekehrt konvertiert.

  1. Öffnen Sie die Datei ConversionDemo.java in Ihrem Projektverzeichnis.

    import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ConversionDemo {
    public static void main(String[] args) {
        // We'll add our code here
    }
}

    Beachten Sie die Import-Anweisungen oben. Wir importieren Klassen, die wir für unsere Konvertierungen benötigen.

  2. Beginnen wir damit, ein Array in eine ArrayList zu konvertieren. Fügen Sie diesen Code in die main-Methode ein:

    String[] colorArray = {"Red", "Green", "Blue"};
List<String> colorList = Arrays.asList(colorArray);

System.out.println("Array converted to ArrayList:");
System.out.println(colorList);

    Arrays.asList() konvertiert ein Array in eine List. Beachten Sie, dass dies eine Liste mit fester Größe erstellt, die vom ursprünglichen Array unterstützt wird.

  3. Ändern wir die ArrayList und sehen, was mit dem ursprünglichen Array passiert. Fügen Sie diesen Code hinzu:

    colorList.set(1, "Yellow");

System.out.println("\nAfter modifying the ArrayList:");
System.out.println(colorList);
System.out.println("Original array after ArrayList modification:");
System.out.println(Arrays.toString(colorArray));

    Arrays.toString() ist eine bequeme Methode, um ein Array auszugeben.

  4. Konvertieren wir nun eine ArrayList in ein Array. Fügen Sie diesen Code hinzu:

    ArrayList<Integer> numberList = new ArrayList<>();
numberList.add(1);
numberList.add(2);
numberList.add(3);

Integer[] numberArray = numberList.toArray(new Integer[0]);

System.out.println("\nArrayList converted to array:");
System.out.println(Arrays.toString(numberArray));

    Wir verwenden die toArray()-Methode der ArrayList, um sie in ein Array zu konvertieren. Wir übergeben new Integer[0] als Argument, das als Hinweis für den Typ und die Größe des zu erstellenden Arrays dient.

  5. Ändern wir schließlich das Array und sehen, ob es die ArrayList beeinflusst. Fügen Sie diesen Code hinzu:

    numberArray[0] = 100;
System.out.println("\nAfter modifying the array:");
System.out.println("Array: " + Arrays.toString(numberArray));
System.out.println("ArrayList: " + numberList);

  6. Speichern Sie die Datei, kompilieren und führen Sie das Programm aus:

    javac ~/project/ConversionDemo.java
java -cp ~/project ConversionDemo

    Sie sollten eine Ausgabe ähnlich dieser sehen:

    Array converted to ArrayList:
[Red, Green, Blue]

After modifying the ArrayList:
[Red, Yellow, Blue]
Original array after ArrayList modification:
[Red, Yellow, Blue]

ArrayList converted to array:
[1, 2, 3]

After modifying the array:
Array: [100, 2, 3]
ArrayList: [1, 2, 3]

Diese Demonstration zeigt, wie Arrays und ArrayLists ineinander konvertiert werden können. Es ist wichtig, den Unterschied im Verhalten zu beachten:

  • Wenn Sie ein Array in eine Liste mit Arrays.asList() konvertieren, wird die resultierende Liste vom ursprünglichen Array unterstützt. Dies bedeutet, dass Änderungen an der Liste auch im Array widergespiegelt werden und umgekehrt.
  • Wenn Sie eine ArrayList in ein Array mit toArray() konvertieren, erstellen Sie ein neues Array, das unabhängig von der ArrayList ist. Änderungen an diesem neuen Array wirken sich nicht auf die ursprüngliche ArrayList aus.

Das Verständnis dieser Konvertierungen und ihres Verhaltens ist entscheidend, wenn Sie mit verschiedenen Sammlungs-Typen in Java arbeiten, insbesondere wenn Sie mit APIs oder Bibliotheken interagieren, die möglicherweise einen Typ gegenüber dem anderen bevorzugen.

Zusammenfassung

In diesem Lab haben wir uns mit zwei grundlegenden Datenstrukturen in Java beschäftigt: Arrays und ArrayLists. Lassen Sie uns zusammenfassen, was wir gelernt haben:

  1. Arrays:

    • Wir haben Arrays erstellt und initialisiert, indem wir die Syntax int[] numbers = {1, 2, 3, 4, 5}; verwendet haben.
    • Wir haben gelernt, wie man auf Array-Elemente über die Indexnotation zugreift, wie z. B. numbers[0].
    • Wir haben sowohl traditionelle for-Schleifen als auch erweiterte for-Schleifen verwendet, um durch Arrays zu iterieren.
    • Wir haben Berechnungen mit Array-Elementen durchgeführt, wie z. B. die Summe und den maximalen Wert zu finden.
    • Wir haben gesehen, dass Arrays eine feste Größe haben, aber wir können ihre Elemente ändern.

  2. ArrayLists:

    • Wir haben ArrayLists erstellt, indem wir ArrayList<String> fruits = new ArrayList<>(); verwendet haben.
    • Wir haben gelernt, wie man Elemente mit add() hinzufügt, Elemente mit remove() entfernt und auf Elemente mit get() zugreift.
    • Wir haben Methoden wie size(), set() und contains() verwendet, um mit ArrayLists zu arbeiten.
    • Wir haben gesehen, dass ArrayLists dynamisch wachsen und schrumpfen können, was mehr Flexibilität als Arrays bietet.

  3. Konvertieren zwischen Arrays und ArrayLists:

    • Wir haben Arrays in ArrayLists mit Arrays.asList() konvertiert.
    • Wir haben ArrayLists in Arrays mit der toArray()-Methode konvertiert.
    • Wir haben das unterschiedliche Verhalten beim Ändern von konvertierten Sammlungen beobachtet.

Arrays und ArrayLists sind essentielle Werkzeuge in der Java-Programmierung. Arrays eignen sich hervorragend für die Arbeit mit einer festen Anzahl von Elementen und können in Bezug auf den Speicherverbrauch effizienter sein. ArrayLists hingegen bieten mehr Flexibilität und eine Vielzahl von Methoden zur Manipulation der Sammlung.

Wenn Sie Ihre Java-Reise fortsetzen, werden Sie feststellen, dass Sie sowohl Arrays als auch ArrayLists häufig verwenden. Die Wahl zwischen ihnen hängt oft von Ihren spezifischen Anforderungen ab - wenn Sie die genaue Anzahl der Elemente kennen, mit denen Sie arbeiten werden, ist ein Array möglicherweise vorzuziehen. Wenn Sie eine dynamische Sammlung benötigen, die wachsen oder schrumpfen kann, oder wenn Sie die zusätzlichen Methoden, die von ArrayLists bereitgestellt werden, benötigen, dann ist eine ArrayList die bessere Wahl.

Verwandt Java Kurse
Java für Anfänger

Java für Anfänger

java
Java-Programmierübungen

Java-Programmierübungen

java
Massenimport von Daten in den Kursplan

Massenimport von Daten in den Kursplan

java