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?

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.

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

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.

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

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 .

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

Mit Java-9und 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?

import com.google.common.collect.ImmutableList;

....

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

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

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?

Der kompakteste Weg, dies zu tun, ist:

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

Verwenden Sie einfach den folgenden Code wie folgt.

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

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.

Hier ist ein anderer Weg:

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

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

Sie können die folgenden Anweisungen verwenden:

Code-Auszug:

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

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

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 .

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.

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

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

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

Sie können StickyListvon Cactoos verwenden :

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

Versuchen Sie es mit dieser Codezeile:

Collections.singletonList(provider)

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.

Collections.singletonList(messageBody)

Wenn Sie eine Liste mit einem Artikel benötigen !

Sammlungen stammen aus dem Paket java.util .

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.

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.

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

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

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

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

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