La réponse simple
Dans Java 9 ou version ultérieure, après a List.of()été ajouté:
List<String> strings = List.of("foo", "bar", "baz");
Avec Java 10 ou version ultérieure, cela peut être raccourci avec le varmot - clé.
var strings = List.of("foo", "bar", "baz");
Cela vous donnera une immuable List , donc il ne peut pas être changé.
C'est ce que vous voulez dans la plupart des cas où vous le préremplissez.
Java 8 ou version antérieure:
List<String> strings = Arrays.asList("foo", "bar", "baz");
Cela vous donnera un Listsoutenu par un tableau, donc il ne peut pas changer de longueur.
Mais vous pouvez appeler List.set, donc c'est toujours mutable .
Vous pouvez Arrays.asListraccourcir encore plus avec une importation statique:
List<String> strings = asList("foo", "bar", "baz");
L'importation statique:
import static java.util.Arrays.asList;
Ce que n'importe quel IDE moderne suggérera et fera automatiquement pour vous.
Par exemple, dans IntelliJ IDEA, vous appuyez sur Alt+Enteret sélectionnezStatic import method... .
Cependant, je ne recommande pas de raccourcir la List.ofméthode of, car cela devient déroutant.
List.ofest déjà assez court et se lit bien.
En utilisant Stream s
Pourquoi faut-il que ce soit un List?
Avec Java 8 ou version ultérieure, vous pouvez utiliser un Streamqui est plus flexible:
Stream<String> strings = Stream.of("foo", "bar", "baz");
Vous pouvez concaténer Streams:
Stream<String> strings = Stream.concat(Stream.of("foo", "bar"),
Stream.of("baz", "qux"));
Ou vous pouvez passer de a Streamà a List:
import static java.util.stream.Collectors.toList;
List<String> strings = Stream.of("foo", "bar", "baz").collect(toList());
Mais de préférence, utilisez simplement le Streamsans le ramasser à un List.
Si vous avez vraiment besoin d'unjava.util.ArrayList
(Vous ne le faites probablement pas.)
Pour citer JEP 269 (c'est moi qui souligne):
Il existe un petit ensemble de cas d'utilisation pour initialiser une instance de collection mutable avec un ensemble de valeurs prédéfinies. Il est généralement préférable que ces valeurs prédéfinies se trouvent dans une collection immuable, puis d'initialiser la collection mutable via un constructeur de copie.
Si vous souhaitez à la fois préremplir un ArrayList et y ajouter par la suite (pourquoi?), Utilisez
ArrayList<String> strings = new ArrayList<>(List.of("foo", "bar"));
strings.add("baz");
ou en Java 8 ou version antérieure:
ArrayList<String> strings = new ArrayList<>(asList("foo", "bar"));
strings.add("baz");
ou en utilisant Stream:
import static java.util.stream.Collectors.toCollection;
ArrayList<String> strings = Stream.of("foo", "bar")
.collect(toCollection(ArrayList::new));
strings.add("baz");
Mais encore une fois, il vaut mieux utiliser Streamdirectement le au lieu de le collecter dans unList .
Programme aux interfaces, pas aux implémentations
Vous avez déclaré avoir déclaré la liste en tant que ArrayListdans votre code, mais vous ne devriez le faire que si vous utilisez un membre deArrayList qui n'en fait pas partie List.
Ce que vous ne faites probablement pas.
Habituellement , vous devez simplement déclarer des variables par la plus interface générale que vous allez utiliser (par exemple Iterable, Collectionou List), et les initialiser avec la mise en œuvre spécifique (par exemple ArrayList, LinkedListouArrays.asList() ).
Sinon, vous limitez votre code à ce type spécifique, et il sera plus difficile de changer quand vous le souhaitez.
Par exemple, si vous passez d'un ArrayListà un void method(...):
// Iterable if you just need iteration, for (String s : strings):
void method(Iterable<String> strings) {
for (String s : strings) { ... }
}
// Collection if you also need .size(), .isEmpty(), or .stream():
void method(Collection<String> strings) {
if (!strings.isEmpty()) { strings.stream()... }
}
// List if you also need .get(index):
void method(List<String> strings) {
strings.get(...)
}
// Don't declare a specific list implementation
// unless you're sure you need it:
void method(ArrayList<String> strings) {
??? // You don't want to limit yourself to just ArrayList
}
Un autre exemple serait de toujours déclarer une variable an InputStreammême s'il s'agit généralement d'un FileInputStreamou d'un BufferedInputStream, car un jour prochain, vous ou quelqu'un d'autre voudrez utiliser un autre type de InputStream.
ArrasyList<String> places = ["Buenos Aires", "Córdoba", "La Plata"]