Trabajar con Arrays de Tipos Primitivos
En los pasos anteriores, trabajamos con arrays de tipos de referencia (String). Sin embargo, los arrays de Java también pueden contener tipos primitivos como int, double, etc. Convertir arrays de tipos primitivos a Lists requiere pasos adicionales porque los genéricos de Java solo funcionan con tipos de referencia.
Creemos un nuevo ejemplo para demostrar este proceso.
Crear un Nuevo Archivo Java
-
Cree un nuevo archivo Java llamado PrimitiveArrayToList.java en el mismo directorio:
Desde el WebIDE, navegue a project/src/main/java, haga clic con el botón derecho y seleccione "Nuevo archivo". Nómbrelo PrimitiveArrayToList.java.
-
Agregue el siguiente código al archivo:
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);
}
}
-
Compile y ejecute el programa:
cd ~/project
javac src/main/java/PrimitiveArrayToList.java
java -cp src/main/java PrimitiveArrayToList
Debería ver una salida similar a esta:
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]
Comprender la Conversión de Arrays de Tipos Primitivos
Al trabajar con arrays de tipos primitivos, hay dos consideraciones clave:
-
Autoboxing (Autoboxing): Java convierte automáticamente los valores primitivos a sus objetos de clase wrapper (envoltorio) cuando se agregan a las colecciones. Por ejemplo, int se convierte en Integer.
-
Métodos de Boxing (Boxing) para Streams: Al usar streams con arrays de tipos primitivos, necesita llamar al método .boxed() para convertir los streams primitivos en streams de objetos.
El proceso de conversión crea Lists completamente nuevas que son independientes de los arrays originales. Esto significa:
- Modificar la List no afectará al array original
- Las Lists son completamente mutables (puede agregar, eliminar o cambiar elementos)
- Cada elemento en la List es un nuevo objeto (wrapper) que contiene el valor del array
Esta independencia es particularmente útil cuando necesita manipular los datos sin arriesgarse a cambios en el array original.
