Créer liste de tableaux à partir de la matrice de

Donné:

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

La réponse la plus simple est de le 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.

Depuis que cette question est assez vieux, ça m'étonne 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));

De Java 5, Arrays.asList() prend un varargs paramètre et que vous n'avez pas à construire le tableau explicitement.

D'une autre façon (bien qu'essentiellement équivalente à la new ArrayList(Arrays.asList(array)) solution en terme de performance:

Collections.addAll(arraylist, array);

Vous avez probablement juste besoin d'une Liste, pas une liste de tableaux. Dans ce cas, il vous suffit de faire:

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

Si vous utilisez :

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

vous peut créer et remplir deux listes ! Le remplissage de deux fois une grande liste est exactement ce que vous ne voulez pas le faire, car il va créer un autre Object[] tableau à chaque fois que les besoins de capacité à être étendu.

Heureusement le JDK mise en œuvre est rapide et Arrays.asList(a[]) est très bien fait. Il permet de créer une sorte de liste de tableaux de Tableaux nommés.Liste de tableaux où l'Objet de[] points de données directement dans 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
    }
    ....
}

Secondaires dangereux, c'est que si vous modifiez la table initiale, vous modifiez la Liste ! Êtes-vous sûr que vous voulez que ? Peut-être que oui, peut-être pas.

Si pas, le plus compréhensible est de faire ceci :

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

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

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

J'aime utiliser Collections, Arrays, ou de Goyave. Mais si elle ne rentre pas, ou vous ne le sentez pas, il suffit d'écrire un autre inélégante ligne à la place.

En fonction de la question de la réponse à l'aide de java 1.7:

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

Vous pouvez le 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

Vous pouvez également le faire avec des flux en Java 8.

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

1. Si on peut voir 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. 

   Ainsi, 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ée comme Objet, et peut être passé comme un var-args.

2. Il y a peut être une autre réponse pour cette question.
   
   Si vous consultez la 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 de faire

   Collections.addAll(arraylist, array);

Si le tableau est d'un type primitif, les réponses données ne fonctionne pas. Mais depuis Java 8, vous pouvez utiliser:

int[] array = new int[5];
Arrays.stream(array).boxed().collect(Collectors.toList());

Même si il ya beaucoup de parfaitement écrit les réponses à cette question, je vais ajouter mes entrées.

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

New ArrayList peut être créé dans l'une 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 ont très bien en charge 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 vont donner d'erreur lorsque vous essayez de faire quelques ArrayList opérations

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

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

Un autre Java8 solution (j'ai peut-être raté la réponse parmi le grand jeu. Si donc, mes excuses). Cela crée une liste de tableaux (par opposition à une Liste), à savoir 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);
    }
}

De sortie est...

Bonjour

monde

Déjà tout le monde a fourni une assez bonne réponse à votre problème.
Maintenant à partir de la toutes les suggestions, vous avez besoin de décider qui sera adapté à votre exigence. Il existe deux types de collecte dont vous avez besoin de savoir. L'un est non modifiée de la collecte et de l'autre une collection qui va vous permettre de modifier l'objet plus tard.

Donc, Ici, je vais donner l'exemple de deux cas d'utilisation.

• Immuable la création de la collection :: Quand vous ne voulez pas modifier l'objet de collection après la création

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

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

C'est une manière claire pour que

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

Utilisez code ci-dessous

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

Il y a une autre option, si votre objectif est de générer une liste fixe au moment de l'exécution, qui est aussi simple qu'efficace:

static final ArrayList<Element> myList = generateMyList();

private static ArrayList<Element> generateMyList() {
  final ArrayList<Element> result = new ArrayList<>();
  result.add(new Element(1));
  result.add(new Element(2));
  result.add(new Element(3));
  result.add(new Element(4));
  return result;
}

L'avantage de ce modèle est que la liste est pour une fois pas généré de manière très intuitive et, par conséquent, est très facile à modifier, même avec des listes de grande taille ou complexes d'initialisation, tandis que de l'autre main, il contient toujours les mêmes Éléments sur tous les réels de l'exécution du programme (à moins de changer à un moment plus tard, bien sûr).