Java Language Créer une liste à partir d'un tableau


Exemple

La méthode Arrays.asList() peut être utilisée pour renvoyer une List taille fixe contenant les éléments du tableau donné. La List résultante sera du même type de paramètre que le type de base du tableau.

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

Remarque : cette liste est soutenue par ( une vue de) le tableau d'origine, ce qui signifie que toute modification apportée à la liste modifiera le tableau et inversement. Cependant, les modifications de la liste qui changeraient sa taille (et donc la longueur du tableau) déclencheront une exception.

Pour créer une copie de la liste, utilisez le constructeur de java.util.ArrayList prenant une Collection en argument:

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

Dans Java SE 7 et versions ultérieures, une paire de crochets <> (un ensemble vide d'arguments de type) peut être utilisée, appelée Diamond . Le compilateur peut déterminer les arguments de type à partir du contexte. Cela signifie que les informations de type peuvent être omises lors de l'appel du constructeur de ArrayList et qu'elles seront automatiquement déduites lors de la compilation. Cela s'appelle Type Inference, qui fait partie de 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 point à noter à propos du diamant est qu'il ne peut pas être utilisé avec les classes anonymes .

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

Remarques importantes relatives à l'utilisation de la méthode Arrays.asList ()

  • Cette méthode renvoie List , qui est une instance de Arrays$ArrayList (classe interne statique de Arrays ) et non java.util.ArrayList . La List résultante est de taille fixe. Cela signifie que l'ajout ou la suppression d'éléments n'est pas pris en charge et lancera une UnsupportedOperationException :

    stringList.add("something"); // throws java.lang.UnsupportedOperationException
    
  • Une nouvelle List peut être créée par le passage d' un tableau soutenu par List au constructeur d'une nouvelle List . Cela crée une nouvelle copie des données, qui a une taille modifiable et qui n'est pas soutenue par le tableau d'origine:

    List<String> modifiableList = new ArrayList<>(Arrays.asList("foo", "bar"));
    
  • L'appel de <T> List<T> asList(T... a) sur un tableau primitif, tel qu'un int[] , produira une List<int[]> dont le seul élément est le tableau de primitives source au lieu des éléments réels du tableau source.

    La raison de ce comportement est que les types primitifs ne peuvent pas être utilisés à la place des paramètres de type générique, de sorte que le tableau primitif tout entier remplace le paramètre de type générique dans ce cas. Pour convertir un tableau primitif en List , tout d'abord, convertissez le tableau primitif en un tableau du type wrapper correspondant (c'est-à-dire appelez Arrays.asList sur un Integer[] au lieu d'un int[] ).

    Par conséquent, cela va imprimer false :

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

    Voir la démo

    D'un autre côté, cela sera true :

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

    Voir la démo

    Cela imprimera également true , car le tableau sera interprété comme un Integer[] ):

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

    Voir la démo