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:
Verwendung der Stream-API von Java mit der Methode stream.mapToInt()
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.
Coden ohne Setup – sofort loslegen.
Erstellen einer 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.
Stellen Sie zunächst sicher, dass Sie sich im Projektverzeichnis befinden:
cd /home/labex/project
Erstellen Sie eine neue Java-Datei im Maven-Quellverzeichnis:
cd src/main/java
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
}
}
Kompilieren Sie den Code mit Maven:
cd /home/labex/project
mvn compile
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 Befü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:
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;
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:
Stellen Sie sicher, dass Sie sich im Projektverzeichnis befinden:
cd /home/labex/project
Ö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");
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.
Einfach starten, ohne Installation.
Umwandlung einer 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
Stellen Sie sicher, dass Sie sich im Projektverzeichnis befinden:
cd /home/labex/project
Ö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");
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:
integerList.stream() - Erstellt einen Stream aus unserer Liste
.mapToInt(Integer::intValue) - Wandelt jedes Integer in ein int um
.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().
Umwandlung einer 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
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");
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:
integerList.toArray(new Integer[0]) - Wandelt die Liste in ein Array von Integer-Objekten um
ArrayUtils.toPrimitive() - Wandelt das Integer-Array in ein int-Array um
Diese Methode ist einfacher, erfordert aber die Apache Commons Lang-Bibliothek.
Mehr als nur ein Lerntext – erlebe es selbst.
Zusammenfassung
In diesem Lab haben Sie zwei verschiedene Methoden gelernt, um eine Integer-Liste in ein int-Array in Java umzuwandeln: