Conversion d'un tableau en liste en Java

Comment convertir un tableau en liste en Java?

J'ai utilisé le Arrays.asList()mais le comportement (et la signature) est en quelque sorte passé de Java SE 1.4.2 (les documents sont maintenant archivés) à 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 du tableau

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

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

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

Vous pouvez cependant avoir une List<Integer>utilisation de la Integerclasse qui encapsule la intprimitive. Convertissez votre tableau en un Listavec la Arrays.asListméthode utilitaire.

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

Découvrez ce code en direct sur IdeOne.com .

Dans Java 8, vous pouvez utiliser des flux:

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

En parlant de conversion, cela dépend de la raison pour laquelle vous en avez besoin List. Si vous en avez besoin juste pour lire les données. OK, c'est parti:

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 en avez même besoin:

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

La première approche ne convertit pas réellement le 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 ArrayList.

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

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

Il semble peu tard mais voici mes deux cents. Nous ne pouvons pas avoir List<int>comme intun 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, Listpar exemple, ArrayListnous pouvons utiliser toCollectioncomme:

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

Pourquoi list21ne peut - on pas être modifié structurellement?

Lorsque nous utilisons Arrays.asListla 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 UnsupportedOperationExceptionsera levé. Nous devons donc aller avec list22quand nous voulons modifier la liste. Si nous avons Java8, nous pouvons également y aller list23.

Pour être clair, cela list21peut ê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:

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

Consultez également ma réponse pour en savoir plus.

Encore plus court:

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

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 (array), vous créez une collection de taille fixe: vous ne pouvez ni ajouter ni supprimer. Cette entrée explique le problème mieux que moi: pourquoi est-ce que j'obtiens une exception UnsupportedOperationException lorsque j'essaie de supprimer un élément d'une liste?.

Au final, 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).

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 UnsupportedOperationExceptionsera 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 d'ArrayList ou d'autres implémentations de liste

Vous pouvez utiliser une forboucle pour ajouter tous les éléments du tableau dans une Listimplémentation, 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 flux, puis collecter le flux à l'aide de différents collecteurs: le collecteur par défaut dans Java 8 utilise ArrayListderriè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:

• Pourquoi utilisons-nous l'autoboxing et le déballage en Java?
• Quand utiliser LinkedList sur ArrayList?

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 se convertit int[]enInteger[]

vous devez lancer dans le tableau

Arrays.asList((Object[]) array)

Bon mot:

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

Dans Java 9, vous avez la solution encore plus élégante d'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 d' ici )

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 "Non-correspondance de type: impossible de convertir de List<Object>à List<Integer>".

1. Utilisation de la 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);

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

Étant donné le tableau:

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

Conversion d'un tableau d'entiers en liste d'entiers

One way: boxed () -> retourne l'IntStream

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

Deuxième façon: mappez chaque élément du flux en entier, puis collectez

REMARQUE: En utilisant mapToObj, vous pouvez convertir chaque élément int en flux de chaînes, flux de caractères, etc. en mettant i dans (char) i

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

Conversion d'un type de tableau en un autre type Exemple:

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

Cela dépend donc 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);

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/

Pouvez-vous améliorer cette réponse s'il vous plaît car c'est ce que j'utilise mais je ne suis pas clair à 100%. Cela fonctionne bien mais intelliJ a ajouté une nouvelle WeatherStation [0]. Pourquoi le 0?

    public WeatherStation[] removeElementAtIndex(WeatherStation[] array, int index)
    {
        List<WeatherStation> list = new ArrayList<WeatherStation>(Arrays.asList(array));
        list.remove(index);
        return list.toArray(new WeatherStation[0]);
    }

utilisez deux lignes de code pour convertir le tableau en liste si vous l'utilisez en valeur entière, vous devez utiliser le type de zone automatique pour le type de données primitif

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