Chciałem stworzyć listę opcji do celów testowych. Na początku zrobiłem to:

ArrayList<String> places = new ArrayList<String>();
places.add("Buenos Aires");
places.add("Córdoba");
places.add("La Plata");

Następnie zmieniłem kod w następujący sposób:

ArrayList<String> places = new ArrayList<String>(
    Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

Czy jest na to lepszy sposób?

Właściwie prawdopodobnie „najlepszym” sposobem na zainicjowanie ArrayListmetody jest napisana przez ciebie metoda, ponieważ nie trzeba jej Listw żaden sposób tworzyć :

ArrayList<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");

Problem polega na tym, że aby odwołać się do tego listwystąpienia , konieczne jest sporo pisania .

Istnieją alternatywy, takie jak utworzenie anonimowej klasy wewnętrznej za pomocą inicjatora instancji (znanego również jako „inicjalizacja podwójnego nawiasu klamrowego”):

ArrayList<String> list = new ArrayList<String>() {{
    add("A");
    add("B");
    add("C");
}};

Jednak nie przepadam za tą metodą, ponieważ to, co kończysz, to podklasa, ArrayListktóra ma inicjalizator instancji, a ta klasa jest tworzona tylko w celu stworzenia jednego obiektu - to wydaje mi się trochę przesadne.

Byłoby miło, gdyby propozycja Collection Literals dla Project Coin została zaakceptowana (miała zostać wprowadzona w Javie 7, ale raczej nie będzie częścią Java 8).

List<String> list = ["A", "B", "C"];

Niestety nie pomoże ci to tutaj, ponieważ zainicjuje niezmienne Listzamiast ArrayList, a ponadto nie jest jeszcze dostępne, jeśli kiedykolwiek będzie.

Byłoby łatwiej, gdyby po prostu zadeklarować go jako List- czy to musi być ArrayList?

List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");

Lub jeśli masz tylko jeden element:

List<String> places = Collections.singletonList("Buenos Aires");

Oznaczałoby to, że placesjest niezmienny (próba zmiany spowoduje UnsupportedOperationExceptionwygenerowanie wyjątku).

Aby utworzyć konkretną listę, ArrayListktórą można modyfikować , możesz utworzyć ją ArrayListz listy niezmiennej:

ArrayList<String> places = new ArrayList<>(Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

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.

Jeśli potrzebujesz prostej listy o rozmiarze 1:

List<String> strings = new ArrayList<String>(Collections.singletonList("A"));

Jeśli potrzebujesz listy kilku obiektów:

List<String> strings = new ArrayList<String>();
Collections.addAll(strings,"A","B","C","D");

Z Guava możesz pisać:

ArrayList<String> places = Lists.newArrayList("Buenos Aires", "Córdoba", "La Plata");

W Guava są też inne przydatne konstruktory statyczne. Możesz przeczytać o nich tutaj .

Literały kolekcji nie trafiły do ​​Java 8, ale można użyć interfejsu API Stream do zainicjowania listy w jednym dość długim wierszu:

List<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toList());

Jeśli potrzebujesz aby zapewnić, że Listjest ArrayList:

ArrayList<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toCollection(ArrayList::new));

Z java-9i powyżej, jak zasugerowano w JEP 269: Wygodowe metody fabryczne dla kolekcji , można to osiągnąć za pomocą literałów kolekcji teraz dzięki -

List<String> list = List.of("A", "B", "C");

Set<String> set = Set.of("A", "B", "C");

Podobne podejście dotyczyłoby Maprównież -

Map<String, String> map = Map.of("k1", "v1", "k2", "v2", "k3", "v3")

która jest podobna do propozycji literatury kolekcji, jak stwierdził @coobird. Dalsze wyjaśnienia również w JEP -

Alternatywy

Zmiany językowe były kilkakrotnie rozpatrywane i odrzucane:

Propozycja monety projektu, 29 marca 2009 r

Propozycja monety projektu, 30 marca 2009 r

Dyskusja JEP 186 na temat lambda-dev, styczeń-marzec 2014 r

Propozycje językowe zostały odłożone na bok zamiast propozycji opartej na bibliotece, streszczonej w tym komunikacie.

Powiązane: Jaki jest sens przeciążonych metod fabryk wygody dla kolekcji w Javie 9

import com.google.common.collect.ImmutableList;

....

List<String> places = ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");

Możesz stworzyć metodę fabryczną:

public static ArrayList<String> createArrayList(String ... elements) {
  ArrayList<String> list = new ArrayList<String>();
  for (String element : elements) {
    list.add(element);
  }
  return list;
}

....

ArrayList<String> places = createArrayList(
  "São Paulo", "Rio de Janeiro", "Brasília");

Ale to niewiele lepsze niż pierwsze refaktoryzacja.

