Prosta odpowiedź
W Javie 9 lub nowszej List.of()dodano później :
List<String> strings = List.of("foo", "bar", "baz");
W Javie 10 lub nowszej można to skrócić za pomocą varsłowa kluczowego.
var strings = List.of("foo", "bar", "baz");
To da ci niezmienne List , więc nie można tego zmienić.
To jest to, czego chcesz w większości przypadków, gdy przygotowujesz to do wypełnienia.
Java 8 lub wcześniejsza:
List<String> strings = Arrays.asList("foo", "bar", "baz");
To da ci Listwsparcie przez tablicę, więc nie może zmienić długości.
Ale możesz zadzwonić List.set, więc nadal można go modyfikować .
Możesz Arrays.asListskrócić jeszcze bardziej za pomocą importu statycznego:
List<String> strings = asList("foo", "bar", "baz");
Import statyczny:
import static java.util.Arrays.asList;
Co każde nowoczesne IDE zasugeruje i automatycznie zrobi dla Ciebie.
Na przykład w IntelliJ IDEA naciskasz Alt+Enteri wybierasz Static import method....
Jednak nie polecam skracania List.ofmetody of, ponieważ staje się to mylące.
List.ofjest już wystarczająco krótki i dobrze czyta.
Korzystanie z Streams
Dlaczego to musi być List ?
W Javie 8 lub nowszej możesz użyć Streambardziej elastycznego:
Stream<String> strings = Stream.of("foo", "bar", "baz");
Możesz połączyć następujące elementy Stream:
Stream<String> strings = Stream.concat(Stream.of("foo", "bar"),
Stream.of("baz", "qux"));
Lub możesz przejść z Stream do List:
import static java.util.stream.Collectors.toList;
List<String> strings = Stream.of("foo", "bar", "baz").collect(toList());
Ale najlepiej po prostu użyj Stream bez zbierania go do List.
Jeśli ty naprawdę potrzebujeszjava.util.ArrayList
(Prawdopodobnie nie.)
Cytując JEP 269 (moje podkreślenie):
Jest mały zestaw przypadków użycia do zainicjowania mutable instancji kolekcji przy użyciu predefiniowanego zestawu wartości. Zazwyczaj lepiej jest mieć te predefiniowane wartości w niezmiennej kolekcji, a następnie zainicjować kolekcję podlegającą modyfikacji za pomocą konstruktora kopii.
Jeśli chcesz zarówno wstępnie wypełnić an, jak ArrayList i dodać do niego później (dlaczego?), Użyj
ArrayList<String> strings = new ArrayList<>(List.of("foo", "bar"));
strings.add("baz");
lub w Javie 8 lub wcześniejszej:
ArrayList<String> strings = new ArrayList<>(asList("foo", "bar"));
strings.add("baz");
lub za pomocą Stream :
import static java.util.stream.Collectors.toCollection;
ArrayList<String> strings = Stream.of("foo", "bar")
.collect(toCollection(ArrayList::new));
strings.add("baz");
Ale znowu, lepiej po prostu użyć Stream bezpośrednio zamiast zbierać go do List.
Program do interfejsów, a nie do implementacji
Powiedziałeś, że zadeklarowałeś listę jako ArrayListw swoim kodzie, ale powinieneś to zrobić tylko wtedy, gdy używasz jakiegoś członka, ArrayListktórego nie maList .
Czego najprawdopodobniej nie robisz.
Zazwyczaj należy po prostu zadeklarować zmienne od najbardziej ogólnego interfejsu, który będzie używany (np Iterable, Collectionalbo List) i zainicjować je z realizacją konkretnego (np ArrayList, LinkedListlub Arrays.asList()).
W przeciwnym razie ograniczysz kod do tego konkretnego typu i trudniej będzie go zmienić, kiedy chcesz.
Na przykład, jeśli przekazujesz an ArrayListdo 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
}
Innym przykładem byłoby zawsze deklarowanie zmiennej, InputStreamnawet jeśli zwykle jest to a FileInputStreamlub a BufferedInputStream, ponieważ pewnego dnia ty lub ktoś inny będzie chciał użyć innego rodzaju InputStream.
ArrasyList<String> places = ["Buenos Aires", "Córdoba", "La Plata"]