Créer ArrayList à partir d'un tableau

3599

J'ai un tableau qui est initialisé comme:

Element[] array = {new Element(1), new Element(2), new Element(3)};

Je voudrais convertir ce tableau en un objet de la ArrayListclasse.

ArrayList<Element> arraylist = ???;
Ron Tuffin
la source
50
En Java9 -> List <String> list = List.of ("Bonjour", "Monde", "de", "Java");
MarekM
18
@MarekM Cette réponse est fausse, car cela ne renvoie pas de ArrayList. L'affiche a demandé spécifiquement cela.
Dorian Gray
4
Je pense qu'il n'a pas exploité l'interface List, car c'est la meilleure pratique. Mais si vous voulez, voici - new ArrayList <> (List.of ("Hello", "World", "from", "Java"));
MarekM
10
Il ne s'agit pas d'utiliser l'interface, le fait est que dans votre solution, la liste renvoyée n'est pas modifiable. Cela pourrait être plus un problème, et une raison pour laquelle il a demandé une liste de tableaux
Dorian Gray

Réponses:

4604
new ArrayList<>(Arrays.asList(array));
À M
la source
362
Oui. Et dans le cas (le plus courant) où vous voulez juste une liste, l' new ArrayListappel est également inutile.
Calum
143
@Luron - utilisez simplementList<ClassName> list = Arrays.asList(array)
Pool
249
@Calum et @Pool - comme indiqué ci-dessous dans la réponse d'Alex Miller, utiliser Arrays.asList(array)sans le passer dans un nouvel ArrayListobjet fixera la taille de la liste. L'une des raisons les plus courantes d'utiliser un ArrayListest de pouvoir modifier dynamiquement sa taille, et votre suggestion empêcherait cela.
Code Jockey
130
Arrays.asList () est une fonction horrible, et vous ne devez jamais simplement utiliser sa valeur de retour telle quelle. Il casse le modèle List, utilisez-le toujours sous la forme indiquée ici, même s'il semble redondant. Bonne réponse.
Adam
83
@Adam Veuillez étudier le javadoc pour java.util.List. Le contrat d'ajout leur permet de lever une exception UnsupportedOperationException. docs.oracle.com/javase/7/docs/api/java/util/… Certes, d'un point de vue orienté objet, il n'est pas très agréable que plusieurs fois vous ayez à connaître l'implémentation concrète pour utiliser une collection - ceci était un choix de conception pragmatique afin de garder le cadre simple.
lbalazscs
918

Donné:

Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) };

La réponse la plus simple est de faire:

List<Element> list = Arrays.asList(array);

Cela fonctionnera bien. Mais quelques mises en garde:

  1. La liste renvoyée par asList a une taille fixe . Donc, si vous voulez pouvoir ajouter ou supprimer des éléments de la liste retournée dans votre code, vous devrez l'encapsuler dans un nouveau ArrayList. Sinon, vous obtiendrez un UnsupportedOperationException.
  2. La liste renvoyée par asList()est sauvegardée par le tableau d'origine. Si vous modifiez le tableau d'origine, la liste sera également modifiée. Cela peut surprendre.
Alex Miller
la source
6
Quelle est la complexité temporelle des deux opérations? Je veux dire avec et sans utiliser une construction arrayliste explicite.
maudit
35
Arrays.asList () crée simplement une ArrayList en encapsulant le tableau existant pour qu'il soit O (1).
Alex Miller,
27
L'encapsulation dans une nouvelle ArrayList () entraînera l'itération de tous les éléments de la liste de taille fixe et leur ajout à la nouvelle ArrayList, tout comme O (n).
Alex Miller,
8
l'implémentation de List retournée par asList () n'implémente pas plusieurs des méthodes de List (comme add (), remove (), clear (), etc ...) ce qui explique l'exception UnsupportedOperationException. certainement une mise en garde ...
sethro
8
Lorsque la question demande "un objet de la classe ArrayList", je pense qu'il est raisonnable de supposer que la classe à laquelle il se réfère est java.util.ArrayList. Arrays.asList renvoie en fait un java.util.Arrays.ArrayListqui n'est pas un instanceofautre classe. Donc, une troisième mise en garde est que si vous essayez de l'utiliser dans un contexte nécessitant ce qui précède, cela ne fonctionnera pas.
Dave L.
352

