Il semble peu tard mais voici mes deux cents. Nous ne pouvons pas avoir List<int>
comme int
un type primitif, nous ne pouvons donc que l'avoir List<Integer>
.
Java 8 (tableau int)
int[] ints = new int[] {1,2,3,4,5};
List<Integer> list11 =Arrays.stream(ints).boxed().collect(Collectors.toList());
Java 8 et versions antérieures (tableau entier)
Integer[] integers = new Integer[] {1,2,3,4,5};
List<Integer> list21 = Arrays.asList(integers); // returns a fixed-size list backed by the specified array.
List<Integer> list22 = new ArrayList<>(Arrays.asList(integers)); // good
List<Integer> list23 = Arrays.stream(integers).collect(Collectors.toList()); //Java 8 only
Besoin d'ArrayList et non de List?
Dans le cas où nous voulons une implémentation spécifique, List
par exemple, ArrayList
nous pouvons utiliser toCollection
comme:
ArrayList<Integer> list24 = Arrays.stream(integers)
.collect(Collectors.toCollection(ArrayList::new));
Pourquoi list21
ne peut - on pas être modifié structurellement?
Lorsque nous utilisons Arrays.asList
la taille de la liste retournée est fixe car la liste retournée ne l'est pas java.util.ArrayList
, mais une classe statique privée définie à l'intérieur java.util.Arrays
. Donc, si nous ajoutons ou supprimons des éléments de la liste retournée, un UnsupportedOperationException
sera levé. Nous devons donc aller avec list22
quand nous voulons modifier la liste. Si nous avons Java8, nous pouvons également y aller list23
.
Pour être clair, cela list21
peut être modifié dans le sens que nous pouvons appeler, list21.set(index,element)
mais cette liste peut ne pas être structurellement modifiée, c'est-à-dire qu'elle ne peut pas ajouter ou supprimer des éléments de la liste. Vous pouvez également vérifier cette question .
Si nous voulons une liste immuable, nous pouvons l'envelopper comme suit:
List<Integer> list 22 = Collections.unmodifiableList(Arrays.asList(integers));
Un autre point à noter est que la méthode Collections.unmodifiableList
retourne une vue non modifiable de la liste spécifiée. Une collection de vues non modifiables est une collection non modifiable et est également une vue sur une collection de supports. Notez que des modifications de la collection de supports peuvent toujours être possibles et si elles se produisent, elles sont visibles à travers la vue non modifiable.
Nous pouvons avoir une liste vraiment immuable en Java 9 et 10.
Liste véritablement immuable
Java 9:
String[] objects = {"Apple", "Ball", "Cat"};
List<String> objectList = List.of(objects);
Java 10 (liste véritablement immuable) de deux manières:
List.copyOf(Arrays.asList(integers))
Arrays.stream(integers).collect(Collectors.toUnmodifiableList());
Consultez également ma réponse pour en savoir plus.
Arrays.asList(new int[] { 1, 2, 3 })
:; n'a certainement pas compilé en Java 1.4.2, car anint[]
n'est pas unObject[]
.