Umwandlung einer Integer-Liste in ein int-Array

Einführung

In diesem Lab werden Sie durch den Prozess der Umwandlung einer Integer-Liste in ein int-Array in Java geführt. Dies ist eine häufige Aufgabe in der Java-Programmierung, wenn Sie mit primitiven Arrays arbeiten müssen, nachdem Sie Daten in einer Liste gesammelt haben.

Wir werden zwei verschiedene Ansätze zur Durchführung dieser Umwandlung untersuchen:

1. Verwendung der Stream-API von Java mit der Methode stream.mapToInt()
2. Verwendung der Methode ArrayUtils.toPrimitive() von Apache Commons Lang

Am Ende dieses Labs werden Sie beide Methoden verstehen und in der Lage sein, sie in Ihren eigenen Java-Anwendungen anzuwenden.

Erstellen Sie eine Java-Klasse für unser Experiment

In diesem ersten Schritt werden wir eine Java-Klasse erstellen, um die Umwandlungsmethoden zu demonstrieren. Wir werden Maven verwenden, um unsere Abhängigkeiten und die Projektstruktur zu verwalten.

1. Stellen Sie zunächst sicher, dass Sie sich im Projektverzeichnis befinden:

cd /home/labex/project

2. Erstellen Sie eine neue Java-Datei im Maven-Quellverzeichnis:

cd src/main/java

3. Erstellen Sie IntegerListToIntArray.java mit folgendem Inhalt:

import java.util.ArrayList;
import java.util.List;
import org.apache.commons.lang3.ArrayUtils;

public class IntegerListToIntArray {
    public static void main(String[] args) {
        System.out.println("Converting Integer List to int Array Demo");
        System.out.println("---------------------------------------");

        // Wir werden unseren Code hier in den folgenden Schritten hinzufügen
    }
}

4. Kompilieren Sie den Code mit Maven:

cd /home/labex/project
mvn compile

5. Führen Sie das Programm aus, um zu überprüfen, ob es funktioniert:

mvn exec:java

Sie sollten den Überschriftstext in der Konsole sehen. Wenn keine Fehler auftreten, können Sie mit dem nächsten Schritt fortfahren.

Erstellen und Füllen einer Integer-Liste

In diesem Schritt werden wir eine Integer-Liste erstellen und einige Zahlen hinzufügen. Bevor wir mit dem Codieren beginnen, verstehen wir zunächst, warum wir diese Umwandlung benötigen.

Warum zwischen Integer-Liste und int-Array umwandeln?

In Java gibt es zwei Möglichkeiten, mit Zahlen zu arbeiten:

1. Primitive Typ (int):

   • Grundlegender Zahlentyp, der nur die Zahl speichert
   • Verwendet weniger Speicher
   • Kann nicht direkt in Sammlungen wie Listen verwendet werden
   • Beispiel: int x = 5;

2. Wrapper-Klasse (Integer):

   • Objekt, das eine Zahl enthält
   • Kann in Sammlungen wie Listen verwendet werden
   • Hat zusätzliche Methoden und Funktionen
   • Beispiel: Integer x = 5;

Wir sammeln oft Zahlen in einer Liste (die Integer erfordert), aber einige Methoden benötigen ein primitives int-Array für eine bessere Leistung. Deshalb müssen wir zwischen ihnen umwandeln.

Aktualisieren des Java-Codes

Ändern wir unsere IntegerListToIntArray.java-Datei, um eine Liste von Zahlen zu erstellen und anzuzeigen:

1. Stellen Sie sicher, dass Sie sich im Projektverzeichnis befinden:

cd /home/labex/project

2. Öffnen Sie src/main/java/IntegerListToIntArray.java und fügen Sie den folgenden Code innerhalb der main-Methode nach den vorhandenen Ausgabebefehlen hinzu:

// Create a List of Integer objects
List<Integer> integerList = new ArrayList<>();

// Add some numbers to the list
integerList.add(1);
integerList.add(2);
integerList.add(3);
integerList.add(4);
integerList.add(5);

// Display the list contents
System.out.println("Original Integer List:");
for (Integer num : integerList) {
    System.out.print(num + " ");
}
System.out.println("\n");

3. Kompilieren und führen Sie das Programm aus:

mvn compile
mvn exec:java

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Converting List List to int Array Demo
---------------------------------------
Original Integer List:
1 2 3 4 5

Diese Ausgabe bestätigt, dass wir erfolgreich eine Integer-Liste erstellt und mit Zahlen befüllt haben. Im nächsten Schritt werden wir lernen, wie wir diese Liste in ein primitives int-Array umwandeln.

Konvertieren Sie eine Liste in ein Array mit der Stream API

In diesem Schritt lernen wir unsere erste Methode, um eine Integer-Liste in ein int-Array mit Java's Stream-API umzuwandeln. Die Stream-API bietet eine moderne und effiziente Möglichkeit, Datenkollektionen zu verarbeiten.

Grundlagen der Java-Streams

Ein Stream in Java ist wie eine Pipeline, die Daten schrittweise verarbeiten kann:

• Es nimmt Daten aus einer Quelle (unserer Liste)
• Verarbeitet die Daten (wandelt Integer in int um)
• Sammelt die Ergebnisse (in ein Array)

Hinzufügen des Umwandlungscodes

1. Stellen Sie sicher, dass Sie sich im Projektverzeichnis befinden:

cd /home/labex/project

2. Öffnen Sie src/main/java/IntegerListToIntArray.java und fügen Sie diesen Code nach Ihrem Code zur Listen-Erstellung hinzu:

// Method 1: Using Stream API
System.out.println("Converting using Stream API:");

// Convert Integer List to int array using Stream
int[] intArrayUsingStream = integerList.stream()    // Create a stream from the list
                                     .mapToInt(Integer::intValue)  // Convert Integer to int
                                     .toArray();    // Collect results into an array

// Print the converted array
System.out.println("Converted int Array:");
for (int value : intArrayUsingStream) {
    System.out.print(value + " ");
}
System.out.println("\n");

3. Kompilieren und führen Sie das Programm aus:

mvn compile
mvn exec:java

Sie sollten eine Ausgabe wie die folgende sehen:

Converting Integer List to int Array Demo
---------------------------------------
Original Integer List:
1 2 3 4 5

Converting using Stream API:
Converted int Array:
1 2 3 4 5

Funktionsweise des Codes

Lassen Sie uns analysieren, wie die Umwandlung funktioniert:

1. integerList.stream() - Erstellt einen Stream aus unserer Liste
2. .mapToInt(Integer::intValue) - Wandelt jedes Integer in ein int um
3. .toArray() - Sammelt alle int-Werte in ein Array

Integer::intValue wird als Methoden-Referenz (method reference) bezeichnet. Es ist eine Abkürzung für number -> number.intValue().

Konvertieren Sie eine Liste in ein Array mit ArrayUtils

In diesem Schritt lernen wir eine zweite Methode, um unsere Liste mit der ArrayUtils-Klasse aus der Apache Commons Lang-Bibliothek umzuwandeln. Diese Methode ist einfacher und für Anfänger möglicherweise leichter zu verstehen.

Grundlagen von ArrayUtils

Die ArrayUtils-Klasse bietet viele nützliche Methoden für die Arbeit mit Arrays. Die toPrimitive()-Methode hilft uns speziell, von Wrapper-Typen (wie Integer) zu primitiven Typen (wie int) umzuwandeln.

Hinzufügen des ArrayUtils-Umwandlungscodes

1. Fügen Sie diesen Code in Ihre IntegerListToIntArray.java-Datei nach dem Stream-API-Code ein:

// Method 2: Using ArrayUtils
System.out.println("Converting using ArrayUtils:");

// First convert List<Integer> to Integer[]
Integer[] intermediateArray = integerList.toArray(new Integer[0]);

// Then convert Integer[] to int[]
int[] intArrayUsingArrayUtils = ArrayUtils.toPrimitive(intermediateArray);

// Print the converted array
System.out.println("Converted int Array:");
for (int value : intArrayUsingArrayUtils) {
    System.out.print(value + " ");
}
System.out.println("\n");

2. Kompilieren und führen Sie das Programm aus:

mvn compile
mvn exec:java

Sie sollten jetzt beide Umwandlungsmethoden in der Ausgabe sehen:

Converting Integer List to int Array Demo
---------------------------------------
Original Integer List:
1 2 3 4 5

Converting using Stream API:
Converted int Array:
1 2 3 4 5

Converting using ArrayUtils:
Converted int Array:
1 2 3 4 5

Funktionsweise des Codes

Die ArrayUtils-Methode arbeitet in zwei Schritten:

1. integerList.toArray(new Integer[0]) - Wandelt die Liste in ein Array von Integer-Objekten um
2. ArrayUtils.toPrimitive() - Wandelt das Integer-Array in ein int-Array um

Diese Methode ist einfacher, erfordert aber die Apache Commons Lang-Bibliothek.

Zusammenfassung

In diesem Lab haben Sie zwei verschiedene Methoden gelernt, um eine Integer-Liste in ein int-Array in Java umzuwandeln:

1. Mit Java's Stream-API:

int[] array = integerList.stream().mapToInt(Integer::intValue).toArray();

• Moderner und funktionaler Ansatz
• In Java integriert
• Gut geeignet für die schrittweise Verarbeitung von Daten

2. Mit ArrayUtils aus Apache Commons Lang:

int[] array = ArrayUtils.toPrimitive(integerList.toArray(new Integer[0]));

• Einfacherer Ansatz
• Erfordert eine externe Bibliothek
• Leicht zu verstehen und zu nutzen

Beide Methoden erzielen dasselbe Ergebnis, und Sie können diejenige wählen, die Ihren Bedürfnissen am besten entspricht:

• Verwenden Sie die Stream-API, wenn Sie einen modernen, funktionalen Ansatz wünschen.
• Verwenden Sie ArrayUtils, wenn Sie einen einfachereren, lesbareren Code wünschen.

Sie verfügen nun über das Wissen, um in Ihren Java-Anwendungen zwischen Integer-Listen und int-Arrays zu konvertieren.