(ancien fil, mais seulement 2 cents car aucun ne mentionne Guava ou d'autres bibliothèques et quelques autres détails)

Si vous le pouvez, utilisez la goyave

Il convient de souligner la manière Guava, qui simplifie considérablement ces manigances:

Usage

Pour une liste immuable

Utilisez la ImmutableListclasse et ses méthodes of()et copyOf()usine (les éléments ne peuvent pas être nuls) :

List<String> il = ImmutableList.of("string", "elements");  // from varargs
List<String> il = ImmutableList.copyOf(aStringArray);      // from array

Pour une liste Mutable

Utilisez la Listsclasse et ses newArrayList()méthodes d'usine:

List<String> l1 = Lists.newArrayList(anotherListOrCollection);    // from collection
List<String> l2 = Lists.newArrayList(aStringArray);               // from array
List<String> l3 = Lists.newArrayList("or", "string", "elements"); // from varargs

Veuillez également noter les méthodes similaires pour d'autres structures de données dans d'autres classes, par exemple dans Sets.

Pourquoi la goyave?

L'attraction principale pourrait être de réduire l'encombrement dû aux génériques pour la sécurité des types, car l'utilisation des méthodes de l'usine de goyave permet de déduire les types la plupart du temps. Cependant, cet argument détient moins d'eau depuis l'arrivée de Java 7 avec le nouvel opérateur diamantaire.

Mais ce n'est pas la seule raison (et Java 7 n'est pas encore partout): la syntaxe raccourcie est également très pratique, et les initialiseurs de méthodes, comme vu ci-dessus, permettent d'écrire du code plus expressif. Vous faites dans un appel Guava ce qui prend 2 avec les collections Java actuelles.


Si vous ne pouvez pas ...

Pour une liste immuable

Utilisez la Arraysclasse du JDK et sa asList()méthode d'usine, enveloppée par un Collections.unmodifiableList():

List<String> l1 = Collections.unmodifiableList(Arrays.asList(anArrayOfElements));
List<String> l2 = Collections.unmodifiableList(Arrays.asList("element1", "element2"));

Notez que le type retourné pour asList()est une Listutilisation d'une ArrayListimplémentation concrète , mais il ne l'est PAS java.util.ArrayList . C'est un type interne, qui émule un ArrayListmais fait en fait directement référence au tableau passé et le fait "écrire" (les modifications sont reflétées dans le tableau).

Il interdit les modifications à travers certaines des Listméthodes de l' API en étendant simplement un AbstractList(donc, l'ajout ou la suppression d'éléments n'est pas pris en charge), mais il permet aux appels set()de remplacer les éléments. Ainsi, cette liste n'est pas vraiment immuable et un appel à asList()devrait être terminé Collections.unmodifiableList().

Consultez l'étape suivante si vous avez besoin d'une liste modifiable.

Pour une liste Mutable

Comme ci-dessus, mais enveloppé d'un réel java.util.ArrayList:

List<String> l1  = new ArrayList<String>(Arrays.asList(array));    // Java 1.5 to 1.6
List<String> l1b = new ArrayList<>(Arrays.asList(array));          // Java 1.7+
List<String> l2  = new ArrayList<String>(Arrays.asList("a", "b")); // Java 1.5 to 1.6
List<String> l2b = new ArrayList<>(Arrays.asList("a", "b"));       // Java 1.7+

À des fins éducatives: Le bon vieux manuel

// for Java 1.5+
static <T> List<T> arrayToList(final T[] array) {
  final List<T> l = new ArrayList<T>(array.length);

  for (final T s : array) {
    l.add(s);
  }
  return (l);
}

// for Java < 1.5 (no generics, no compile-time type-safety, boo!)
static List arrayToList(final Object[] array) {
  final List l = new ArrayList(array.length);

  for (int i = 0; i < array.length; i++) {
    l.add(array[i]);
  }
  return (l);
}
haylem
la source
27
+1 Mais notez que le Listretourné par Arrays.asListest modifiable en ce que vous pouvez toujours des setéléments - il n'est tout simplement pas redimensionnable. Pour les listes immuables sans goyave, vous pourriez mentionner Collections.unmodifiableList.
Paul Bellora
1
@haylem Dans votre section à des fins éducatives: The Good ol 'Manual Way , your arrayToListfor Java 1.5+ is incorrect. Vous instanciation listes de String, et d' essayer de récupérer des chaînes du tableau donné, au lieu d'utiliser le type de paramètre générique T. En dehors de cela, bonne réponse et +1 pour être le seul à inclure la méthode manuelle.
afsantos
Je renommerais votre section "Si vous ne pouvez pas ... / Pour une liste immuable" en "Pour une liste non modifiable" car elle peut être modifiée par des modifications ultérieures du tableau encapsulé. C'est toujours O(1), mais pour l'immuabilité, vous devez faire une copie, par exemple, par Collections.unmodifiableList(new ArrayList<>(Arrays.asList(array))).
maaartinus
232

