:

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

ça va marcher. Mais quelques mises en garde:

1. la liste retournée d'asList contient fixed size . Donc, si vous voulez être en mesure d'ajouter ou de supprimer des éléments de la liste retournée dans votre code, vous aurez besoin de l'envelopper dans un nouveau ArrayList . Sinon, vous aurez un UnsupportedOperationException .
2. La liste retournée de asList() est soutenue par le tableau original. Si vous modifiez le tableau d'origine, la liste sera modifiée. Cela peut être surprenant.

^{(vieux fil, mais seulement 2 cents comme aucune mention de goyave ou d'autres libs et quelques autres détails)}

Si Vous Le Pouvez, Utilisez La Goyave

il vaut la peine de souligner le chemin de goyave, qui simplifie grandement ces manigances:

Utilisation

pour une liste immuable

utiliser la classe ImmutableList et son of() et copyOf() "1519410920 d'usine" méthodes ^{(éléments ne peuvent pas être null)} :

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

utiliser les Lists classe 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 les classes, par exemple dans Sets .

Pourquoi La Goyave?

L'attraction principale pourrait être de réduire l'encombrement dû aux médicaments génériques pour la sécurité, comme l'utilisation de la Goyave "1519660920 d'usine" méthodes autoriser les types de déduire la plupart du temps. Cependant, cet argument contient moins d'eau depuis que Java 7 est arrivé avec le nouvel opérateur diamond.

mais C'est ce n'est pas la seule raison (et Java 7 n'est pas encore partout): la syntaxe en raccourci 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 Guava appeler ce qui prend 2 avec les Collections Java actuelles.

si vous ne pouvez pas...

pour une liste immuable

utiliser la classe Arrays de JDK et sa asList() méthode d'usine, enveloppé avec un Collections.unmodifiableList() :

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

noter que le type retourné pour asList() est un List utilisant un béton ArrayList mise en œuvre, mais il n'est pas java.util.ArrayList . Il s'agit d'un type interne, qui émule un ArrayList mais renvoie directement au tableau passé et le fait "écrire à travers" (les modifications sont reflétées dans le tableau).

il interdit les modifications à travers certaines des méthodes de L'API List en prolongeant simplement un AbstractList (ainsi, l'ajout ou la suppression d'éléments n'est pas pris en charge), cependant il permet les appels à set() pour outrepasser les éléments. Ainsi cette liste n'est pas vraiment immuable et un appel à asList() devrait être enveloppé avec Collections.unmodifiableList() .

Voir l'étape suivante si vous avez besoin d'une mutable liste.

pour une liste Mutable

même que ci-dessus, mais enveloppé avec 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 Pédagogiques: Le Bon vieux manuels

// 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, il 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));

s'assurer que myArray est le 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'essentiellement équivalente à la new ArrayList(Arrays.asList(array)) solution performance-wise:

Collections.addAll(arraylist, array);

vous avez probablement juste besoin d'une Liste, pas D'un ArrayList. Dans ce cas, vous pouvez simplement faire:

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

Java 9

dans Java 9 , vous pouvez utiliser List.of méthode d'usine statique afin de créer un List littéral. Quelque chose comme ce qui suit:

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

cela donnerait une liste immuable contenant trois éléments. Si vous voulez un mutable liste, passer cette liste au ArrayList constructeur:

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

JEP 269: le Confort de l'Usine de Méthodes pour les Collections

JEP 269 fournit quelques commodité de l'usine de méthodes pour Java Collections de l'API. Ces méthodes immuables d'usine statique sont intégrées dans le List , Set , et Map interfaces en Java 9 et plus tard.

une autre mise à jour, presque fin 2014, vous pouvez le faire avec Java 8 aussi:

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

quelques caractères seraient sauvegardés, si ce n'était qu'un List

List<Element> list = Stream.of(myArray).collect(Collectors.toList());

pour convertir un tableau en ArrayList, les développeurs font souvent ceci:

List<String> list = Arrays.asList(arr);// this is wrong way..

Arrays.asList() renvoie un ArrayList qui est un private static class inside Arrays , ce n'est pas le java.util.Classe d'ArrayList. The java.util.Arrays.ArrayList classe a set(), get(), contains() méthodes, mais n'a pas de méthodes pour ajouter des éléments, de sorte que sa taille est fixe. Pour créer un vrai ArrayList, vous devez faire:

ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr));