Dla większej elastyczności może być ogólny:

public static <T> ArrayList<T> createArrayList(T ... elements) {
  ArrayList<T> list = new ArrayList<T>();
  for (T element : elements) {
    list.add(element);
  }
  return list;
}

W Javie 9 możemy łatwo zainicjować ArrayListjedną linię:

List<String> places = List.of("Buenos Aires", "Córdoba", "La Plata");

lub

List<String> places = new ArrayList<>(List.of("Buenos Aires", "Córdoba", "La Plata"));

To nowe podejście do Java 9 ma wiele zalet w stosunku do poprzednich:

1. Wydajność przestrzeni
2. Niezmienność
3. Wątek bezpieczny

Zobacz ten post, aby uzyskać więcej informacji -> Jaka jest różnica między List.of a Arrays.asList?

Najbardziej kompaktowym sposobem na to jest:

Double array[] = { 1.0, 2.0, 3.0};
List<Double> list = Arrays.asList(array);

Po prostu użyj poniższego kodu w następujący sposób.

List<String> list = new ArrayList<String>() {{
            add("A");
            add("B");
            add("C");
}};

Dzięki Eclipse Collections możesz napisać:

List<String> list = Lists.mutable.with("Buenos Aires", "Córdoba", "La Plata");

Możesz także sprecyzować typy i czy są one zmienne czy niezmienne.

MutableList<String> mList = Lists.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableList<String> iList = Lists.immutable.with("Buenos Aires", "Córdoba", "La Plata");

Możesz również zrobić to samo z zestawami i torbami:

Set<String> set = Sets.mutable.with("Buenos Aires", "Córdoba", "La Plata");
MutableSet<String> mSet = Sets.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet<String> iSet = Sets.immutable.with("Buenos Aires", "Córdoba", "La Plata");

Bag<String> bag = Bags.mutable.with("Buenos Aires", "Córdoba", "La Plata");
MutableBag<String> mBag = Bags.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableBag<String> iBag = Bags.immutable.with("Buenos Aires", "Córdoba", "La Plata");

Uwaga: jestem osobą odpowiedzialną za kolekcje Eclipse.

Oto inny sposób:

List<String> values = Stream.of("One", "Two").collect(Collectors.toList());

(Powinien to być komentarz, ale zbyt długi, więc nowa odpowiedź). Jak wspomnieli inni, Arrays.asListmetoda ma stały rozmiar, ale to nie jedyny problem. Nie radzi sobie również dobrze z dziedziczeniem. Załóżmy na przykład, że masz:

class A{}
class B extends A{}

public List<A> getAList(){
    return Arrays.asList(new B());
}

Powyższe powoduje błąd kompilatora, ponieważ List<B>(co jest co jest zwracane przez Arrays.asList) nie jest podklasą List<A>, chociaż można dodawać obiekty typu B do List<A>obiektu. Aby obejść ten problem, musisz zrobić coś takiego:

new ArrayList<A>(Arrays.<A>asList(b1, b2, b3))

Jest to prawdopodobnie najlepszy sposób na zrobienie tego, szczególnie. jeśli potrzebujesz nieograniczonej listy lub musisz użyć dziedziczenia.

Możesz użyć poniższych instrukcji:

Fragment kodu:

String [] arr = {"Sharlock", "Homes", "Watson"};

List<String> names = Arrays.asList(arr);

Jak powiedział Tom :

List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");

Ale ponieważ narzekałeś na potrzebę ArrayList, powinieneś najpierw wiedzieć, że ArrayList jest podklasą List i możesz po prostu dodać ten wiersz:

ArrayList<String> myPlaces = new ArrayList(places);

Chociaż może to powodować narzekanie na „wydajność”.

W takim przypadku nie ma to dla mnie sensu, ponieważ skoro twoja lista jest predefiniowana, nie została zdefiniowana jako tablica (ponieważ rozmiar jest znany w momencie inicjalizacji). A jeśli to dla ciebie opcja:

String[] places = {"Buenos Aires", "Córdoba", "La Plata"};

Jeśli nie przejmujesz się drobnymi różnicami w wydajności, możesz również bardzo prosto skopiować tablicę do ArrayList:

ArrayList<String> myPlaces = new ArrayList(Arrays.asList(places));

Okej, ale w przyszłości potrzebujesz czegoś więcej niż tylko nazwy miejsca, potrzebujesz też kodu kraju. Zakładając, że jest to wciąż predefiniowana lista, która nigdy się nie zmieni w czasie wykonywania, wówczas można użyć enumzestawu, który wymagałby ponownej kompilacji, gdyby lista musiała zostać zmieniona w przyszłości.

enum Places {BUENOS_AIRES, CORDOBA, LA_PLATA}

stanie się:

enum Places {
    BUENOS_AIRES("Buenos Aires",123),
    CORDOBA("Córdoba",456),
    LA_PLATA("La Plata",789);

    String name;
    int code;
    Places(String name, int code) {
      this.name=name;
      this.code=code;
    }
}

Wyliczenia mają valuesmetodę statyczną , która zwraca tablicę zawierającą wszystkie wartości wyliczenia w kolejności, w jakiej zostały zadeklarowane, np .:

for (Places p:Places.values()) {
    System.out.printf("The place %s has code %d%n",
                  p.name, p.code);
}

W takim przypadku myślę, że nie potrzebujesz swojej ArrayList.

PS Randyaa zademonstrował inny fajny sposób przy użyciu statycznej metody użytkowej Collections.addAll .

Java 9 ma następującą metodę utworzenia niezmiennej listy:

List<String> places = List.of("Buenos Aires", "Córdoba", "La Plata");

który można łatwo dostosować do tworzenia listy zmiennych, jeśli jest to wymagane:

List<String> places = new ArrayList<>(List.of("Buenos Aires", "Córdoba", "La Plata"));

Podobne metody są dostępne dla Seti Map.

List<String> names = Arrays.asList("2","@2234","21","11");

Tak, za pomocą tablic możesz zainicjalizować listę tablic w jednym wierszu,

List<String> strlist= Arrays.asList("aaa", "bbb", "ccc");

Możesz używać StickyListz Cactoos :

List<String> names = new StickyList<>(
  "Scott Fitzgerald", "Fyodor Dostoyevsky"
);

Spróbuj użyć tej linii kodu:

Collections.singletonList(provider)

W Javie nie możesz tego zrobić

ArrayList<String> places = new ArrayList<String>( Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

Jak już wspomniano, należy wykonać inicjalizację podwójnego nawiasu klamrowego:

List<String> places = new ArrayList<String>() {{ add("x"); add("y"); }};

Ale może to zmusić Cię do dodania adnotacji @SuppressWarnings("serial") lub wygenerowania seryjnego UUID, co jest denerwujące. Również większość formatatorów kodu rozpakuje to na wiele instrukcji / linii.

Alternatywnie możesz to zrobić

List<String> places = Arrays.asList(new String[] {"x", "y" });

ale wtedy możesz chcieć zrobić @SuppressWarnings("unchecked") .

Również według javadoc powinieneś być w stanie to zrobić:

List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");

Ale nie jestem w stanie zmusić go do kompilacji z JDK 1.6.

Collections.singletonList(messageBody)

Jeśli musisz mieć listę jednego elementu !

Kolekcje pochodzą z pakietu java.util .

Najlepszy sposób to zrobić:

package main_package;

import java.util.ArrayList;


public class Stackkkk {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<Object>();
        add(list, "1", "2", "3", "4", "5", "6");
        System.out.println("I added " + list.size() + " element in one line");
    }

    public static void add(ArrayList<Object> list,Object...objects){
        for(Object object:objects)
            list.add(object);
    }
}

Wystarczy utworzyć funkcję, która może mieć tyle elementów, ile chcesz i wywołać ją, aby dodać je w jednym wierszu.

Oto kod AbacusUtil

// ArrayList
List<String> list = N.asList("Buenos Aires", "Córdoba", "La Plata");
// HashSet
Set<String> set = N.asSet("Buenos Aires", "Córdoba", "La Plata");
// HashMap
Map<String, Integer> map = N.asMap("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);

// Or for Immutable List/Set/Map
ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);

// The most efficient way, which is similar with Arrays.asList(...) in JDK. 
// but returns a flexible-size list backed by the specified array.
List<String> set = Array.asList("Buenos Aires", "Córdoba", "La Plata");

Deklaracja ： Jestem programistą AbacusUtil.

Dla mnie Arrays.asList () jest najlepszy i wygodny. Zawsze lubię inicjować w ten sposób. Jeśli jesteś początkującym w kolekcji Java, chciałbym, abyś polecił inicjalizację ArrayList

Dlaczego nie zrobić prostej funkcji narzędziowej, która to robi?

static <A> ArrayList<A> ll(A... a) {
  ArrayList l = new ArrayList(a.length);
  for (A x : a) l.add(x);
  return l;
}

„ ll” oznacza „dosłowną listę”.

ArrayList<String> places = ll("Buenos Aires", "Córdoba", "La Plata");

co ciekawe, nie wymieniono jednej linijki z drugą metodą przeciążeniaStream::collect

ArrayList<String> places = Stream.of( "Buenos Aires", "Córdoba", "La Plata" ).collect( ArrayList::new, ArrayList::add, ArrayList::addAll );

W rzeczywistości można to zrobić w jednym wierszu:

Arrays.asList(new MyClass[] {new MyClass("arg1"), new MyClass("arg2")})