Comme cette question est assez ancienne, cela m'étonne que personne n'ait encore suggéré la forme la plus simple:

List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));

Depuis Java 5, Arrays.asList()prend un paramètre varargs et vous n'avez pas à construire le tableau explicitement.

Tim Büthe
la source
7
En particulier,List<String> a = Arrays.asList("first","second","third")
18446744073709551615
209
new ArrayList<T>(Arrays.asList(myArray));

Assurez-vous qu'il myArrays'agit du même type que T. Vous obtiendrez une erreur de compilation si vous essayez de créer un à List<Integer>partir d'un tableau de int, par exemple.

Bill le lézard
la source
103

Une autre façon (bien qu'elle soit essentiellement équivalente à la new ArrayList(Arrays.asList(array))solution en termes de performances:

Collections.addAll(arraylist, array);
Peter Tseng
la source
97

Java 9

Dans Java 9 , vous pouvez utiliser List.ofla méthode d'usine statique pour créer un Listlittéral. Quelque chose comme ceci:

List<Element> elements = List.of(new Element(1), new Element(2), new Element(3));

Cela retournerait une liste immuable contenant trois éléments. Si vous voulez une liste mutable , passez cette liste au ArrayListconstructeur:

new ArrayList<>(List.of(// elements vararg))

JEP 269: Méthodes de commodité pour les collections

JEP 269 fournit des méthodes d'usine pratiques pour l' API Java Collections . Ces méthodes d'usine statiques immuables sont intégrés dans les List, Setet les Mapinterfaces en Java 9 et versions ultérieures.

Ali Dehghani
la source
List.of () ne renverra pas une instance de java.util.ArrayList, comme demandé dans la question d'origine. Par conséquent, seule la deuxième option est une réponse valide.
tquadrat
84

Vous avez probablement juste besoin d'une liste, pas d'une liste de tableaux. Dans ce cas, vous pouvez simplement faire:

List<Element> arraylist = Arrays.asList(array);
Kip
la source
8
Cela sera soutenu par le tableau d'entrée d'origine, c'est pourquoi vous voulez (probablement) l'envelopper dans une nouvelle ArrayList.
Bill the Lizard
16
Soyez prudent avec cette solution. Si vous regardez, les tableaux ne retournent pas un vrai java.util.ArrayList. Il renvoie une classe interne qui implémente les méthodes requises, mais vous ne pouvez pas modifier les membres de la liste. C'est simplement un wrapper autour d'un tableau.
Mikezx6r
1
Vous pouvez lancer l'élément List <Element> dans un ArrayList <Element>
monksy
12
@ Mikezx6r: petite correction : c'est une liste de taille fixe. Vous pouvez changer les éléments de la liste ( setméthode), vous ne pouvez pas changer la taille de la liste (pas addou removeéléments)!
user85421
1
Oui, avec la mise en garde que cela dépend de ce que vous voulez faire avec la liste. Il convient de noter que si l'OP souhaite simplement parcourir les éléments, le tableau n'a pas du tout besoin d'être converti.
PaulMurrayCbr
69

Une autre mise à jour, se terminant presque l'année 2014, vous pouvez aussi le faire avec Java 8:

ArrayList<Element> arrayList = Stream.of(myArray).collect(Collectors.toCollection(ArrayList::new));

Quelques caractères seraient enregistrés, si cela pouvait être juste un List

List<Element> list = Stream.of(myArray).collect(Collectors.toList());
pourquoi
la source
8
Il est probablement préférable de ne pas dépendre de l'implémentation, mais Collectors.toList()renvoie en fait un ArrayList.
bcsb1001
utilisation incorrecte de Stream.of (...); qui créera un flux à un élément. Utilisez plutôt Arrays.stream
Patrick Parker
Je ne pense pas, les 2 options sont valides mais le Arrays.stream est légèrement «meilleur» puisque vous pouvez le créer avec une taille fixe, en utilisant la méthode de surcharge avec les arguments «start», «end». Voir aussi: stackoverflow.com/a/27888447/2619091
whyem
41

Si tu utilises :

new ArrayList<T>(Arrays.asList(myArray));

vous pouvez créer et remplir deux listes! Remplir deux fois une grande liste est exactement ce que vous ne voulez pas faire car cela créera une autre Object[]baie à chaque fois que la capacité doit être étendue.

Heureusement, l'implémentation JDK est rapide et Arrays.asList(a[])très bien réalisée. Il crée une sorte d'ArrayList nommée Arrays.ArrayList où les données Object [] pointent directement vers le tableau.

// in Arrays
@SafeVarargs
public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}
//still in Arrays, creating a private unseen class
private static class ArrayList<E>

    private final E[] a;    
    ArrayList(E[] array) {
        a = array; // you point to the previous array
    }
    ....
}

Le côté dangereux est que si vous changez le tableau initial, vous changez la liste! Êtes-vous sûr de vouloir cela? Peut-être que oui peut-être que non.

Sinon, la façon la plus compréhensible est de le faire:

ArrayList<Element> list = new ArrayList<Element>(myArray.length); // you know the initial capacity
for (Element element : myArray) {
    list.add(element);
}

Ou comme l'a dit @glglgl, vous pouvez créer un autre ArrayList indépendant avec:

new ArrayList<T>(Arrays.asList(myArray));

J'aime utiliser Collections, Arraysou goyave. Mais si cela ne correspond pas, ou si vous ne le sentez pas, écrivez simplement une autre ligne inélégante à la place.

Nicolas Zozol
la source
1
Je ne vois pas la différence fondamentale entre votre boucle à la fin de la réponse et la new ArrayList<T>(Arrays.asList(myArray));partie que vous découragez d'utiliser. Les deux font tout à fait la même chose et ont la même complexité.
glglgl
Les Collections créent un pointeur au début du tableau. Ma boucle crée de nombreux pointeurs: un pour chaque membre du tableau. Donc, si le tableau d'origine change, mes pointeurs sont toujours dirigés vers les anciennes valeurs.
Nicolas Zozol
1
new ArrayList<T>(Arrays.asList(myArray));fait de même, il copie le asListdans un ArrayList...
glglgl
37

Dans Java 9vous pouvez utiliser:

List<String> list = List.of("Hello", "World", "from", "Java");
List<Integer> list = List.of(1, 2, 3, 4, 5);
MarekM
la source
Notez qu'il ne s'agit pas d'une ArrayList, comme cela a été explicitement demandé.
Dorian Gray
33

Selon la question, la réponse à l'aide de Java 1.7 est:

ArrayList<Element> arraylist = new ArrayList<Element>(Arrays.<Element>asList(array));

Cependant, il vaut mieux toujours utiliser l'interface:

List<Element> arraylist = Arrays.<Element>asList(array);
nekperu15739
la source
30
// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray); 
Bohdan
la source
21

comme tous l'ont dit, cela

 new ArrayList<>(Arrays.asList("1","2","3","4"));

et la plus récente façon courante de créer un tableau est observableArrays

ObservableList: une liste qui permet aux auditeurs de suivre les changements lorsqu'ils se produisent.

pour Java SE, vous pouvez essayer

FXCollections.observableArrayList(new Element(1), new Element(2), new Element(3));

c'est selon Oracle Docs

observableArrayList () Crée une nouvelle liste observable vide qui est sauvegardée par un arraylist. observableArrayList (E ... items) Crée une nouvelle liste de tableaux observables avec des éléments ajoutés.

Mettre à jour Java 9

aussi en Java 9 c'est un peu facile:

List<String> list = List.of("element 1", "element 2", "element 3");
Abojemyeg
la source
20

Depuis Java 8, il existe un moyen plus simple de transformer:

public static <T> List<T> fromArray(T[] array) {
    return Arrays.stream(array).collect(toList());
}
Andrii Abramov
la source
18

Vous pouvez également le faire avec stream dans Java 8.

 List<Element> elements = Arrays.stream(array).collect(Collectors.toList()); 
Vaseph
la source
3
Au java 8 , Collectors.toList()renverra un ArrayList. Cependant, cela peut différer dans les versions futures sur java.Si vous voulez un type spécifique de collection, utilisez Collectors.toCollection()plutôt où vous pouvez spécifier le type exact de collection que vous souhaitez créer.
Raja Anbazhagan
14
  1. Si nous voyons la définition de la Arrays.asList()méthode, vous obtiendrez quelque chose comme ceci:

     public static <T> List<T> asList(T... a) //varargs are of T type. 

    Donc, vous pouvez initialiser arraylistcomme ceci:

     List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));

    Remarque : chacun new Element(int args)sera traité comme un objet individuel et peut être transmis comme un var-args.

  2. Il pourrait également y avoir une autre réponse à cette question.
    Si vous voyez une déclaration de java.util.Collections.addAll()méthode, vous obtiendrez quelque chose comme ceci:

    public static <T> boolean addAll(Collection<? super T> c, T... a);

    Donc, ce code est également utile pour ce faire

    Collections.addAll(arraylist, array);
Vikrant Kashyap
la source
10

Un autre moyen simple consiste à ajouter tous les éléments du tableau à une nouvelle liste de tableaux à l'aide d'une boucle for-each.

ArrayList<Element> list = new ArrayList<>();

for(Element e : array)
    list.add(e);
spencer.sm
la source
10

Si le tableau est de type primitif, les réponses données ne fonctionneront pas. Mais depuis Java 8, vous pouvez utiliser:

int[] array = new int[5];
Arrays.stream(array).boxed().collect(Collectors.toList());
A1m
la source
cette solution ne semble pas non plus fonctionner avec le chartableau.
PixelMaster
8

Vous pouvez le faire en java 8 comme suit

ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());
Adit A. Pillai
la source
1
Voté parce que cette distribution semble très dangereuse. rien ne spécifie que le type de liste renvoyé est en fait une ArrayList, comme l'indique javadoc: "Il n'y a aucune garantie sur le type, la mutabilité, la sérialisation ou la sécurité des threads de la liste renvoyée"
Dorian Gray
1
Si vous souhaitez créer explicitement une liste de tableaux, essayez ceci:ArrayList<String> list = Arrays.stream(array).collect(Collectors.toCollection(ArrayList::new));
Dorian Gray
8

Nous pouvons facilement convertir un tableau en ArrayList. Nous utilisons la addAll()méthode de l' interface Collection dans le but de copier du contenu d'une liste à une autre.

 Arraylist arr = new Arraylist();
 arr.addAll(Arrays.asList(asset));
