Conversion d’un tableau en liste en Java

Comment convertir un tableau en liste dans Java?

J’ai utilisé le Arrays.asList() mais le comportement (et la signature) d’une manière ou d’une autre de Java SE 1.4.2 (docs maintenant en archive) à 8 et la plupart des snippets 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); 

Dans votre exemple, c’est parce que vous ne pouvez pas avoir une liste de type primitif. En d’autres termes, List n’est pas possible. Vous pouvez cependant avoir une List .

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

Cela fonctionne comme prévu.

Le problème est que varargs a été introduit dans Java5 et malheureusement, Arrays.asList() été surchargé avec une version de vararg. Ainsi, le compilateur Java5 comprend Arrays.asList(spam) en tant que paramètre vararg des tableaux int.

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

En ce qui concerne la conversion, cela dépend des raisons pour lesquelles vous avez besoin de votre List . Si vous en avez besoin juste pour lire des données. OK, c’est parti:

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

La première approche ne convertit pas réellement le tableau mais «le représente» comme une 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 .

Dans Java 8, vous pouvez utiliser des stream:

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

Il semble peu tard mais voici mes deux cents. On ne peut pas avoir List car int est un type primitif donc on ne peut avoir que List .

Java 8 (tableau int)

 int[] ints = new int[] {1,2,3,4,5}; List list11 =Arrays.stream(ints).boxed().collect(Collectors.toList()); 

Java 8 et inférieur (tableau entier)

 Integer[] integers = new Integer[] {1,2,3,4,5}; List list21 = Arrays.asList(integers); // Cannot modify returned list List list22 = new ArrayList<>(Arrays.asList(integers)); // good List list23 = Arrays.stream(integers).collect(Collectors.toList()); //Java 8 only 

Besoin ArrayList et non List?

toCollection nous voulons une implémentation spécifique de List par exemple ArrayList nous pouvons utiliser toCollection comme:

 ArrayList 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 fixe 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 lancée. On devrait donc aller avec list22 quand on veut modifier la liste. Si nous avons Java8, 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 append ou supprimer des éléments de la liste. Vous pouvez également vérifier cette question .

Si nous voulons une liste immuable, nous pouvons l’emballer comme suit:

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

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 append ni supprimer. Cette entrée explique le problème mieux que moi: pourquoi est-ce que je reçois une exception UnsupportedOperationException lorsque je tente de supprimer un élément d’une liste? .

Au final, j’ai dû faire une conversion “manuelle”:

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

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

Encore plus court:

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

Utiliser des tableaux

C’est le moyen le plus simple de convertir un tableau en List . Toutefois, si vous essayez d’append un nouvel élément ou de supprimer un élément existant de la liste, une UnsupportedOperationException sera lancée.

 Integer[] existingArray = {1, 2, 3}; List list1 = Arrays.asList(existingArray); List 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 listes

Vous pouvez utiliser une boucle for pour append tous les éléments du tableau dans une implémentation List , par exemple ArrayList :

 List 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 stream, puis collecter le stream à 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 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 la recherche automatique et la désencapsulation en Java?
  • Quand utiliser LinkedList sur ArrayList?

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

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

REMARQUE:

Faites attention aux Collectors.toList() , cette méthode générique vous aide à éviter l’erreur “Incompatibilité de type: impossible de convertir de List en List “.

Bon mot:

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

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

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

(copié sans vergogne d’ ici )

  1. Utilisation de goyave:

     Integer[] array = { 1, 2, 3}; List list = Lists.newArrayList(sourceArray); 
  2. Utilisation des collections Apache Commons:

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

vous devez jeter dans le tableau

 Arrays.asList((Object[]) array) 

Une autre solution 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[]

Voici plusieurs façons de convertir un tableau en liste en Java:

1- Arrays.asList

 public static List convertArrayToListAsList(Ssortingng[] names) { List namesLst = Arrays.asList(names); return namesLst; } 

La limitation de l’utilisation de cette méthode est qu’elle renvoie une liste de taille fixe. Vous pouvez simplement lire et remplacer ses éléments, mais si vous essayez d’append / de supprimer des éléments de la liste renvoyée, vous obtenez une exception UnsupportedOperationException .

Pour générer une liste modifiable en utilisant Arrays.aslist () , faites comme ceci:

 List namesLst = new ArrayList(Arrays.asList(names)); 

2- Java 8

Dans Java 8, vous pouvez utiliser les méthodes d’utilitaires Arrays.stream () et Collectors.toList () .

 public static List convertArrayToListJava8(Ssortingng[] names) { List namesLst = Arrays.stream(names).collect(Collectors.toList()); return namesLst; } 

3- façon traditionnelle

Vous pouvez également effectuer la conversion manuellement en parcourant les éléments du tableau et en remplissant une liste de tableaux .

 private static List convertArrayToListManually(Ssortingng[] names) { List namesLst = new ArrayList(); for(Ssortingng name : names) { namesLst.add(name); } return namesLst; } 

Référence: Java – Convertir un tableau en liste

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

Java 7

  Arrays.asList(1, 2, 3); 

OU

  final Ssortingng arr[] = new Ssortingng[] { "G", "E", "E", "K" }; final List initialList = new ArrayList() {{ 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 list = Arrays.stream(num) .boxed().collect(Collectors.toList()) 

Référencehttp://www.codingeek.com/java/how-to-convert-array-to-list-in-java/

Si cela vous aide: j’ai eu le même problème et 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  ArrayList ArrayToArrayList(T[] array) { ArrayList list = new ArrayList(); for(T elmt : array) list.add(elmt); return list; } 

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

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