Conversion de tableau à la liste en Java

Question

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

J'ai utilisé le Arrays.asList() mais le comportement (et signature) en quelque sorte changé de Java SE 1.4.2 (docs maintenant dans l'archive) 8 et la plupart des extraits que j'ai trouvé 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 retourne une liste contenant les éléments 1, 2, 3
• sur 1.5.0+ retourne une liste contenant le spam tableau

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

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

Answer 1

Dans votre exemple, il est parce que vous ne pouvez pas avoir une liste d'un type primitif. En d'autres termes, List<int> est impossible.

Vous pouvez toutefois, un List<Integer> en utilisant Integer classe qui enveloppe le int primitive. Convertissez votre tableau à une List avec la méthode de l'utilitaire de Arrays.asList.

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

Voir cette .

Answer 2

En Java 8, vous pouvez utiliser les flux:

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

Answer 3

En parlant de façon de conversion, cela dépend de la raison pour laquelle avez-vous besoin de votre List. Si vous avez besoin juste de lire les données. OK, ici vous allez:

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

Mais si vous faites quelque chose comme ceci:

list.add(1);

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

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

Première approche ne convertit pas un tableau, mais « représente » comme un List. Mais 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.

Answer 4

Le problème est que varargs se sont introduits dans Java5 et malheureusement, Arrays.asList() se sont surchargées avec une version vararg aussi. Alors Arrays.asList(spam) est entendu par le compilateur Java5 comme paramètre vararg de tableaux int.

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

Answer 5

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); // 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 ArrayList et pas la liste?

Dans le cas où nous voulons une mise en œuvre spécifique de List par exemple ArrayList nous pouvons ensuite 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 fixée parce que 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 l'on ajoute ou supprimer des éléments de la liste renvoyée, un UnsupportedOperationException sera jeté. Nous devons 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 l'on peut appeler list21.set(index,element) mais cette liste ne peut pas être modifiée dans sa structure ne peut pas dire ajouter ou supprimer des éléments de la liste. Vous pouvez également consulter cette question .

---

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

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 vue non modifiable est une collection qui est non modifiable et est également une vue sur un ensemble de support. Notez que les modifications à la collection de soutien pourrait encore être possible, et si elles se produisent, ils sont visibles dans la vue non modifiable.

Nous pouvons avoir une liste vraiment immuable en Java 10.

Java 10 (vraiment liste Immuable) de deux façons:

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

Consultez également cette répondre de mes plus.

Answer 6

J'ai récemment convertir un tableau à une liste. Par la suite le programme filtré la liste tenter de supprimer les données. Lorsque vous utilisez la fonction Arrays.asList (tableau), vous créez une collection de taille fixe: vous pouvez ajouter ni supprimer ni. Cette entrée explique le problème mieux que moi: Pourquoi est-ce que je reçois un UnsupportedOperationException en essayant de supprimer un élément d'une liste .

En fin de compte, je devais faire une conversion "manuel":

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

Je suppose que je aurais pu ajouter la conversion d'un tableau à une liste à l'aide d'une opération List.addAll (articles).

Answer 7

Même plus courte:

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

Answer 8

Utilisation des tableaux

Ceci est la façon la plus simple de convertir un tableau en List. Toutefois, si vous essayez d'ajouter un nouvel élément ou supprimer un élément existant de la liste, une UnsupportedOperationException sera levée.

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 ArrayList ou une autre liste Implémentations

Vous pouvez utiliser une boucle de for pour ajouter tous les éléments du tableau dans une mise en œuvre de List, par exemple ArrayList:

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

Utilisation de l'API Java flux en 8

Vous pouvez tourner le tableau dans un cours d'eau, puis recueillir le flux en utilisant différents capteurs. Le collecteur par défaut en Java 8 utilisation ArrayList derrière l'écran, mais vous pouvez également imposer votre mise en oeuvre 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 aussi:

• Pourquoi utiliser autoboxing et unboxing en Java?
• Quand utiliser LinkedList sur ArrayList?

Answer 9

Une autre solution si vous utilisez commons-lang apache:

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

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

Answer 10

En Java 9 vous avez la solution encore plus élégante d'utiliser des listes immuables par la nouvelle méthode d'usine de commodité List.of :

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

(sans vergogne copié de ici )

Answer 11

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());

NOTE:

Faites attention à la Collectors.<Integer>toList(), cette méthode générique vous aide à éviter l'erreur « Incompatibilité de type: ne peut pas convertir List<Object> à List<Integer> ».

Answer 12

vous devez jeter dans la série

Arrays.asList((Object[]) array)

Answer 13

One-liner:

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

Answer 14

1. Utilisation Goyave:

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

2. En utilisant Apache Commons Collections:

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

Answer 15

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

Java 7

 Arrays.asList(1, 2, 3);

ou

       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);

ou

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

En 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/

Answer 16

Si cela aide: j'ai eu le même problème et simplement écrit une fonction générique qui prend un tableau et renvoie une liste de tableaux 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;
}

Answer 17

Compte tenu de tableau:

    int[] givenArray = {2,2,3,3,4,5};

Conversion de tableau d'entiers à la liste Entier

Une façon: boxed () -> retourne la IntStream

    List<Integer> givenIntArray1 = Arrays.stream(givenArray)
                                  .boxed()
                                  .collect(Collectors.toList());

Second Way: carte chaque élément du flux à entier et collecter

Remarque: Utilisation de mapToObj on peut convertir chaque élément d'int dans le courant de chaîne, courant charbon etc enveloppe par i à (char) i

    List<Integer> givenIntArray2 = Arrays.stream(givenArray)
                                         .mapToObj(i->i)
                                         .collect(Collectors.toList());

la conversion d'un type de tableau à un autre exemple de type:

List<Character> givenIntArray2 = Arrays.stream(givenArray)
                                             .mapToObj(i->(char)i)
                                             .collect(Collectors.toList());

Answer 18

utiliser deux lignes de code pour convertir tableau à la liste si vous l'utilisez en valeur entière vous devez utiliser le type de autoboxing pour le type de données primitive

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