Ce laboratoire vous guidera tout au long du processus de conversion d'une liste d'entiers (Integer List) en tableau d'entiers primitifs (int Array) en Java. C'est une tâche courante en programmation Java lorsque vous avez besoin de travailler avec des tableaux primitifs après avoir collecté des données dans une liste.
Nous explorerons deux approches différentes pour effectuer cette conversion :
En utilisant l'API Stream de Java avec la méthode stream.mapToInt()
En utilisant la méthode ArrayUtils.toPrimitive() d'Apache Commons Lang
À la fin de ce laboratoire, vous comprendrez les deux méthodes et pourrez les appliquer dans vos propres applications Java.
Créer une classe Java pour notre expérience
Dans cette première étape, nous allons créer une classe Java pour démontrer les méthodes de conversion. Nous utiliserons Maven pour gérer nos dépendances et la structure du projet.
Tout d'abord, vérifiez que vous êtes dans le répertoire du projet :
cd /home/labex/project
Créez un nouveau fichier Java dans le répertoire source Maven :
cd src/main/java
Créez le fichier IntegerListToIntArray.java avec le contenu suivant :
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("---------------------------------------");
// Nous ajouterons notre code ici dans les étapes suivantes
}
}
Compilez le code en utilisant Maven :
cd /home/labex/project
mvn compile
Exécutez le programme pour vérifier qu'il fonctionne :
mvn exec:java
Vous devriez voir le texte d'en-tête imprimé dans la console. S'il n'y a pas d'erreurs, vous êtes prêt à passer à l'étape suivante.
Créer et remplir une liste d'entiers (Integer)
Dans cette étape, nous allons créer une liste d'entiers (Integer List) et y ajouter quelques nombres. Avant de commencer à coder, comprenons pourquoi nous avons besoin de cette conversion.
Pourquoi convertir entre une liste d'entiers (Integer List) et un tableau d'entiers primitifs (int Array) ?
En Java, nous avons deux façons de travailler avec des nombres :
Type primitif (int) :
Type de nombre de base qui stocke uniquement le nombre.
Consomme moins de mémoire.
Ne peut pas être utilisé directement dans des collections telles que les listes.
Exemple : int x = 5;
Classe wrapper (Integer) :
Objet qui contient un nombre.
Peut être utilisé dans des collections telles que les listes.
Dispose de méthodes et de fonctionnalités supplémentaires.
Exemple : Integer x = 5;
Nous collectons souvent des nombres dans une liste (qui nécessite des objets Integer), mais certaines méthodes ont besoin d'un tableau d'entiers primitifs (int) pour de meilleures performances. C'est pourquoi nous devons convertir entre les deux.
Mettre à jour le code Java
Modifions le fichier IntegerListToIntArray.java pour créer et afficher une liste de nombres :
Assurez-vous que vous êtes dans le répertoire du projet :
cd /home/labex/project
Ouvrez le fichier src/main/java/IntegerListToIntArray.java et ajoutez le code suivant à l'intérieur de la méthode main, après les instructions d'impression existantes :
// 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");
Compilez et exécutez le programme :
mvn compile
mvn exec:java
Vous devriez voir une sortie similaire à ceci :
Converting Integer List to int Array Demo
---------------------------------------
Original Integer List:
1 2 3 4 5
Cette sortie confirme que nous avons créé avec succès une liste d'entiers (Integer List) et l'avons remplie de nombres. Dans l'étape suivante, nous apprendrons à convertir cette liste en un tableau d'entiers primitifs (int).
Convertir une liste en tableau en utilisant l'API Stream
Dans cette étape, nous allons apprendre notre première méthode pour convertir une liste d'entiers (Integer List) en un tableau d'entiers (int array) en utilisant l'API Stream de Java. L'API Stream offre une manière moderne et efficace de traiter des collections de données.
Comprendre les flux Java (Java Streams)
Un flux (Stream) en Java est comme un pipeline qui peut traiter des données étape par étape :
Il prend des données à partir d'une source (notre liste).
Traite les données (convertit les objets Integer en entiers primitifs int).
Collecte les résultats (dans un tableau).
Ajouter le code de conversion
Assurez-vous que vous êtes dans le répertoire du projet :
cd /home/labex/project
Ouvrez le fichier src/main/java/IntegerListToIntArray.java et ajoutez ce code après le code de création de votre liste :
// 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");
Compilez et exécutez le programme :
mvn compile
mvn exec:java
Vous devriez voir une sortie comme celle-ci :
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
Comprendre le code
Décortiquons le fonctionnement de la conversion :
integerList.stream() - Crée un flux à partir de notre liste.
.mapToInt(Integer::intValue) - Convertit chaque objet Integer en un entier primitif int.
.toArray() - Collecte toutes les valeurs entières (int) dans un tableau.
Integer::intValue est appelé une référence de méthode. C'est une manière abrégée d'écrire number -> number.intValue().
Convertir une liste en tableau en utilisant ArrayUtils
Dans cette étape, nous allons apprendre une deuxième méthode pour convertir notre liste en utilisant la classe ArrayUtils de la bibliothèque Apache Commons Lang. Cette méthode est plus directe et peut être plus facile à comprendre pour les débutants.
Comprendre ArrayUtils
La classe ArrayUtils propose de nombreuses méthodes utiles pour travailler avec des tableaux. La méthode toPrimitive() en particulier nous aide à convertir des types wrapper (comme Integer) en types primitifs (comme int).
Ajouter le code de conversion avec ArrayUtils
Ajoutez ce code à votre fichier IntegerListToIntArray.java après le code utilisant l'API Stream :
// 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");
Compilez et exécutez le programme :
mvn compile
mvn exec:java
Vous devriez maintenant voir les deux méthodes de conversion dans la sortie :
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
Comprendre le code
La méthode utilisant ArrayUtils fonctionne en deux étapes :
integerList.toArray(new Integer[0]) - Convertit la liste en un tableau d'objets Integer.
ArrayUtils.toPrimitive() - Convertit le tableau d'objets Integer en un tableau d'entiers primitifs int.
Cette méthode est plus directe, mais nécessite la bibliothèque Apache Commons Lang.
Résumé
Dans ce laboratoire (lab), vous avez appris deux manières différentes de convertir une liste d'objets Integer en un tableau d'entiers primitifs int en Java :
Les deux méthodes donnent le même résultat, et vous pouvez choisir celle qui correspond le mieux à vos besoins :
Utilisez l'API Stream lorsque vous souhaitez une approche moderne et fonctionnelle.
Utilisez ArrayUtils lorsque vous souhaitez un code plus simple et plus lisible.
Vous avez maintenant les connaissances nécessaires pour convertir des listes d'objets Integer en tableaux d'entiers primitifs int dans vos applications Java.
