Inicjalizacja ArrayList w jednym wierszu

2755

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?

Makaron
źródło
34
Jeśli jest to przeznaczone do testów jednostkowych, wypróbuj groovy na huśtawkę. Możesz napisać w nim kod testowy podczas testowania kodu Java i użyćArrasyList<String> places = ["Buenos Aires", "Córdoba", "La Plata"]
ripper234
3
W Java SE 7 można zastąpić sparametryzowany typ konstruktora pustym zestawem parametrów typu (<>): Map <String, List <String>> myMap = new HashMap <> ();
Rose
2
Zobacz także stackoverflow.com/questions/157944/create-arraylist-from-array
Christoffer Hammarström
2
użyj podwójnej inicjalizacji stężeń :)
Mohammadreza Khatami
8
Stream.of („val1”, „val2”). Collect (Collectors.toList ()); // tworzy ArrayList, rozwiązanie Java8.
torina

Odpowiedzi:

2024

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.

coobird
źródło
172
Zobacz stackoverflow.com/questions/924285, aby uzyskać więcej informacji na temat inicjalizacji podwójnego nawiasu klamrowego, zalet i wad.
Eddie
6
@Eddie: Dobre wezwanie do linku - jedno zdanie na temat inicjalizacji podwójnego nawiasu nie wystarcza, aby go w pełni opisać.
coobird
2
Działa tylko, jeśli nie polegasz na liście automatycznych boków <lista podwójna> = [1,0, 2,0, 3,0]; zawodzi.
Richard B,
1
Brakuje średnika na inicjalizacji podwójnej listy
Don Larynx
6
Ponieważ ta odpowiedź jest najbardziej popularną i wspomnianą Monetą Projektu, myślę, że powinieneś wezwać, że java 9 została dostarczona ze składnią List.of (...): docs.oracle.com/javase/9/docs/api/java/util/ List.html # of-E ...-
Asaf,
2155

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"));
Tomek
źródło
18
@Marcase: Czy nie możesz zmienić swojej klasy, aby używała listy zamiast ArrayList?
Lawrence Dol
74
Zgodnie z moją odpowiedzią, jeśli nie używasz metod specyficznych dla ArrayList, lepiej byłoby zmienić deklarację na List. Podaj interfejsy, a nie implementacje.
Christoffer Hammarström
9
@Christoffer Hammarström: jeśli zmieni deklarację na List i użyje List <String> places = Arrays.asList (...); nie będzie mógł korzystać z places.add („blabla”)
maks.
57
Żeby było jasne, asList(...)zwraca stały rozmiar, Listktóry wysadza się w wyniku mutacji operacji, takich jak removei clear, rzeczy, które Listkontrakt twierdzi, że obsługuje. Nawet jeśli pozostawiłeś deklarację jako List, nadal musisz użyć List l = new ArrayList(asList(...)), aby uzyskać obiekt, który nie zgłasza wyjątków OperationNotSupported. Liskov Zastępstwo Zasada ktoś?
Splash
5
@Splash: removei clearsą operacjami opcjonalnymi wList , więc asList(...)jest zgodny z umową. Nigdzie PO nie mówi, że musi dodać więcej elementów później, przykład jest po prostu taki List, który należy zainicjować trzema elementami.
Christoffer Hammarström,
871

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.

Christoffer Hammarström
źródło
3
@jollyroger: Arrays.asListjest metodą statyczną. Zobacz docs.oracle.com/javase/1.5.0/docs/guide/language/…
Christoffer Hammarström
2
@ ChristofferHammarström W tym przypadku mój początkujący umysł mówi mi, że import statyczny wykazuje silne podobieństwo do zmiennych globalnych i niebezpieczeństw związanych z takim użyciem. Czy to założenie jest słuszne i czy jest to również powód podobnej odpowiedzi powyżej uzyskania większej liczby głosów?
Jollyroger
2
Powyższa odpowiedź, o której myślę, że została udzielona, ​​została postawiona rok wcześniej. I nie, problem ze zmiennymi globalnymi polega na tym, że można je modyfikować. Nie mają one nic wspólnego z importem statycznym.
Christoffer Hammarström
2
Jeśli nie chcesz importować statycznie, możesz również zdefiniować pełną ścieżkę do statycznej metody asList, tak jak: List <String> strings = java.util.Arrays.asList ("", "");
Geert Weening
2
Lub możesz użyć importu java.util.Arrays; i Arrays.asList („”, „”); Nie musisz używać importu statycznego. Nie musisz używać pełnej ścieżki. Metody statyczne nie dbają o import. Po prostu denerwują się, jeśli używasz instancji, by je znaleźć.
candied_orange
111

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");
Randyaa
źródło
57

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 .

Paweł Adamski
źródło
1
Jestem prawie pewien, że możesz to zrobić za pomocą java.util.Arraystakich, jak:List<String> names = Arrays.asList("Beckah", "Sam", "Michael");
ponieważ
2
Metoda @becka Arrays.asLists tworzy obiekt typu List, a pytanie dotyczy utworzenia ArrayList
Paweł Adamski
34

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));
znak
źródło
34

Z i 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

