Initialisierung einer ArrayList in einer Zeile

2756

Ich wollte eine Liste von Optionen zu Testzwecken erstellen. Zuerst habe ich das gemacht:

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

Dann habe ich den Code wie folgt überarbeitet:

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

Gibt es einen besseren Weg, dies zu tun?

Makrig
quelle
34
Wenn dies für Unit-Tests vorgesehen ist, versuchen Sie es mit einer Schaukel. Sie können Ihren ArrasyList<String> places = ["Buenos Aires", "Córdoba", "La Plata"]
Testcode darin
3
In Java SE 7 können Sie den parametrisierten Typ des Konstruktors durch einen leeren Satz von Typparametern (<>) ersetzen: Map <String, List <String >> myMap = new HashMap <> ();
Rose
2
Verwenden Sie die doppelte Klammerinitialisierung :)
Mohammadreza Khatami
8
Stream.of ("val1", "val2"). Collect (Collectors.toList ()); // erstellt ArrayList, Java8-Lösung.
Torina

Antworten:

2025

Wahrscheinlich ArrayListist die von Ihnen geschriebene Methode die "beste" Methode zum Initialisieren der Methode, da sie Listin keiner Weise eine neue erstellen muss :

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

Der Haken ist, dass einiges an Eingabe erforderlich ist, um auf diese listInstanz zu verweisen .

Es gibt Alternativen, z. B. das Erstellen einer anonymen inneren Klasse mit einem Instanzinitialisierer (auch als "Double-Brace-Initialisierung" bezeichnet):

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

Ich mag diese Methode jedoch nicht besonders, da Sie am Ende eine Unterklasse haben, ArrayListdie einen Instanzinitialisierer hat, und diese Klasse nur erstellt wird, um ein Objekt zu erstellen - das scheint mir nur ein bisschen übertrieben zu sein.

Was schön gewesen wäre, wäre, wenn der Vorschlag für Sammlungsliterale für Project Coin angenommen worden wäre (er sollte in Java 7 eingeführt werden, ist aber wahrscheinlich auch nicht Teil von Java 8.):

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

Leider hilft es Ihnen hier nicht weiter, da es Listeher eine unveränderliche als eine initialisiert ArrayListund darüber hinaus noch nicht verfügbar ist, falls dies jemals der Fall sein wird.

Coobird
quelle
172
Weitere Informationen zur Doppelklammerinitialisierung sowie zu den Vor- und Nachteilen finden Sie unter stackoverflow.com/questions/924285 .
Eddie
6
@Eddie: Guter Aufruf für den Link - ein Satz zur Initialisierung in doppelten Klammern reicht nicht aus, um ihn vollständig zu beschreiben.
Coobird
2
Funktioniert nur, wenn Sie sich nicht auf Auto Boxing verlassen. List <Double> list = [1.0, 2.0, 3.0]; schlägt fehl.
Richard B
1
Sie vermissen ein Semikolon auf der Doppellisteninitialisierung
Don Larynx
6
Da diese Antwort die am besten bewertete und erwähnte Projektmünze ist, sollten Sie Java 9 mit der Syntax List.of (...) ausrufen: docs.oracle.com/javase/9/docs/api/java/util/ List.html # of-E ...-
Asaf
2155

Es wäre einfacher, wenn Sie es einfach als List- deklarieren müssten, muss es eine ArrayList sein?

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

Oder wenn Sie nur ein Element haben:

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

Dies würde bedeuten , dass placesist unveränderlich (versucht es eine verursacht zu ändern UnsupportedOperationExceptionAusnahme ausgelöst werden).

Um eine veränderbare Liste zu ArrayListerstellen, die konkret ist , können Sie ArrayListaus der unveränderlichen Liste eine erstellen :

