实际上，初始化ArrayList的“最佳”方法可能是您编写的方法，因为它不需要以任何方式创建新的List：

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

问题在于，引用该列表实例需要大量的输入。

还有其他方法，例如使用实例初始化器（也称为“双括号初始化”）创建匿名内部类：

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

然而，我并不太喜欢这个方法，因为你最终得到的是ArrayList的一个子类，它有一个实例初始化器，而创建这个类只是为了创建一个对象——这在我看来有点过分。

如果Project Coin的Collection Literals提案被接受（它计划在Java 7中引入，但也不太可能是Java 8的一部分），那将是一件好事

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

不幸的是，它在这里对您没有帮助，因为它将初始化一个不可变的List，而不是ArrayList，此外，它还不可用，如果可能的话。

如果您只是将其声明为List，这会更简单——它必须是ArrayList吗？

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

或者如果您只有一个元素：

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

这意味着位置是不可变的（尝试更改它将导致引发UnsupportedOperationException异常）。

要创建一个可变列表，即一个具体的ArrayList，您可以从不可变列表中创建一个ArrayList：

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

并导入正确的软件包：

import java.util.Arrays;

您可以创建工厂方法：

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

但这并不比第一次重构好多少。

为了获得更大的灵活性，它可以是通用的：

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

import com.google.common.collect.ImmutableList;

....

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

简单的答案

Java 9或更高版本：

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

这将为您提供一个不可变的列表，因此无法更改。在大多数情况下，这就是你想要的。

Java 8或更早版本：

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

这将为您提供一个由数组支持的List*，因此它不能更改长度。但是您可以调用List.set（…），所以它仍然是可变的。

*实现细节：它是java.util.Arrays内部的一个私有嵌套类，名为ArrayList，这是一个与java.util.ArrayList不同的类，尽管它们的简单名称相同。

静态导入

您可以通过静态导入使Java 8 Arrays.asList更短：

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

任何现代IDE*都会为您建议并执行此操作。

我不建议静态地导入List.of方法，因为它会令人困惑。

*例如，在IntelliJ IDEA中，按Alt+Enter并选择静态导入方法。。。

使用流

为什么必须是列表？对于Java 8或更高版本，您可以使用更灵活的Stream：

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

您可以连接流：

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

或者您可以从“流”转到“列表”：

import static java.util.stream.Collectors.toList;
...
var strings = Stream.of("foo", "bar", "baz").toList(); // Java 16

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

但最好只使用流而不将其收集到列表中。

如果您特别需要java.util.ArrayList*

如果要预先填充ArrayList并在之后添加到其中，请使用

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

或Java 8或更早版本：

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

或使用流：

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

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

但同样，最好直接使用流，而不是将其收集到列表中。

*您可能不需要特别的ArrayList。引用JEP 269：

使用预定义的值集初始化可变集合实例有一小组用例。通常最好将这些预定义的值放在不可变集合中，然后通过复制构造函数初始化可变集合。

（强调矿井）

程序到接口，而不是实现

您说过您已经在代码中将列表声明为ArrayList，但只有当您使用的ArrayList的某个成员不在list中时，才应该这样做。

这是你最可能不做的。

通常，您应该只通过要使用的最通用的接口（例如Iterable、Collection或List）声明变量，并使用特定的实现（例如ArrayList、LinkedList或Arrays.asList（））初始化它们。

否则，您将代码限制为特定类型，并且在需要更改时将更难更改。

例如，如果要将ArrayList传递给void方法（…）：

// 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 random access, .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
}

另一个例子是总是将变量声明为InputStream，即使它通常是FileInputStream或BufferedInputStream，因为很快有一天你或其他人会想要使用其他类型的InputStream。

如果您需要大小为1的简单列表：

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

如果需要多个对象的列表：

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

在Java中，您无法做到

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

如前所述，您需要执行双括号初始化：

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

但这可能会迫使您添加注释@SuppressWarnings（“串行”）或生成一个令人讨厌的串行UUID。大多数代码格式化程序也会将其展开为多个语句/行。

或者你也可以这样做

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

但您可能需要执行@SuppressWarnings（“未选中”）。

此外，根据javadoc，您应该能够做到这一点：

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

但我无法用JDK1.6编译它。

public static <T> List<T> asList(T... a) {
    return new ArrayList<T>(a);
}

这是Arrays.asList的实现，因此您可以使用

ArrayList<String> arr = (ArrayList<String>) Arrays.asList("1", "2");

实际上，可以在一行中完成：

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

（应该是评论，但太长了，所以是新回复）。正如其他人所提到的，Arrays.asList方法是固定大小的，但这并不是它唯一的问题。它也不能很好地处理继承。例如，假设您有以下内容：

class A{}
class B extends A{}

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

上述结果导致编译器错误，因为List<B>（这是Arrays.asList返回的）不是List<a>的子类，即使您可以将类型B的object添加到List<a>object。要解决此问题，您需要执行以下操作：

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

这可能是实现这一点的最佳方式，特别是如果您需要无边界列表或需要使用继承。

