Créer un tableau à partir d'un tableau

Question

J'ai un tableau initialisé tel que:

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

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

ArrayList<Element> arraylist = ???;

Answer 1

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

Answer 2

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 . Ainsi, si vous souhaitez pouvoir ajouter ou supprimer des éléments de la liste renvoyée dans votre code, vous devez l’envelopper 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 être surprenant.

Answer 3

^{(ancien fil de discussion, mais 2 centimes car aucun ne mentionne Guava ou d'autres bibliothèques et quelques autres détails)}

Si vous le pouvez, utilisez de la goyave

Cela vaut la peine de souligner la méthode Guava, qui simplifie grandement ces manigances:

Utilisation

Pour une liste immuable

Utilisez le <= > et sa ImmutableList et of() méthodes d'usine ^{(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 modifiable

Utilisez le <= > et sa copyOf() 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

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

Pourquoi choisir la goyave?

L'attrait principal pourrait être de réduire l'encombrement dû aux génériques pour la sécurité de type, comme l'utilisation de la goyave les méthodes d'usine permettent la déduction des types la plupart du temps. Toutefois, cet argument a moins d’eau puisque Java 7 est arrivé chez le nouvel opérateur diamantaire.

Mais ce n’est pas la seule raison (et Java 7 n’est pas encore partout): la syntaxe abrégée est également très pratique, et les initialiseurs de méthodes, comme on le voit ci-dessus, permettent d’écrire du code plus expressif. Vous faites en un seul appel Guava ce qui prend 2 avec les Collections Java actuelles.

Si vous ne pouvez pas ...

Pour une liste immuable

Utilisez le newArrayList() du JDK. classe et sa < => méthode d'usine, entourée d'un Sets :

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

Notez que le type renvoyé pour Arrays est une asList() utilisant une implémentation Collections.unmodifiableList() concrète, mais ce n'est PAS List. C'est un type interne, qui émule un ArrayList mais référence en réalité directement le tableau passé et le rend & "Write through &"; (les modifications sont reflétées dans le tableau).

Il interdit les modifications via certaines méthodes de l'API java.util.ArrayList simplement en étendant un AbstractList (ainsi, l'ajout ou la suppression d'éléments n'est pas pris en charge). Toutefois, il autorise les appels vers set() à remplacer les éléments. Ainsi, cette liste n'est pas vraiment immuable et un appel à <=> doit être encapsulé avec <=>.

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

Pour une liste modifiable

Comme ci-dessus, mais enveloppé d'un :

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

Answer 4

Comme cette question est assez ancienne, cela me surprend que personne n'ait suggéré la forme la plus simple à ce jour:

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 à construire le tableau explicitement.

Answer 5

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

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

Answer 6

Autre solution (bien qu'équivalent essentiellement à la new ArrayList(Arrays.asList(array)) solution en termes de performances:

Collections.addAll(arraylist, array);

Answer 7

Java 9

Dans Java 9 , vous pouvez utiliser List.of méthode de fabrique statique afin de créer un <= > littéral. Quelque chose comme ce qui suit:

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

Ceci renverrait un immuable liste contenant trois éléments. Si vous souhaitez une liste mutable , transmettez cette liste au constructeur List:

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

PEC 269: Méthodes de fabrique de commodité pour les collections

JEP 269 fournit des méthodes de fabrique pratiques pour API Java Collections . Ces méthodes de fabriques statiques immuables sont intégrées à la ArrayList , Set , et Map interfaces de Java 9 et versions ultérieures .

Answer 8

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

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

Answer 9

Une autre mise à jour, qui se termine presque en 2014, vous pouvez également le faire avec Java 8:

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

Quelques caractères seraient sauvegardés, s'il ne pouvait s'agir que d'un List

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

Answer 10

Si vous utilisez:

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 un autre Object[] tableau à chaque fois que la capacité doit être étendue.

Heureusement, la mise en oeuvre du JDK est rapide et Arrays.asList(a[]) très bien fait. Il crée une sorte de ArrayList nommée Arrays.ArrayList où les données Object [] pointent directement sur 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 modifiez le tableau initial, vous modifiez la liste! Êtes-vous sûr de vouloir cela? Peut-être que oui, peut-être que non.

Si ce n'est pas le cas, le moyen le plus compréhensible est de procéder ainsi:

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

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

<*>

J'aime utiliser Collections, Arrays ou Guava. Mais si cela ne vous convient pas ou si vous ne le sentez pas, écrivez simplement une autre ligne inélégante.

Answer 11

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

Answer 12

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 est préférable de toujours utiliser l'interface:

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

Answer 13

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

Answer 14

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

Answer 15

comme tout a dit cela le fera

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

et le moyen le plus récent de créer un tableau est observableArrays

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

pour Java SE, vous pouvez essayer

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

selon Documents Oracle

  

observableArrayList ()   Crée une nouvelle liste observable vide qui est soutenue 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");

Answer 16

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

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

Answer 17

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

Answer 18

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 arraylist comme ceci:

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

     

   Remarque : chaque new Element(int args) sera traité en tant qu'objet individuel et peut être transmis en tant que var-args.

2. Il pourrait aussi y avoir une autre réponse à cette question.
   Si vous voyez une déclaration pour la 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 aussi utile pour le faire

   Collections.addAll(arraylist, array);
   

Answer 19

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

Answer 20

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

Answer 21

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

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

Answer 22

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

Disons que vous avez 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 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 ne renvoient qu'une vue en liste d'un tableau, et non un tableau en 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 en essayant de faire des 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 en liste du tableau link .

Answer 23

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

Answer 24

  

Une autre solution Java8 (j'ai peut-être manqué la réponse parmi le grand ensemble. Si c'est le cas, mes excuses). Ceci 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
monde

Answer 25

Vous pouvez le faire dans Java 8 comme suit

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

Answer 26

Déjà tout le monde a fourni assez de bonne réponse à votre problème. Maintenant, parmi toutes les suggestions, vous devez décider lequel correspondra à vos besoins. Il y a deux types de collection que vous devez connaître. L'une est une collection non modifiée et l'autre une collection qui vous permettra de modifier l'objet ultérieurement.

Donc, je vais donner ici 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 modifiable :: 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));

Answer 27

Utilisez le code suivant pour convertir un tableau d’éléments en une 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]);
}

Answer 28

Vous pouvez créer un ArrayList à l'aide de Cactoos (je suis l'un des développeurs):

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

Rien ne garantit que l'objet sera effectivement de classe <=>. Si vous avez besoin de cette garantie, procédez comme suit:

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

Answer 29

Utilisez le code ci-dessous

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

Answer 30

C’est un moyen clair pour cela

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