ArrayList<String> places = new ArrayList<>(Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));
Tom
quelle
18
@Marcase: Können Sie Ihre Klasse nicht so ändern, dass eine Liste anstelle von ArrayList verwendet wird?
Lawrence Dol
74
Laut meiner Antwort ist ArrayListes besser, die Deklaration in zu ändern , wenn Sie keine spezifischen Methoden verwenden List. Geben Sie Schnittstellen an, keine Implementierungen.
Christoffer Hammarström
9
@Christoffer Hammarström: Wenn er die Deklaration in List ändert und List <String> verwendet, setzt Places = Arrays.asList (...); Er wird nicht in der Lage sein, sites.add ("blabla") zu verwenden
macht den
57
Um ganz klar zu sein, wird asList(...)eine feste Größe zurückgegeben List, die bei mutierenden Vorgängen wie removeund clear, Dinge, die der ListVertrag zu unterstützen behauptet, in die Luft sprengt . Selbst wenn Sie die Deklaration als belassen haben List, müssen Sie sie verwenden List l = new ArrayList(asList(...)), um ein Objekt zu erhalten, das keine OperationNotSupported-Ausnahmen auslöst. Liskov Substitutionsprinzip jemand?
Splash
5
@Splash: removeund clearsind optionale Operationen in List, asList(...)folgen also dem Vertrag. Nirgendwo sagt das OP, dass er später weitere Elemente hinzufügen muss. Das Beispiel ist nur ein Beispiel, das Listmit drei Elementen initialisiert werden muss.
Christoffer Hammarström
872

Die einfache Antwort

In Java 9 oder höher wurde danach List.of()hinzugefügt:

List<String> strings = List.of("foo", "bar", "baz");

Mit Java 10 oder höher kann dies mit dem varSchlüsselwort gekürzt werden .

var strings = List.of("foo", "bar", "baz");

Dies gibt Ihnen eine unveränderliche List , so dass es nicht geändert werden kann.
Welches ist, was Sie in den meisten Fällen wollen, in denen Sie es vorab ausfüllen.


Java 8 oder früher:

List<String> strings = Arrays.asList("foo", "bar", "baz");

Dadurch erhalten Sie eine ListUnterstützung durch ein Array, sodass die Länge nicht geändert werden kann.
Aber du kannst anrufen List.set, also ist es immer noch veränderlich .


Arrays.asListMit einem statischen Import können Sie noch kürzer machen :

List<String> strings = asList("foo", "bar", "baz");

Der statische Import:

import static java.util.Arrays.asList;  

Was jede moderne IDE vorschlägt und automatisch für Sie erledigt.
Zum Beispiel drücken Sie in IntelliJ IDEA Alt+Enterund wählen Static import method....


Ich empfehle jedoch nicht, die List.ofMethode auf zu verkürzen of, da dies verwirrend wird.
List.ofist schon kurz genug und liest sich gut.


Mit Streams

Warum muss es ein sein List?
Mit Java 8 oder höher können Sie ein Streamflexibleres verwenden:

Stream<String> strings = Stream.of("foo", "bar", "baz");

Sie können Streams verketten :

Stream<String> strings = Stream.concat(Stream.of("foo", "bar"),
                                       Stream.of("baz", "qux"));

Oder Sie können von a Streamnach a gehen List:

import static java.util.stream.Collectors.toList;

List<String> strings = Stream.of("foo", "bar", "baz").collect(toList());

Verwenden Sie das Gerät jedoch vorzugsweise, Streamohne es zu sammeln List.


Wenn Sie wirklich speziell eine brauchenjava.util.ArrayList

(Wahrscheinlich nicht.)
Um JEP 269 zu zitieren (Hervorhebung von mir):

Es gibt eine kleine Reihe von Anwendungsfällen zum Initialisieren einer veränderlichen Auflistungsinstanz mit einer vordefinierten Reihe von Werten. Normalerweise ist es vorzuziehen, diese vordefinierten Werte in einer unveränderlichen Sammlung zu haben und dann die veränderbare Sammlung über einen Kopierkonstruktor zu initialisieren.