rashedcs
la source
C'est moins efficace que la réponse acceptée de 9 ans.
AjahnCharles
2
L'un des ArrayListconstructeurs s accepte un ? extends Collection<T>argument, ce qui rend l'appel addAllredondant.
Tamoghna Chowdhury
7

Même s'il existe de nombreuses réponses parfaitement écrites à cette question, je vais ajouter mes entrées.

Dis que tu as Element[] array = { new Element(1), new Element(2), new Element(3) };

La nouvelle liste de tableaux peut être créée des manières suivantes

ArrayList<Element> arraylist_1 = new ArrayList<>(Arrays.asList(array));
ArrayList<Element> arraylist_2 = new ArrayList<>(
    Arrays.asList(new Element[] { new Element(1), new Element(2), new Element(3) }));

// Add through a collection
ArrayList<Element> arraylist_3 = new ArrayList<>();
Collections.addAll(arraylist_3, array);

Et ils supportent très bien toutes les opérations d'ArrayList

arraylist_1.add(new Element(4)); // or remove(): Success
arraylist_2.add(new Element(4)); // or remove(): Success
arraylist_3.add(new Element(4)); // or remove(): Success

Mais les opérations suivantes ne renvoient qu'une vue List d'un ArrayList et non un ArrayList réel.

// Returns a List view of array and not actual ArrayList
List<Element> listView_1 = (List<Element>) Arrays.asList(array);
List<Element> listView_2 = Arrays.asList(array);
List<Element> listView_3 = Arrays.asList(new Element(1), new Element(2), new Element(3));

Par conséquent, ils donneront une erreur lors de la tentative de certaines opérations ArrayList

listView_1.add(new Element(4)); // Error
listView_2.add(new Element(4)); // Error
listView_3.add(new Element(4)); // Error

Plus d'informations sur la représentation de liste du lien de tableau .

Devendra Lattu
la source
7

Le moyen le plus simple de le faire consiste à ajouter le code suivant. Essayé et testé.

