Question Créer ArrayList à partir du tableau


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 classe ArrayList.

ArrayList<Element> arraylist = ???;

2963
2017-10-01 14:38


origine


Réponses:


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

3962
2017-10-01 14:39



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 taille fixe. Donc, si vous voulez pouvoir ajouter ou supprimer des éléments de la liste renvoyée dans votre code, vous devez l'ajouter à un nouveau ArrayList. Sinon, vous aurez un UnsupportedOperationException.
  2. La liste retournée de asList() est soutenu par le tableau original. Si vous modifiez le tableau d'origine, la liste sera également modifiée. Cela peut être surprenant.

774
2017-10-01 15:39



(vieux fil, mais seulement 2 cents car aucune mention de goyave ou d'autres libs et d'autres détails)

Si vous le pouvez, utilisez Goyave

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

Usage

Pour une liste immutable

Utilisez le ImmutableList classe et son of() et copyOf() méthodes d'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 le Lists classe et son 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

S'il vous plaît noter également les méthodes similaires pour d'autres structures de données dans d'autres classes, par exemple dans Sets.

Pourquoi goyave?

L'attraction principale pourrait être de réduire le fouillis en raison de génériques pour la sécurité de type, comme l'utilisation de la goyave méthodes d'usine permettre aux types d'être déduits la plupart du temps. Cependant, cet argument tient moins d'eau puisque Java 7 est arrivé avec le nouvel opérateur diamant.

Mais ce n'est pas la seule raison (et Java 7 n'est pas encore partout): la syntaxe sténographique est aussi très pratique, et les initialiseurs de méthodes, comme vu plus haut, 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 immutable

Utilisez le JDK Arrays classe et son asList() méthode d'usine, enveloppé d'un Collections.unmodifiableList():

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

Notez que le type renvoyé pour asList() est un List en utilisant un béton ArrayList mise en œuvre, mais ce n'est pas  java.util.ArrayList. C'est un type interne, qui émule un ArrayList mais fait référence directement au tableau passé et le rend "write through" (les modifications sont reflétées dans le tableau).

Il interdit les modifications à travers certains des List Méthodes de l'API par le simple prolongement d'un AbstractList (donc, l'ajout ou la suppression d'éléments n'est pas pris en charge), mais il permet d'appeler set() pour remplacer les éléments. Cette liste n'est donc pas vraiment immuable et appelle à asList() devrait être enveloppé avec Collections.unmodifiableList().

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

Pour une liste modifiable

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 éducatives: Le bon vieux chemin 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);
}

295
2017-11-16 17:16



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

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


203
2018-06-22 11:30



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

Sois sûr 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.


172
2017-10-01 14:40



Une autre voie (bien qu'essentiellement équivalente à la new ArrayList(Arrays.asList(array)) solution au niveau de la performance:

Collections.addAll(arraylist, array);

77
2018-04-03 23:20



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

62
2017-10-01 14:45



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 le suivant:

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

Cela retournerait un immuable liste contenant trois éléments. Si vous voulez un mutable liste, passez cette liste à ArrayList constructeur:

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

JEP 269: Méthodes d'usine de proximité pour les collections

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


59
2018-04-17 16:58



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 sauvés, si cela pouvait être juste un List 

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

54
2017-11-25 20:48



Pour convertir un tableau en ArrayList, les développeurs le font souvent:

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

Arrays.asList() retournera un ArrayList qui est un private static class inside Arrays, ce n'est pas la classe java.util.ArrayList. The java.util.Arrays.ArrayList la 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 une ArrayList réelle, vous devez faire:

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

Le constructeur de ArrayList peut accepter un Type de collection, qui est aussi un super type pour java.util.Arrays.ArrayList


47
2018-06-25 07:20