Wenn Sie möchten sowohl vorab ausgefüllt ein ArrayList und fügen Sie danach (warum?), Nutzung

ArrayList<String> strings = new ArrayList<>(List.of("foo", "bar"));
strings.add("baz");

oder in Java 8 oder früher:

ArrayList<String> strings = new ArrayList<>(asList("foo", "bar"));
strings.add("baz");

oder mit Stream:

import static java.util.stream.Collectors.toCollection;

ArrayList<String> strings = Stream.of("foo", "bar")
                             .collect(toCollection(ArrayList::new));
strings.add("baz");

Aber auch hier ist es besser, das Streamdirekt zu verwenden, als es zu einem zu sammeln List.


Programmieren Sie auf Schnittstellen, nicht auf Implementierungen

Sie sagten, Sie hätten die Liste als ArrayListin Ihrem Code deklariert , aber Sie sollten dies nur tun, wenn Sie ein Mitglied verwenden ArrayList, das nicht in enthalten ist List.

Was Sie höchstwahrscheinlich nicht tun.

Normalerweise sollten Sie nur Variablen deklarieren durch die allgemeinste Schnittstelle , die Sie verwenden möchten (zB Iterable, Collectionoder List) und initialisieren sie mit der konkreten Umsetzung (zB ArrayList, LinkedListoder Arrays.asList()).

Andernfalls beschränken Sie Ihren Code auf diesen bestimmten Typ, und es ist schwieriger, ihn zu ändern, wenn Sie möchten.

Wenn Sie beispielsweise ein ArrayListan ein übergeben 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
}

Ein anderes Beispiel wäre, immer eine Variable zu deklarieren, InputStreamobwohl es normalerweise eine FileInputStreamoder eine ist BufferedInputStream, weil Sie oder jemand anderes eines Tages bald eine andere Art von verwenden möchten InputStream.

Christoffer Hammarström
quelle
3
@jollyroger: Arrays.asListist eine statische Methode. Siehe docs.oracle.com/javase/1.5.0/docs/guide/language/…
Christoffer Hammarström
2
@ ChristofferHammarström In diesem Fall sagt mir mein Anfänger, dass der statische Import eine starke Ähnlichkeit mit globalen Variablen und den Gefahren aufweist, die mit einer solchen Verwendung verbunden sind. Ist diese Annahme richtig und ist es auch der Grund dafür, dass die oben genannte ähnliche Antwort mehr Stimmen erhält?
Jollyroger
2
Die Antwort oben, von der ich denke, dass Sie sprechen, wurde ein Jahr zuvor gemacht. Und nein, das Problem mit globalen Variablen ist, dass sie veränderlich sind. Sie haben nichts mit statischen Importen zu tun.
Christoffer Hammarström
2
Wenn Sie den statischen Import nicht möchten, können Sie auch den vollständigen Pfad zur statischen asList-Methode definieren: List <String> strings = java.util.Arrays.asList ("", "");
Geert Weening
2
Oder Sie können import java.util.Arrays verwenden. und Arrays.asList ("", ""); Sie müssen keinen statischen Import verwenden. Sie müssen keinen vollständigen Pfad verwenden. Statische Methoden kümmern sich nicht um den Import. Sie ärgern sich nur, wenn Sie eine Instanz verwenden, um sie zu finden.
candied_orange
111

Wenn Sie eine einfache Liste der Größe 1 benötigen:

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

Wenn Sie eine Liste mit mehreren Objekten benötigen:

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

Mit Guava können Sie schreiben:

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

In Guava gibt es auch andere nützliche statische Konstruktoren. Sie können über sie lesen hier .

Paweł Adamski
quelle
1
Ich bin mir ziemlich sicher, dass Sie dies mit so etwas java.util.ArrayswieList<String> names = Arrays.asList("Beckah", "Sam", "Michael");
Beckah
2
@ Beckah Methode Arrays.asLists erstellt Objekt vom Typ List, während Frage über die Erstellung von ArrayList
Paweł Adamski
34

