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 = ???;

new ArrayList<>(Arrays.asList(array));

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.

^{(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);
}

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.

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.

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

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.

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

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

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.

Dans Java 9vous pouvez utiliser:

List<String> list = List.of("Hello", "World", "from", "Java");
List<Integer> list = List.of(1, 2, 3, 4, 5);

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

// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray); 

Vous pouvez convertir en utilisant différentes méthodes

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

2. List<Element> list = new ArrayList();
Collections.addAll(list, array);

3. Arraylist list = new Arraylist();
list.addAll(Arrays.asList(array));

Pour plus de détails, vous pouvez vous référer à http://javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html

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

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

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

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

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

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

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

Vous pouvez le faire en java 8 comme suit

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

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

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 .

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

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

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

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

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

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

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

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