La semplice risposta
In Java 9 o versioni successive, dopo è List.of()stato aggiunto:
List<String> strings = List.of("foo", "bar", "baz");
Con Java 10 o versioni successive, questo può essere abbreviato con la varparola chiave.
var strings = List.of("foo", "bar", "baz");
Questo ti darà un valore immutabile List , quindi non può essere modificato.
Qual è quello che vuoi nella maggior parte dei casi in cui lo stai prepopolando.
Java 8 o precedente:
List<String> strings = Arrays.asList("foo", "bar", "baz");
Questo ti darà il Listsupporto di un array, quindi non può cambiare lunghezza.
Ma si può chiamare List.set, quindi è ancora mutabile .
Puoi renderlo Arrays.asListancora più breve con un'importazione statica:
List<String> strings = asList("foo", "bar", "baz");
L'importazione statica:
import static java.util.Arrays.asList;
Quale qualsiasi IDE moderno suggerirà e farà automaticamente per te.
Ad esempio in IntelliJ IDEA si preme Alt+Entere si seleziona Static import method....
Tuttavia, non consiglio di abbreviare il List.ofmetodo of, perché diventa confuso.
List.ofè già abbastanza corto e legge bene.
Usando Streams
Perché deve essere un List?
Con Java 8 o versioni successive è possibile utilizzare un Streammetodo più flessibile:
Stream<String> strings = Stream.of("foo", "bar", "baz");
Puoi concatenare Stream:
Stream<String> strings = Stream.concat(Stream.of("foo", "bar"),
Stream.of("baz", "qux"));
Oppure puoi andare da a Streama a List:
import static java.util.stream.Collectors.toList;
List<String> strings = Stream.of("foo", "bar", "baz").collect(toList());
Ma preferibilmente, basta usare il Streamsenza raccoglierlo in a List.
Se hai davvero bisogno di ajava.util.ArrayList
(Probabilmente no.)
Per citare JEP 269 (enfasi sulla mia):
Esiste un piccolo set di casi d'uso per l'inizializzazione di un'istanza di raccolta mutabile con un set predefinito di valori. Di solito è preferibile avere quei valori predefiniti in una raccolta immutabile e quindi inizializzare la raccolta mutabile tramite un costruttore di copie.
Se si vuole sia un precompilare ArrayList e aggiungere ad essa in seguito (perché?), L'uso
ArrayList<String> strings = new ArrayList<>(List.of("foo", "bar"));
strings.add("baz");
o in Java 8 o precedenti:
ArrayList<String> strings = new ArrayList<>(asList("foo", "bar"));
strings.add("baz");
o usando Stream:
import static java.util.stream.Collectors.toCollection;
ArrayList<String> strings = Stream.of("foo", "bar")
.collect(toCollection(ArrayList::new));
strings.add("baz");
Ma ancora una volta, è meglio usare Streamdirettamente il invece di raccoglierlo in a List.
Programma per interfacce, non per implementazioni
Hai detto di aver dichiarato l'elenco come ArrayListnel tuo codice, ma dovresti farlo solo se stai usando un membro ArrayListche non è in List.
Cosa che molto probabilmente non stai facendo.
Di solito dovresti semplicemente dichiarare le variabili dall'interfaccia più generale che intendi utilizzare (ad es Iterable. Collection, O List) e inizializzarle con l'implementazione specifica (ad es. ArrayList, LinkedListOArrays.asList() ).
Altrimenti stai limitando il tuo codice a quel tipo specifico, e sarà più difficile cambiare quando vuoi.
Ad esempio, se stai passando un ArrayLista 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 altro esempio sarebbe sempre dichiarare una variabile InputStreamanche se di solito è una FileInputStreamo una BufferedInputStream, perché un giorno presto tu o qualcun altro vorrete usare qualche altro tipo di InputStream.
ArrasyList<String> places = ["Buenos Aires", "Córdoba", "La Plata"]