Sammlungsliterale haben es nicht in Java 8 geschafft, aber es ist möglich, die Stream-API zu verwenden, um eine Liste in einer ziemlich langen Zeile zu initialisieren:

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

Wenn Sie müssen sicherstellen , dass Ihr Listeine ist ArrayList:

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

Mit und höher, wie in JEP 269: Convenience Factory-Methoden für Sammlungen vorgeschlagen , könnte dies mit Sammlungsliteralen erreicht werden, die jetzt mit -

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

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

Ein ähnlicher Ansatz würde auch gelten für Map-

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

Dies ähnelt dem von @coobird angegebenen Vorschlag für Sammlungsliterale . Weiter im JEP geklärt -


Alternativen

Sprachänderungen wurden mehrfach berücksichtigt und abgelehnt:

Projektmünzvorschlag, 29. März 2009

Projektmünzvorschlag, 30. März 2009

JEP 186 Diskussion über Lambda-Dev, Januar-März 2014

Die Sprachvorschläge wurden einem bibliotheksbasierten Vorschlag, wie in dieser Nachricht zusammengefasst, vorgezogen.

Verwandte Themen: Was ist der Sinn überladener Convenience Factory-Methoden für Sammlungen in Java 9?

Naman
quelle
31
import com.google.common.collect.ImmutableList;

....

List<String> places = ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");
George
quelle
4
Ich möchte keine neue Abhängigkeit hinzufügen, nur um das zu tun.
Macarse
6
Das ist das gleiche wie Collections.unmodifiableList(Arrays.asList("Buenos Aires", "Córdoba", "La Plata")), das wird unmodifiableList(asList("Buenos Aires", "Córdoba", "La Plata"))mit statischen Importen. Sie benötigen dafür keine Google-Sammlungen.
Christoffer Hammarström
9
Nein, es ist nicht dasselbe. Da ImmutableList seine Unveränderlichkeit im Ergebnistyp dokumentiert, wenn unmodizableList es als normale Liste tarnt.
David Pierre
2
Anstelle der unveränderlichen bieten Google-Sammlungen auch eine veränderbare Array-Liste: List <String> = Lists.newArrayList ("Buenos Aires", "Córdoba", "La Plata");
L. Holanda
3
Sie werden das ImmutableListan andere Methoden weitergeben, die a benötigen List, und dann haben Sie diese Dokumentation trotzdem verloren.
Christoffer Hammarström
23

Sie können eine Factory-Methode erstellen:

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");

Aber es ist nicht viel besser als dein erstes Refactoring.

Für mehr Flexibilität kann es generisch sein:

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
quelle
1
Schauen Sie sich den ursprünglichen Beitrag noch einmal an. Er fordert die Array-Initialisierung in einer Zeile an , nicht in 7 zusätzlichen Zeilen.
L. Holanda
7
@LeoHolanda: Ich stimme zu, dass es zu viel ist, Factory-Methoden für jede Kleinigkeit zu erstellen. Aber je nach Situation und auf der Anzahl der Male , dass diese Methode verwendet werden soll, könnte es Sinn machen , es zu schaffen. Erstellen von zusätzlichen Abstraktionsschichten sollte entfernen Komplexität, durch die Schaffung von mehr sinnvoll , dass der Fang der Methoden Absicht des Designers.
Jordão
16

In Java 9 können wir ein einfach ArrayListin einer einzelnen Zeile initialisieren :

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

oder

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

Dieser neue Ansatz von Java 9 hat viele Vorteile gegenüber den vorherigen:

  1. Raumeffizienz
  2. Unveränderlichkeit
  3. Thread sicher

Weitere Informationen finden Sie in diesem Beitrag -> Was ist der Unterschied zwischen List.of und Arrays.asList?

Mohit Tyagi
quelle
8

Der kompakteste Weg, dies zu tun, ist:

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

