Comment créer ArrayList (ArrayList<T>) de la matrice (T[])

Question

J'ai un tableau qui est initialisé comme:

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

Je voudrais le convertir ce tableau en un objet de la classe ArrayList.

ArrayList<Element> arraylist = ???;

Je suis sûr que j'ai fait avant, mais la solution est assis juste sur le bord de mon mémoire.

Answer 1

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

Answer 2

Donnée:

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 fonctionne très bien. Mais quelques mises en garde:

1. La liste retournée par asList a taille fixe. 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 une UnsupportedOperationException.
2. La liste retournée par asList() "est soutenu par le tableau d'origine. Si vous modifiez le tableau d'origine, la liste sera modifiée. Cela peut être surprenant.

Answer 3

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

Si Vous Le Pouvez, Utilisez Goyave

Il est intéressant de souligner la Goyave façon, ce qui simplifie grandement ces manigances:

L'utilisation de la

Pour une Liste Immuable

Utiliser l' ImmutableList de la classe et de ses of() et copyOf() méthodes de fabrique ^{(les éléments ne peuvent pas être null)}:

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

Pour Une Liste Mutable

Utiliser l' Lists de la classe et de ses newArrayList() usine méthodes:

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, en Sets.

Pourquoi 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 usine méthodes permettent les types de déduire la plupart du temps. Toutefois, cet argument contient moins d'eau depuis Java 7 est arrivé avec le nouveau diamant de l'opérateur.

Mais ce n'est pas la seule raison (et Java 7 n'est pas encore partout): l'abréviation syntaxe est également très pratique, et les méthodes d'initialiseurs, comme on le voit ci-dessus, permettent d'écrire plus expressif code. Vous le faites dans une Goyave appel ce qui prend 2 avec le courant Java Collections.

---

Si Vous ne Pouvez pas...

Pour une Liste Immuable

Utilisez le JDK de l' Arrays de la classe et de ses asList() méthode de fabrique, enveloppé avec 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 List à l'aide d'un béton ArrayList mise en œuvre, mais il n'est PAS java.util.ArrayList. C'est un intérieur de type, qui émule un ArrayList mais en fait directement référence le tableau transmis et la rend "écrire" (les modifications sont reflétées dans le tableau).

Il interdit à des modifications par le biais de certains de l' List de l'API de méthodes par le biais d'une simple extension de l' AbstractList (donc, l'ajout ou la suppression d'éléments non pris en charge), mais il permet de faire des appels à l' set() pour remplacer des éléments. Donc cette liste n'est pas vraiment immuable et un appel à l' asList() doit ê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ée avec un effectif 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+

---

Pour les Fins de l'Enseignement: 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);
}

Answer 4

Depuis que cette question est assez vieux, c'surprises moi que personne n'a suggéré la forme la plus simple encore:

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

Comme de Java 5, Tableaux.asList() prend un varargs paramètre et que vous n'avez pas à construire le tableau explicite.

Answer 5

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