正如汤姆所说：

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

但是，既然你抱怨想要一个ArrayList，你应该首先知道ArrayList是List的一个子类，你可以简单地添加这一行：

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

不过，这可能会让你抱怨“表现”。

在这种情况下，这对我来说没有意义，为什么，因为您的列表是预定义的，所以它没有被定义为数组（因为在初始化时大小是已知的）。如果这是你的选择：

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

如果您不关心细微的性能差异，那么您也可以非常简单地将数组复制到ArrayList：

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

好吧，但未来你需要的不仅仅是地名，还需要国家代码。假设这仍然是一个预定义的列表，在运行时不会更改，那么使用枚举集是合适的，如果将来需要更改列表，则需要重新编译。

enum Places {BUENOS_AIRES, CORDOBA, LA_PLATA}

将变成：

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

枚举有一个静态值方法，该方法返回一个数组，该数组按声明顺序包含枚举的所有值，例如：

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

在这种情况下，我想你不需要你的ArrayList。

P.S.Randyaa演示了使用静态实用程序方法Collections.addAll的另一种好方法。

使用Guava，您可以写：

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

在Guava中还有其他有用的静态构造函数。你可以在这里了解他们。

只需使用以下代码即可。

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

集合文本并没有进入Java 8，但可以使用流API在一行中初始化列表：

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

如果您需要确保列表是ArrayList：

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

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

对我来说，Arrays.asList（）是最好且方便的方法。我总是喜欢这样初始化。如果您是Java集合的初学者，那么我希望您参考ArrayList初始化

最简单的方法是：

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

使用Eclipse集合，您可以编写以下内容：

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

您还可以更具体地了解类型，以及它们是可变的还是不可变的。

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

您也可以对套装和包进行同样的操作：

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

注意：我是Eclipse集合的提交人。

Collections.singletonList(messageBody)

如果您需要一个项目列表！

集合来自java.util包。

尝试使用以下代码行：

Collections.singletonList(provider)

最好的方法是：

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

只需创建一个可以包含任意多个元素的函数，并调用它将它们添加到一行中即可。

是的，借助数组，您可以在一行中初始化数组列表，

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

这是算盘常见的代码

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

声明：我是算盘通用的开发者。

Java 9有以下方法来创建不可变列表：

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

如果需要，它很容易适于创建可变列表：

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

类似的方法可用于“集”和“贴图”。

对于java-9和更高版本，正如JEP269：集合的便利工厂方法中所建议的，这可以使用集合文本实现，现在使用-

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

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

类似的方法也适用于Map-

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

这与@coobird所述的“收藏文字”提案类似。JEP中也有进一步澄清-

---

选择

语言更改已被考虑过多次，但均被拒绝：项目硬币提案，2009年3月29日项目硬币提案，2009年3月30日JEP 186关于lambda开发的讨论，2014年1月至3月语言建议被搁置，而不是基于图书馆的建议，因为此消息中总结。

相关：在Java9中重载集合的便利工厂方法有什么意义

还有一种方法：

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

您可以使用以下语句：

代码段：

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

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

您可以使用Cactoos中的粘滞列表：

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

在Java 9中，我们可以很容易地在一行中初始化ArrayList：

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

or

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

Java 9的这种新方法与以前的方法相比有许多优点：

空间效率不可变性线程安全

有关更多详细信息，请参阅本文->List.of和Arrays.asList之间的区别是什么？

为什么不做一个简单的实用函数来实现这一点呢？

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

“ll”代表“文字列表”。

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

有趣的是，没有列出带有另一个重载Stream:：collect方法的一行

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

使用Array.asList（“布宜诺斯艾利斯”、“科尔多瓦”、“拉普拉塔”）；是正确的。但任何对Arrays.asList（）的调用如果没有参数或只有一个参数，都可以用对Collections.singletonList（）或Collections.emptyList（）进行替换，这样可以节省一些内存。

注意：Collections.singletonList（）返回的列表是不可变的，而列表返回的Arrays.asList（）允许调用set（）方法。在极少数情况下，这可能会破坏代码。

最简单的方法：可以使用此方法向任意类型的集合（如ArrayList和HashSet）添加多个元素

ArrayList<String> allViews = new ArrayList<String>();
Collections.addAll(allViews,"hello","world","abc","def","ghi");

有多种方法可以在一行中创建和初始化列表。

    //Using Double brace initialization
    List<String> list1 = new ArrayList<>() {{ add("A");  add("B"); }};
    
    //Immutable List
    List<String> list2 = List.of("A", "B");

    //Fixed size list. Can't add or remove element, though replacing the element is allowed.
    List<String> list3 = Arrays.asList("A", "B");

    //Modifiable list
    List<String> list4 = new ArrayList<>(Arrays.asList("A", "B"));

    //Using Java Stream
    List<String> list5 = Stream.of("A", "B").collect(Collectors.toList());

    //Thread safe List
    List<String> list6 = new CopyOnWriteArrayList<>(Arrays.asList("A", "B"));