Verwenden Sie einfach den folgenden Code wie folgt.

List<String> list = new ArrayList<String>() {{
            add("A");
            add("B");
            add("C");
}};
user2801794
quelle
2
@bsd Mit dieser Methode können Sie die Liste deklarieren, bevor Sie eine Methode eingeben. Wenn Sie also Klassenvariablen definieren, können Sie der Liste Inhalte hinzufügen, ohne eine Methode aufrufen zu müssen.
Melwil
2
Die Initialisierung von Doppelklammern sollte so weit wie möglich vermieden werden. siehe: stackoverflow.com/a/924326/760393
Raúl
8

Mit Eclipse Collections können Sie Folgendes schreiben:

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

Sie können auch genauer festlegen, welche Typen veränderlich oder unveränderlich sind.

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

Sie können dasselbe auch mit Sets und Taschen tun:

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");

Hinweis: Ich bin ein Committer für Eclipse-Sammlungen.

Donald Raab
quelle
7

Hier ist ein anderer Weg:

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

(Sollte ein Kommentar sein, aber zu lang, also neue Antwort). Wie andere bereits erwähnt haben, hat die Arrays.asListMethode eine feste Größe, aber das ist nicht das einzige Problem. Es geht auch nicht sehr gut mit Vererbung um. Angenommen, Sie haben Folgendes:

class A{}
class B extends A{}

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

Das Obige führt zu einem Compilerfehler, da List<B>(was von Arrays.asList zurückgegeben wird) keine Unterklasse von ist List<A>, obwohl Sie einem List<A>Objekt Objekte vom Typ B hinzufügen können . Um dies zu umgehen, müssen Sie Folgendes tun:

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

Dies ist wahrscheinlich der beste Weg, dies zu tun, insb. Wenn Sie eine unbegrenzte Liste benötigen oder Vererbung verwenden müssen.

user439407
quelle
6

Sie können die folgenden Anweisungen verwenden:

Code-Auszug:

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

List<String> names = Arrays.asList(arr);
Rashedcs
quelle
Sie können den ersten Ausdruck inline setzen, um eine kompakte Lösung zu erhalten:letters = Arrays.asList(new String[]{"A", "B", "C"});
Pavel Repin
5

Wie Tom sagte :

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

Da Sie sich jedoch darüber beschwert haben, eine ArrayList zu wollen, sollten Sie zunächst wissen, dass ArrayList eine Unterklasse von List ist, und Sie können einfach diese Zeile hinzufügen:

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

Dies könnte Sie jedoch dazu bringen, sich über die Leistung zu beschweren.

In diesem Fall macht es für mich keinen Sinn, warum Ihre Liste, da sie vordefiniert ist, nicht als Array definiert wurde (da die Größe zum Zeitpunkt der Initialisierung bekannt ist). Und wenn das eine Option für Sie ist:

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

Wenn Sie sich nicht um die geringfügigen Leistungsunterschiede kümmern, können Sie ein Array auch ganz einfach in eine ArrayList kopieren:

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

Okay, aber in Zukunft brauchen Sie ein bisschen mehr als nur den Ortsnamen, Sie brauchen auch einen Ländercode. Angenommen, dies ist immer noch eine vordefinierte Liste, die sich zur Laufzeit nie ändert, dann ist es angebracht, einen enumSatz zu verwenden, der neu kompiliert werden muss, wenn die Liste in Zukunft geändert werden muss.

enum Places {BUENOS_AIRES, CORDOBA, LA_PLATA}

würde werden:

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;
    }
}

Aufzählungen haben eine statische valuesMethode, die ein Array zurückgibt, das alle Werte der Aufzählung in der Reihenfolge enthält, in der sie deklariert sind, z.

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

In diesem Fall würden Sie Ihre ArrayList wohl nicht benötigen.

PS Randyaa demonstrierte einen anderen guten Weg mit der statischen Dienstprogrammmethode Collections.addAll .

