Trabalhando com Arrays Primitivos
Nas etapas anteriores, trabalhamos com arrays de tipos de referência (String). No entanto, os arrays Java também podem conter tipos primitivos como int, double, etc. Converter arrays primitivos para Lists requer etapas adicionais porque os generics Java só funcionam com tipos de referência.
Vamos criar um novo exemplo para demonstrar este processo.
Crie um Novo Arquivo Java
-
Crie um novo arquivo Java chamado PrimitiveArrayToList.java no mesmo diretório:
No WebIDE, navegue até project/src/main/java, clique com o botão direito e selecione "New File". Nomeie-o como PrimitiveArrayToList.java.
-
Adicione o seguinte código ao arquivo:
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 e execute o programa:
cd ~/project
javac src/main/java/PrimitiveArrayToList.java
java -cp src/main/java PrimitiveArrayToList
Você deve ver uma saída semelhante 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]
Compreendendo a Conversão de Arrays Primitivos
Ao trabalhar com arrays primitivos, há duas considerações principais:
-
Autoboxing: Java converte automaticamente valores primitivos em seus objetos de classe wrapper ao adicionar a coleções. Por exemplo, int é convertido em Integer.
-
Métodos de Boxing para Streams: Ao usar streams com arrays primitivos, você precisa chamar o método .boxed() para converter streams primitivos em streams de objetos.
O processo de conversão cria Lists completamente novas que são independentes dos arrays originais. Isso significa:
- Modificar a List não afetará o array original
- As Lists são totalmente mutáveis (você pode adicionar, remover ou alterar elementos)
- Cada elemento na List é um novo objeto (wrapper) que contém o valor do array
Essa independência é particularmente útil quando você precisa manipular os dados sem arriscar alterações no array original.
