Java Language Creare una lista da una matrice

Esempio

Il metodo Arrays.asList() può essere usato per restituire una List dimensione fissa contenente gli elementi dell'array dato. L' List risultante avrà lo stesso tipo di parametro del tipo base dell'array.

String[] stringArray = {"foo", "bar", "baz"};
List<String> stringList = Arrays.asList(stringArray);

Nota : questo elenco è supportato da una vista della matrice originale, il che significa che qualsiasi modifica alla lista cambierà la matrice e viceversa. Tuttavia, le modifiche alla lista che cambierebbero le sue dimensioni (e quindi la lunghezza dell'array) genereranno un'eccezione.

Per creare una copia dell'elenco, utilizzare il costruttore di java.util.ArrayList che java.util.ArrayList una Collection come argomento:

Java SE 5
String[] stringArray = {"foo", "bar", "baz"};
List<String> stringList = new ArrayList<String>(Arrays.asList(stringArray));
Java SE 7

In Java SE 7 e versioni successive, è possibile utilizzare una coppia di parentesi angolari <> (set vuoto di argomenti tipo), che si chiama Diamond . Il compilatore può determinare gli argomenti di tipo dal contesto. Ciò significa che le informazioni sul tipo possono essere omesse quando si chiama il costruttore di ArrayList e verranno dedotte automaticamente durante la compilazione. Questo è chiamato tipo Inferenza che fa parte di Java Generics .

// Using Arrays.asList()

String[] stringArray = {"foo", "bar", "baz"};
List<String> stringList = new ArrayList<>(Arrays.asList(stringArray));

// Using ArrayList.addAll()

String[] stringArray = {"foo", "bar", "baz"};
ArrayList<String> list = new ArrayList<>();
list.addAll(Arrays.asList(stringArray));

// Using Collections.addAll()

String[] stringArray = {"foo", "bar", "baz"};
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, stringArray);

Un punto degno di nota sul diamante è che non può essere utilizzato con le classi anonime .

Java SE 8
// Using Streams

int[] ints = {1, 2, 3};
List<Integer> list = Arrays.stream(ints).boxed().collect(Collectors.toList());

String[] stringArray = {"foo", "bar", "baz"};
List<Object> list = Arrays.stream(stringArray).collect(Collectors.toList());

Note importanti relative all'uso del metodo Arrays.asList ()

  • Questo metodo restituisce List , che è un'istanza di Arrays$ArrayList (classe interna statica di Arrays ) e non java.util.ArrayList . L' List risultante è di dimensioni fisse. Ciò significa che l'aggiunta o la rimozione di elementi non è supportata e genererà un UnsupportedOperationException :

    stringList.add("something"); // throws java.lang.UnsupportedOperationException
    
  • Un nuovo List può essere creato passando un List supportato da array al costruttore di una nuova List . Ciò crea una nuova copia dei dati, che ha dimensioni variabili e che non è supportata dall'array originale:

    List<String> modifiableList = new ArrayList<>(Arrays.asList("foo", "bar"));
    
  • Chiamando <T> List<T> asList(T... a) su un array primitivo, ad esempio un int[] , verrà generato un List<int[]> cui unico elemento è l'array primitivo di origine anziché gli elementi effettivi dell'array sorgente.

    La ragione di questo comportamento è che i tipi primitivi non possono essere usati al posto dei parametri di tipo generico, quindi l'intero array primitivo sostituisce il parametro di tipo generico in questo caso. Per convertire una matrice primitiva in una List , convertire innanzitutto la matrice primitiva in una matrice del tipo di wrapper corrispondente (ad esempio, chiamare Arrays.asList su un numero Integer[] anziché su un int[] ).

    Pertanto, questo verrà stampato false :

    int[] arr = {1, 2, 3};      // primitive array of int
    System.out.println(Arrays.asList(arr).contains(1));
    

    Visualizza la demo

    D'altra parte, questo verrà stampato true :

    Integer[] arr = {1, 2, 3};  // object array of Integer (wrapper for int)
    System.out.println(Arrays.asList(arr).contains(1));
    

    Visualizza la demo

    Anche questo verrà stampato true , poiché l'array verrà interpretato come un Integer[] ):

    System.out.println(Arrays.asList(1,2,3).contains(1));
    

    Visualizza la demo