Travailler avec les tableaux de types primitifs
Dans les étapes précédentes, nous avons travaillé avec des tableaux de types de référence (String). Cependant, les tableaux Java peuvent également contenir des types primitifs tels que int, double, etc. La conversion des tableaux de types primitifs en listes nécessite des étapes supplémentaires car les génériques Java ne fonctionnent qu'avec des types de référence.
Créons un nouvel exemple pour illustrer ce processus.
Créer un nouveau fichier Java
-
Créez un nouveau fichier Java appelé PrimitiveArrayToList.java dans le même répertoire :
Depuis le WebIDE, accédez à project/src/main/java, faites un clic droit et sélectionnez "New File". Nommez-le PrimitiveArrayToList.java.
-
Ajoutez le code suivant au fichier :
import java.util.Arrays;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class PrimitiveArrayToList {
public static void main(String[] args) {
System.out.println("Converting Primitive Arrays to Lists");
System.out.println("===================================");
// Create a primitive int array
int[] numbersArray = {10, 20, 30, 40, 50};
System.out.println("Original primitive array: " + Arrays.toString(numbersArray));
// Method 1: Manual conversion
System.out.println("\nMethod 1: Manual conversion");
List<Integer> numbersList1 = new ArrayList<>();
for (int number : numbersArray) {
numbersList1.add(number); // Autoboxing converts int to Integer
}
System.out.println("List after manual conversion: " + numbersList1);
// Method 2: Using Java 8 Streams
System.out.println("\nMethod 2: Using Java 8 Streams");
List<Integer> numbersList2 = Arrays.stream(numbersArray)
.boxed() // Converts IntStream to Stream<Integer>
.collect(Collectors.toList());
System.out.println("List after stream conversion: " + numbersList2);
// Modify the lists to demonstrate independence from the array
System.out.println("\nModifying the lists:");
numbersList1.add(60);
numbersList1.set(0, 15);
numbersList2.add(70);
numbersList2.remove(0);
System.out.println("List 1 after modifications: " + numbersList1);
System.out.println("List 2 after modifications: " + numbersList2);
System.out.println("Original array after List modifications: " + Arrays.toString(numbersArray));
// Create and convert other primitive type arrays
System.out.println("\nOther primitive type examples:");
double[] doubleArray = {1.1, 2.2, 3.3, 4.4, 5.5};
List<Double> doubleList = Arrays.stream(doubleArray)
.boxed()
.collect(Collectors.toList());
System.out.println("Double array: " + Arrays.toString(doubleArray));
System.out.println("Double list: " + doubleList);
boolean[] boolArray = {true, false, true, true, false};
List<Boolean> boolList = new ArrayList<>();
for (boolean value : boolArray) {
boolList.add(value);
}
System.out.println("Boolean array: " + Arrays.toString(boolArray));
System.out.println("Boolean list: " + boolList);
}
}
-
Compilez et exécutez le programme :
cd ~/project
javac src/main/java/PrimitiveArrayToList.java
java -cp src/main/java PrimitiveArrayToList
Vous devriez voir une sortie similaire à celle-ci :
Converting Primitive Arrays to Lists
===================================
Original primitive array: [10, 20, 30, 40, 50]
Method 1: Manual conversion
List after manual conversion: [10, 20, 30, 40, 50]
Method 2: Using Java 8 Streams
List after stream conversion: [10, 20, 30, 40, 50]
Modifying the lists:
List 1 after modifications: [15, 20, 30, 40, 50, 60]
List 2 after modifications: [20, 30, 40, 50, 70]
Original array after List modifications: [10, 20, 30, 40, 50]
Other primitive type examples:
Double array: [1.1, 2.2, 3.3, 4.4, 5.5]
Double list: [1.1, 2.2, 3.3, 4.4, 5.5]
Boolean array: [true, false, true, true, false]
Boolean list: [true, false, true, true, false]
Comprendre la conversion des tableaux de types primitifs
Lorsque vous travaillez avec des tableaux de types primitifs, il y a deux considérations clés :
-
Autoboxing : Java convertit automatiquement les valeurs primitives en leurs objets de classe wrapper lors de l'ajout aux collections. Par exemple, int est converti en Integer.
-
Méthodes de boxing pour les Streams : Lorsque vous utilisez des streams avec des tableaux de types primitifs, vous devez appeler la méthode .boxed() pour convertir les streams de types primitifs en streams d'objets.
Le processus de conversion crée des listes complètement nouvelles qui sont indépendantes des tableaux d'origine. Cela signifie que :
- La modification de la liste n'affectera pas le tableau d'origine.
- Les listes sont entièrement mutables (vous pouvez ajouter, supprimer ou modifier des éléments).
- Chaque élément de la liste est un nouvel objet (wrapper) qui contient la valeur du tableau.
Cette indépendance est particulièrement utile lorsque vous devez manipuler les données sans risquer de modifier le tableau d'origine.