String[] Array1={"one","two","three"};
ArrayList<String> s1= new ArrayList<String>(Arrays.asList(Array1));
Hemin
la source
7

Une autre solution Java8 (j'ai peut-être manqué la réponse parmi le grand ensemble. Si oui, mes excuses). Cela crée une ArrayList (par opposition à une liste) c'est-à-dire que l'on peut supprimer des éléments

package package org.something.util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Junk {

    static <T> ArrayList<T>  arrToArrayList(T[] arr){
        return Arrays.asList(arr)
            .stream()
            .collect(Collectors.toCollection(ArrayList::new));
    }

    public static void main(String[] args) {
        String[] sArr = new String[]{"Hello", "cruel", "world"};
        List<String> ret = arrToArrayList(sArr);
        // Verify one can remove an item and print list to verify so
        ret.remove(1);
        ret.stream()
            .forEach(System.out::println);
    }
}

La sortie est ...
Bonjour tout le
monde

Voyant édenté
la source
7

Utilisez le code suivant pour convertir un tableau d'éléments en ArrayList.

Element[] array = {new Element(1), new Element(2), new Element(3)};

ArrayList<Element>elementArray=new ArrayList();
for(int i=0;i<array.length;i++) {
    elementArray.add(array[i]);
}
Kavinda Pushpitha
la source
5

Tout le monde a déjà fourni suffisamment de bonnes réponses à votre problème. Maintenant, à partir de toutes les suggestions, vous devez décider qui correspondra à vos besoins. Il existe deux types de collection que vous devez connaître. L'une est une collection non modifiée et une autre collection qui vous permettra de modifier l'objet plus tard.

Donc, ici, je vais donner un court exemple pour deux cas d'utilisation.

  • Création de collection immuable :: Lorsque vous ne souhaitez pas modifier l'objet de collection après la création

    List<Element> elementList = Arrays.asList(array)

  • Création de collection Mutable :: Quand vous voudrez peut-être modifier l'objet de collection créé après la création.

    List<Element> elementList = new ArrayList<Element>(Arrays.asList(array));

Sumit Das
la source
List <Element> elementList = Arrays.asList (array) crée un wrapper sur le tableau d'origine qui rend le tableau d'origine disponible en tant que List. Par conséquent, un objet wrapper est créé, rien n'est copié à partir du tableau d'origine. Par conséquent, les opérations telles que l'ajout ou la suppression d'éléments ne sont pas autorisées.
Priyanka
3
Notez que votre "collection immuable" n'est pas vraiment immuable - le Listretourné par Arrays.asListn'est qu'un wrapper sur le tableau d'origine, et permet d'accéder et de modifier des éléments individuels via getet set. Vous devriez probablement préciser que vous voulez dire "ne pas ajouter ou supprimer d'éléments" au lieu de "immuable", ce qui signifie ne pas changer du tout.
Tamoghna Chowdhury
5

Tableau d'objets donné:

Element[] array = {new Element(1), new Element(2), new Element(3) , new Element(2)};

Convertir un tableau en liste:

    List<Element> list = Arrays.stream(array).collect(Collectors.toList());

Convertir un tableau en liste de tableaux

    ArrayList<Element> arrayList = Arrays.stream(array)
                                       .collect(Collectors.toCollection(ArrayList::new));

Convertir un tableau en LinkedList

    LinkedList<Element> linkedList = Arrays.stream(array)
                     .collect(Collectors.toCollection(LinkedList::new));

Imprimer la liste:

    list.forEach(element -> {
        System.out.println(element.i);
    });

PRODUCTION

1

2

3

Arpan Saini
la source
4

La classe Arrays de Java 8 fournit une méthode stream () qui a des versions surchargées acceptant à la fois les tableaux primitifs et les tableaux d'objets.

/**** Converting a Primitive 'int' Array to List ****/

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

List<Integer> integerList1 = Arrays.stream(intArray).boxed().collect(Collectors.toList());

/**** 'IntStream.of' or 'Arrays.stream' Gives The Same Output ****/

List<Integer> integerList2 = IntStream.of(intArray).boxed().collect(Collectors.toList());

/**** Converting an 'Integer' Array to List ****/

Integer integerArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

List<Integer> integerList3 = Arrays.stream(integerArray).collect(Collectors.toList());
Himanshu Dave
la source
3

Le code ci-dessous semble une bonne façon de le faire.

new ArrayList<T>(Arrays.asList(myArray));
Singh123
la source