web-dev-qa-db-fra.com

Conversion du tableau en liste dans Java

Comment convertir un tableau en liste en Java?

J'ai utilisé le Arrays.asList() mais le comportement (et la signature) a changé d'une manière ou d'une autre de Java SE 1.4.2 (docs maintenant dans l'archive) à 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)
  • on 1.4.2 renvoie une liste contenant les éléments 1, 2, 3
  • sur 1.5.0+ renvoie une liste contenant le spam de la matrice

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

Assert.assertTrue(Arrays.asList(spam).indexOf(4) == -1);
javaarrayslistcontainersdata-conversion
913
Alexandru

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>_ en utilisant la classe Integer qui encapsule la primitive int. Convertissez votre tableau en un List avec l'utilitaire Arrays.asList méthode.

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

Voir ce code exécuté en direct sur IdeOne.com .

1316
Joe Daley

Dans Java 8, vous pouvez utiliser des flux:

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

En parlant de conversion, cela dépend pourquoi vous avez besoin de votre List. Si vous en avez besoin, lisez simplement les données. OK, c'est parti:

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

Mais alors 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 réellement un tableau, mais le représente comme un List. Mais le tableau est sous le capot avec toutes ses propriétés, comme un nombre fixe d’éléments. Veuillez noter que vous devez spécifier le type lors de la construction de ArrayList.

127
Roman Nikitchenko

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

Ce problème est expliqué de manière plus détaillée dans Effective Java 2nd Ed., Chapitre 7, élément 42.

118
Péter Török

Cela semble un peu tard, mais voici mes deux cents. Nous ne pouvons pas avoir List<int>, car int est un type primitif, nous ne pouvons donc avoir que 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 inférieur (tableau Integer)

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 de ArrayList et non List?

Si nous voulons une implémentation spécifique de List par ex. ArrayList alors nous pouvons utiliser toCollection comme:

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

Pourquoi list21 ne peut-il pas être modifié structurellement?

Lorsque nous utilisons Arrays.asList, la taille de la liste renvoyée est fixée car la liste renvoyée n'est pas Java.util.ArrayList, mais une classe statique privée définie dans Java.util.Arrays. Donc, si nous ajoutons ou supprimons des éléments de la liste renvoyée, une UnsupportedOperationException sera levée. Donc, nous devrions utiliser list22 lorsque nous voulons modifier la liste. Si nous avons Java8, alors nous pouvons aussi aller avec list23.

Pour être clair, list21 peut être modifié dans le sens où nous pouvons appeler list21.set(index,element), mais cette liste ne peut pas être modifiée structurellement, c’est-à-dire 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));

Un autre point à noter est que la méthode Collections.unmodifiableList renvoie une vue non modifiable de la liste spécifiée. Une collection de vues non modifiable est une collection qui est non modifiable et constitue également une vue sur une collection de supports. Notez que les modifications apportées à la collection de sauvegarde peuvent encore être possibles et, si elles se produisent, elles sont visibles via la vue non modifiable.

Nous pouvons avoir une liste vraiment immuable dans Java 10.

Java 10 (liste vraiment immuable) de deux manières:

  1. List.copyOf(Arrays.asList(integers))
  2. Arrays.stream(integers).collect(Collectors.toUnmodifiableList());

Vérifiez aussi ceci réponse à moi pour plus.

87
i_am_zero

J'ai récemment eu à 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 le problème mieux que je ne le peux: Pourquoi ai-je une exception UnsupportedOperationException lorsque je tente de supprimer un élément d'une liste? .

Finalement, j'ai dû faire une conversion "manuelle":

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

J'imagine que j'aurais pu ajouter la conversion d'un tableau à une liste à l'aide d'une opération List.addAll (items).

8
Steve Gelman

Encore plus court:

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

Utiliser des 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 levé.

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 une boucle for pour ajouter tous les éléments du tableau dans une implémentation List, par exemple. ArrayList:

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

Utilisation de l'API Stream dans 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 de Java 8 utilise 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:

5
Mincong Huang

Dans Java 9, vous disposez de la solution encore plus élégante consistant à utiliser des listes immuables via la nouvelle méthode de fabrique de commodité List.of :

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

(copié sans vergogne de ici )

3
Pierluigi Vernetto

Si vous ciblez Java 8 (ou version ultérieure), vous pouvez essayer ceci:

int[] numbers = new int[] {1, 2, 3, 4};
List<Integer> integers = Arrays.stream(numbers)
                        .boxed().collect(Collectors.<Integer>toList());

REMARQUE:

Faites attention à la Collectors.<Integer>toList(), cette méthode générique vous aide à éviter l'erreur "Type incompatible: impossible de convertir de List<Object> à List<Integer>".

3
nybon

Une autre solution de contournement si vous utilisez Apache commons-lang:

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

Où ArrayUtils.toObject convertit int[] en Integer[]

3
alaster

  1. Utilisation de goyave:

    Integer[] array = { 1, 2, 3};
List<Integer> list = Lists.newArrayList(sourceArray);

  2. Utilisation des collections Apache Commons:

    Integer[] array = { 1, 2, 3};
List<Integer> list = new ArrayList<>(6);
CollectionUtils.addAll(list, array);
2
Danail Tsvetanov

Bon mot:

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

vous devez participer au tableau

Arrays.asList((Object[]) array)
2
Giancarlo Frison

Si cela aide: J'ai le même problème et simplement écrit une fonction générique qui prend un tableau et renvoie un ArrayList du même type avec le même contenu:

public static <T> ArrayList<T> ArrayToArrayList(T[] array) {
    ArrayList<T> list = new ArrayList<T>();
    for(T elmt : array) list.add(elmt);
    return list;
}
0
kleines filmröllchen

Donc, cela dépend de la version de Java que vous essayez -

Java 7

 Arrays.asList(1, 2, 3);

OR

       final String arr[] = new String[] { "G", "E", "E", "K" };
       final List<String> initialList = new ArrayList<String>() {{
           add("C");
           add("O");
           add("D");
           add("I");
           add("N");
       }};

       // Elements of the array are appended at the end
       Collections.addAll(initialList, arr);

OR

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

Dans Java 8

int[] num = new int[] {1, 2, 3};
List<Integer> list = Arrays.stream(num)
                        .boxed().collect(Collectors.<Integer>toList())

Référence - http://www.codingeek.com/Java/how-to-convert-array-to-list-in- Java /

0
Hitesh Garg