le constructeur de ArrayList peut accepter un Collection type , qui est également un super type pour java.util.Arrays.ArrayList

si vous utilisez:

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

vous peut créer et de remplir deux listes ! Remplir deux fois une grande liste est exactement ce que vous ne voulez pas faire parce qu'il va créer un autre Object[] tableau chaque fois que la capacité doit être prolongée.

heureusement la mise en œuvre de JDK est rapide et Arrays.asList(a[]) est très bien fait. Il crée une sorte D'ArrayList nommé Arrays.Liste de tableaux où l'Objet[] les données 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 ! vous êtes sûr de vouloir ça ? Peut-être que oui, peut-être pas.

si ce n'est pas le cas, la manière 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 dit @glglgl, vous pouvez créer un autre ArrayList indépendant avec:

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

j'adore utiliser Collections , Arrays , ou Goyave. Mais si ça ne va pas, ou si tu ne le sens pas, écris une autre ligne inélégante à la place.

dans Java 9 vous 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 en utilisant 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 des méthodes différentes

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

vous pouvez également le faire avec stream en Java 8.

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

depuis Java 8 Il y a une façon plus facile de transformer:

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

1. si nous voyons la définition de 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 arraylist comme ceci:

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

   Note : chaque new Element(int args) sera traité comme un objet individuel et peut être passé comme un var-args .

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

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

   donc, ce code est aussi utile pour le faire

   Collections.addAll(arraylist, array);
   

comme tous dit que cela va le faire

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

et la plus récente façon commune de créer le 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));

qui est conforme à Oracle Docs

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

Mise À Jour De Java 9

aussi en Java 9 c'est un peu facile:

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

une autre façon simple est d'ajouter tous les éléments du tableau à un nouveau tableau en utilisant un pour-chaque boucle.

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

for(Element e : array)
    list.add(e);

:

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

utiliser:

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

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

même s'il y a beaucoup de réponses parfaitement écrites à cette question, je vais ajouter mes commentaires.

Dites que vous avez Element[] array = { new Element(1), new Element(2), new Element(3) };

New ArrayList peuvent être créées de la manière suivante

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 soutiennent très bien toutes les opérations de 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 retourne juste une vue de Liste d'une liste de tableaux et non des ArrayList.

// 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 l'erreur en essayant de faire quelques opérations ArrayList

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

de Plus sur la Liste à la représentation de la matrice de lien .

la façon la plus simple de le faire est d'ajouter le code suivant. Essayé et testé.

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

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

 Arraylist arr = new Arraylist();
 arr.addAll(Arrays.asList(asset));

un Autre Java8 solution (j'ai peut-être raté la réponse parmi le grand jeu. Si donc, mes excuses). cela crée un ArrayList (par opposition à une liste) i.e. 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);
    }
}

sortie est...

Bonjour

monde

déjà tout le monde a fourni assez bonne réponse pour votre problème. Maintenant, à partir de toutes les suggestions, vous devez décider qui sera adapté à votre exigence. Il y a deux types de collecte que vous devez savoir. L'une Est collection non modifiée et l'autre une collection qui vous permettra de modifier l'objet plus tard.

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

• immuable collection creation:: When vous ne voulez pas modifier l'objet collection après la création

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

• Mutables la création de la collection : Lorsque vous vous souhaiterez peut-être modifier le créé objet de collection après la création.

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

vous pouvez le faire en java 8 comme suit

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

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

vous pouvez créer un ArrayList en utilisant Cactoos (je suis un des développeurs):

List<String> names = new StickyList<>(
  "Scott Fitzgerald", "Fyodor Dostoyevsky"
);

Il n'y a aucune garantie que l'objet sera effectivement de la classe ArrayList . Si vous avez besoin de cette garantie, faites ceci:

ArrayList<String> list = new ArrayList<>(
  new StickyList<>(
    "Scott Fitzgerald", "Fyodor Dostoyevsky"
  )
);