Ozzy
quelle
5

Java 9 verfügt über die folgende Methode zum Erstellen einer unveränderlichen Liste:

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

die leicht angepasst werden kann, um bei Bedarf eine veränderbare Liste zu erstellen:

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

Ähnliche Methoden stehen für Setund zur Verfügung Map.

user85421
quelle
1
Es ist gut, dass Sie explizit "unveränderliche Liste" gesagt und dann ein weiteres Beispiel für eine veränderbare Liste gezeigt haben, weil dadurch klar wird, welche wann verwendet werden soll.
Cherit
4
List<String> names = Arrays.asList("2","@2234","21","11");
Ran Adler
quelle
4

Ja, mit Hilfe von Arrays können Sie die Array-Liste in einer Zeile initialisieren.

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

Sie können StickyListvon Cactoos verwenden :

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

Versuchen Sie es mit dieser Codezeile:

Collections.singletonList(provider)
Ant20
quelle
1
Fügen Sie eine kurze Beschreibung Ihrer Antwort hinzu.
Morales Batovski
2

In Java ist das nicht möglich

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

Wie bereits erwähnt, müssen Sie eine doppelte Klammerinitialisierung durchführen:

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

Dies kann Sie jedoch dazu zwingen, eine Anmerkung hinzuzufügen @SuppressWarnings("serial")oder eine serielle UUID zu generieren, was ärgerlich ist. Außerdem werden die meisten Code-Formatierer dies in mehrere Anweisungen / Zeilen auspacken.

Alternativ können Sie tun

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

aber dann möchten Sie vielleicht eine machen @SuppressWarnings("unchecked").

Auch laut Javadoc sollten Sie dazu in der Lage sein:

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

Aber ich kann es nicht mit JDK 1.6 kompilieren.

Dawg
quelle
5
Falsch! Sie können die erste Zeile machen, und das ist die richtige Antwort übrigens
Bohemian
1
Collections.singletonList(messageBody)

Wenn Sie eine Liste mit einem Artikel benötigen !

Sammlungen stammen aus dem Paket java.util .

ViliusK
quelle
1

Der beste Weg, es zu tun:

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);
    }
}

Erstellen Sie einfach eine Funktion, die beliebig viele Elemente enthalten kann, und rufen Sie sie auf, um sie in einer Zeile hinzuzufügen.

Charif DZ
quelle
1
Wenn Sie alle Probleme haben, können Sie es auch zu einer Vorlagenmethode machen, anstatt einfach zu verwenden Object.
Robert
1

Hier ist Code von 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");

Erklärung: Ich bin der Entwickler von AbacusUtil.

user_3380739
quelle
0

Für mich ist Arrays.asList () die beste und bequemste. Ich initialisiere immer gerne so. Wenn Sie ein Anfänger in Java-Sammlungen sind, möchte ich, dass Sie auf die ArrayList-Initialisierung verweisen

Manoj Kumar
quelle
Warum ist Arrays.asList () besser als das Erstellen einer neuen ArrayList in einer Zeile mit add()Methoden?
IgorGanapolsky
0

Warum nicht eine einfache Utility-Funktion erstellen, die dies tut?

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

" ll" steht für "wörtliche Liste".

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

Interessanterweise ist kein Einzeiler mit der anderen überladenen Stream::collect Methode aufgeführt

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

Eigentlich ist es möglich, dies in einer Zeile zu tun:

Arrays.asList(new MyClass[] {new MyClass("arg1"), new MyClass("arg2")})
Adrian
quelle
3
Darf ich fragen, was dies zu der Frage beiträgt? Diese Antwort wird bereits mehrfach durch andere Antworten abgedeckt.
Mysticial
Dies ist eigentlich eine wirklich schlechte Lösung, da sie eine ZUSAMMENFASSUNGSLISTE erstellt. Sie können dem Container nichts mehr hinzufügen.
Atais