Question Conversion de tableau en liste en Java


Comment puis-je convertir un tableau en une liste en Java?

J'ai utilisé le Arrays.asList() mais le comportement (et la signature) en quelque sorte changé de Java SE 1.4.2 (docs maintenant dans les archives) à 8 et la plupart des extraits que j'ai trouvés sur le web utilisent le comportement 1.4.2.

Par exemple:

int[] spam = new int[] { 1, 2, 3 };
Arrays.asList(spam)
  • sur 1.4.2 renvoie une liste contenant les éléments 1, 2, 3
  • sur 1.5.0+ renvoie une liste contenant le spam de tableau

Dans de nombreux cas, il devrait être facile à détecter, mais parfois il peut passer inaperçu:

Assert.assertTrue(Arrays.asList(spam).indexOf(4) == -1);

752
2018-04-09 12:20


origine


Réponses:


Dans votre exemple, c'est parce que vous ne pouvez pas avoir une liste d'un type primitif. En d'autres termes, List<int> n'est pas possible. Vous pouvez cependant avoir un List<Integer>.

Integer[] spam = new Integer[] { 1, 2, 3 };
Arrays.asList(spam);

Cela fonctionne comme prévu.


1100
2018-04-09 12:27



Le problème est que varargs a été introduit dans Java5 et malheureusement, Arrays.asList() a été surchargé avec une version vararg aussi. Alors Arrays.asList(spam) est compris par le compilateur Java5 comme un paramètre vararg de tableaux int.

Ce problème est expliqué plus en détail dans Effective Java 2nd Ed., Chapitre 7, Item 42.


111
2018-04-09 12:26



Parlant de la façon de conversion, cela dépend de pourquoi avez-vous besoin de votre List. Si vous en avez besoin juste pour lire des données. OK, vous allez:

Integer[] values = { 1, 3, 7 };
List<Integer> list = Arrays.asList(values);

Mais si vous faites quelque chose comme ça:

list.add(1);

vous obtenez java.lang.UnsupportedOperationException. Donc, dans certains cas, vous avez même besoin de ceci:

Integer[] values = { 1, 3, 7 };
List<Integer> list = new ArrayList<Integer>(Arrays.asList(values));

La première approche ne convertit pas le tableau mais le "représente" comme un List. Mais le tableau est sous le capot avec toutes ses propriétés comme nombre fixe d'éléments. S'il vous plaît noter que vous devez spécifier le type lors de la construction ArrayList.


105
2017-09-27 16:22



En Java 8, vous pouvez utiliser des flux:

int[] spam = new int[] { 1, 2, 3 };
Arrays.stream(spam)
      .boxed()
      .collect(Collectors.toList());

93
2018-05-16 23:49



Il semble peu tard, mais voici mes deux cents. Nous ne pouvons pas avoir List<int> comme int est un type primitif, donc nous ne pouvons 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 ci-dessous (tableau entier)

Integer[] integers = new Integer[] {1,2,3,4,5};
List<Integer> list21 =  Arrays.asList(integers); // Cannot modify returned list
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?

Au cas où nous voulons une implémentation spécifique de List par exemple. ArrayList alors nous pouvons utiliser toCollection comme:

ArrayList<Integer> list24 = Arrays.stream(integers)
                          .collect(Collectors.toCollection(ArrayList::new));

Pourquoi list21 ne peut pas être modifié structurellement?

Lorsque nous utilisons Arrays.asList la taille de la liste renvoyée est fixe car la liste renvoyée n'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 jeté. Nous devrions donc aller avec list22 quand on veut modifier la liste. Si nous avons Java8 alors nous pouvons aussi aller avec list23.

Pour être clair 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 ceci question.

Si nous voulons une liste immuable, nous pouvons l'envelopper comme suit:

List<Integer> list 22 = Collections.unmodifiableList(Arrays.asList(integers));

50
2017-12-23 05:07



J'ai récemment dû convertir un tableau en liste. Plus tard, le programme a filtré la liste en essayant de supprimer les données. Lorsque vous utilisez la fonction Arrays.asList (tableau), vous créez une collection de taille fixe: vous ne pouvez ni ajouter ni supprimer. Cette entrée explique mieux le problème que je peux: Pourquoi ai-je une exception UnsupportedOperationException lorsque j'essaie de supprimer un élément d'une liste?.

En fin de compte, j'ai dû faire une conversion "manuelle":

    List<ListItem> items = new ArrayList<ListItem>();
    for (ListItem item: itemsArray) {
        items.add(item);
    }

Je suppose que j'aurais pu ajouter la conversion d'un tableau à une liste en utilisant une opération List.addAll (items).


8
2017-08-31 17:26



Encore plus court:

List<Integer> list = Arrays.asList(1, 2, 3, 4);

6
2018-03-17 09:55



Utilisation de tableaux

C'est le moyen le plus simple de convertir un tableau en List. Cependant, si vous essayez d'ajouter un nouvel élément ou de supprimer un élément existant de la liste, un UnsupportedOperationException sera jeté.

Integer[] existingArray = {1, 2, 3};
List<Integer> list1 = Arrays.asList(existingArray);
List<Integer> list2 = Arrays.asList(1, 2, 3);

// WARNING:
list2.add(1);     // Unsupported operation!
list2.remove(1);  // Unsupported operation!

Utilisation de ArrayList ou d'autres implémentations de liste

Vous pouvez utiliser un for boucle pour ajouter tous les éléments du tableau dans un List la mise en œuvre, par ex. ArrayList:

List<Integer> list = new ArrayList<>();
for (int i : new int[]{1, 2, 3}) {
  list.add(i);
}

Utilisation de l'API Stream en Java 8

Vous pouvez transformer le tableau en un flux, puis collecter le flux à l'aide de différents collecteurs: Le collecteur par défaut dans Java 8 ArrayList derrière l'écran, mais vous pouvez également imposer votre implémentation préférée.

List<Integer> list1, list2, list3;
list1 = Stream.of(1, 2, 3).collect(Collectors.toList());
list2 = Stream.of(1, 2, 3).collect(Collectors.toCollection(ArrayList::new));
list3 = Stream.of(1, 2, 3).collect(Collectors.toCollection(LinkedList::new));

Voir également:


3
2018-03-04 22:12



Bon mot:

List<Integer> list = Arrays.asList(new Integer[] {1, 2, 3, 4});

2
2018-03-11 04:15



Dans Java 9, vous avez la solution encore plus élégante d'utiliser des listes immuables via la nouvelle méthode d'usine pratique List.of:

List<String> immutableList = List.of("one","two","three");

(copié sans vergogne ici )


2
2017-11-28 23:22