Naman
źródło
31
import com.google.common.collect.ImmutableList;

....

List<String> places = ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");
Jerzy
źródło
4
Nie chcę dodawać nowej zależności, aby to zrobić.
Macarse
6
To to samo Collections.unmodifiableList(Arrays.asList("Buenos Aires", "Córdoba", "La Plata")), co staje się unmodifiableList(asList("Buenos Aires", "Córdoba", "La Plata"))przy imporcie statycznym. Nie potrzebujesz do tego kolekcji Google.
Christoffer Hammarström,
9
Nie, to nie to samo. Ponieważ ImmutableList dokumentuje swoją niezmienność w typie wyniku, gdy unmodifiableList udaje, że jest to zwykła lista.
David Pierre
2
Zamiast niezmiennego, kolekcje google oferują także zmienną listę tablic: List <String> = Lists.newArrayList („Buenos Aires”, „Córdoba”, „La Plata”);
L. Holanda,
3
Przekażesz to ImmutableListinnym metodom List, a następnie stracisz tę dokumentację.
Christoffer Hammarström
23

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;
}
Jordão
źródło
1
Spójrz wstecz na oryginalny post, prosi o inicjalizację tablicy w jednym wierszu , a nie w 7 dodatkowych wierszach.
L. Holanda,
7
@LeoHolanda: Tworzenie metod fabrycznych dla każdego drobiazgu to zbyt wiele, zgadzam się. Jednak w zależności od sytuacji i liczby przypadków użycia tej metody, sensowne może być jej utworzenie. Tworzenie dodatkowych warstw abstrakcji ma na celu usunięcie złożoności poprzez stworzenie bardziej sensownych metod, które wychwytują intencje projektanta.
Jordão,
16

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?

Mohit Tyagi
źródło
8

Najbardziej kompaktowym sposobem na to jest:

Double array[] = { 1.0, 2.0, 3.0};
List<Double> list = Arrays.asList(array);
Richard B.
źródło
8

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");
}};
użytkownik2801794
źródło
2
@bsd Możesz użyć tej metody do zadeklarowania listy przed wprowadzeniem dowolnej metody. Tak więc podczas definiowania zmiennych klas zawartość można dodawać do listy bez konieczności wywoływania metody.
melwil
2
należy w miarę możliwości unikać inicjalizacji podwójnych nawiasów klamrowych. patrz: stackoverflow.com/a/924326/760393
Raúl
8

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.

Donald Raab
źródło
7

Oto inny sposób:

List<String> values = Stream.of("One", "Two").collect(Collectors.toList());
Henok T.
źródło
7

(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.

użytkownik439407
źródło
6

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

Fragment kodu:

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

List<String> names = Arrays.asList(arr);
rashedcs
źródło
Możesz wstawić pierwsze wyrażenie, aby uzyskać kompaktowe rozwiązanie:letters = Arrays.asList(new String[]{"A", "B", "C"});
Pavel Repin
5

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 .

Ozzy
źródło
5

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.

użytkownik85421
źródło
1
Dobrze, że wyraźnie powiedziałeś „listę niezmienną”, a następnie pokazałeś kolejny przykład listy zmiennych, ponieważ jasno określa, której użyć kiedy.
cherit
4
List<String> names = Arrays.asList("2","@2234","21","11");
Ran Adler
źródło
4

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

List<String> strlist= Arrays.asList("aaa", "bbb", "ccc");
Akash Manngroliya
źródło
4

Możesz używać StickyListz Cactoos :

List<String> names = new StickyList<>(
  "Scott Fitzgerald", "Fyodor Dostoyevsky"
);
yegor256
źródło
3

Spróbuj użyć tej linii kodu:

Collections.singletonList(provider)
Ant20
źródło
1
Dodaj krótki opis swojej odpowiedzi.
Morales Batovski
2

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.

Dawg
źródło
5
Źle! Państwo może zrobić pierwszy wiersz, a to jest właściwą odpowiedź btw
Bohemian
1
Collections.singletonList(messageBody)

Jeśli musisz mieć listę jednego elementu !

Kolekcje pochodzą z pakietu java.util .

ViliusK
źródło
1

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.

Charif DZ
źródło
1
Jeśli przejdziesz wszystkie problemy, możesz równie dobrze uczynić to metodą szablonową, a nie zwykłą Object.
Robert
1

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.

użytkownik_3380739
źródło
0

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

Manoj Kumar
źródło
Dlaczego Arrays.asList () jest lepszy niż tworzenie nowej ArrayList w jednej linii add()metodami?
IgorGanapolsky
0

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");
Stefan Reich
źródło
0

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 );
Kaplan
źródło
-1

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

Arrays.asList(new MyClass[] {new MyClass("arg1"), new MyClass("arg2")})
Adrian
źródło
3
Czy mogę zapytać, co to dodaje do pytania? Ta odpowiedź jest już wielokrotnie pokrywana przez inne odpowiedzi.
Mysticial
To jest naprawdę złe rozwiązanie, ponieważ tworzy LISTĘ STRESZCZENIA. Nie będziesz mógł dodać nic więcej do kontenera.
Atais,