在一行中初始化 ArrayList

Question

我想创建一个用于测试目的的选项列表。 起初，我这样做了：

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

然后，我重构代码如下：

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

有一个更好的方法吗？

Answer 1

如果你只是将它声明为一个List会更简单 - 它必须是 ArrayList 吗？

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

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

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

这意味着places是不可变的（尝试更改它会导致抛出UnsupportedOperationException异常）。

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

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

并导入正确的 package：

import java.util.Arrays;

Answer 2

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

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

要注意的是，引用该list实例需要大量的输入。

还有其他选择，例如使用实例初始化程序（也称为“双括号初始化”）制作匿名内部 class：

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

但是，我不太喜欢这种方法，因为你最终得到的是ArrayList的一个子类，它有一个实例初始化器，而创建 class 只是为了创建一个 object——这对我来说似乎有点矫枉过正.

如果Project Coin的Collection Literals 提议被接受，那就太好了（它计划在 Java 7 中引入，但它也不太可能成为 Java 8 的一部分。）：

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

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

Answer 3

简单的答案

Java 9 或更高版本：

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

这将为您提供一个不可变的List ，因此无法更改。
在预填充它的大多数情况下，这就是您想要的。

Java 8 或更早：

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

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

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

Static 进口

您可以使用 static 导入使 Java 8 Arrays.asList更短：

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

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

我不建议将List.of方法静态导入of ，因为它会造成混淆。

^{*_{例如，在 IntelliJ IDEA 中你按Alt+Enter和 select Static import method...}}

使用Stream秒

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

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

您可以连接Stream s：

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

或者你可以 go 从Stream到一个List ：

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

但最好只使用Stream而不将其收集到List中。

如果您特别需要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");

或使用Stream ：

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

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

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

^{*_{您可能不需要专门的ArrayList 。 引用JEP 269 ：}}

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

_{（强调我的）}

针对接口而非实现编程

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

您很可能不会这样做。

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

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

例如，如果您将ArrayList传递给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 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 。

Answer 4

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

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

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

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

Answer 5

使用番石榴，您可以编写：

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

在 Guava 中还有其他有用的 static 构造函数。 您可以在此处阅读有关它们的信息。

Answer 6

对于java-9及更高版本，如JEP 269: Convenience Factory Methods for Collections中所建议的，现在可以使用集合文字来实现 -

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 所述的 Collection Literals 提案。 在 JEP 中也有进一步的说明——

---

备择方案

语言更改已被考虑多次，并被拒绝：

Project Coin 提案，2009 年 3 月 29 日

Project Coin 提案，2009 年 3 月 30 日

JEP 186 关于 lambda-dev 的讨论，2014 年 1 月至 3 月

如本消息中所述，语言提案优先于基于图书馆的提案而被搁置。

相关： Java中的Collections重载便利工厂方法有什么意义9

Answer 7

集合字面量没有进入 Java 8，但可以使用 Stream API 在相当长的一行中初始化列表：

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

如果您需要确保您的List是ArrayList ：

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

Answer 8

import com.google.common.collect.ImmutableList;

....

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

Answer 9

你可以创建一个工厂方法：

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

Answer 10

在 Java 9 中，我们可以轻松地在一行中初始化ArrayList ：

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 的新方法与以前的方法相比有很多优点：

1. 空间效率
2. 不变性
3. 线程安全

有关详细信息，请参阅此帖子 -> List.of 和 Arrays.asList 有什么区别？

Answer 11

只需使用下面的代码如下。

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

Answer 12

关于最紧凑的方法是：

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

Answer 13

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

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

您也可以对 Sets 和 Bags 做同样的事情：

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 的提交者。

Answer 14

这是另一种方式：

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

Answer 15

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

class A{}
class B extends A{}

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

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

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

这可能是 go 的最佳方式，尤其是。 如果您需要无界列表或需要使用 inheritance。

Answer 16

您可以使用以下语句：

代码片段：

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

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

Answer 17

就像汤姆说的：

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集是合适的，如果将来需要更改列表，这将需要重新编译。

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

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

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

在那种情况下，我猜你不需要你的 ArrayList。

PS Randyaa 演示了另一种使用 static 实用方法Collections.addAll的好方法。

Answer 18

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

类似的方法可用于Set和Map 。

Answer 19

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

Answer 20

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

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

Answer 21

您可以使用StickyList中的StickyList ：

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

Answer 22

使用Arrays.asList("Buenos Aires", "Córdoba", "La Plata"); 是正确的。 但是任何使用零 arguments 或只有一个参数的 Arrays.asList( Arrays.asList()调用都可以替换为对Collections.singletonList()或Collections.emptyList()的调用，这将节省一些 memory。

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

Answer 23

尝试使用此代码行：

Collections.singletonList(provider)

Answer 24

在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("serial")或生成令人讨厌的串行 UUID。 此外，大多数代码格式化程序会将其解包为多个语句/行。

或者你可以做

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

但是你可能想做一个@SuppressWarnings("unchecked") 。

另外根据 javadoc 你应该能够做到这一点：

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

但是我无法让它与 JDK 1.6 一起编译。

Answer 25

Collections.singletonList(messageBody)

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

Collections来自java.util package。

Answer 26

最好的方法是：

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

只需创建一个 function，它可以包含任意数量的元素，然后调用它在一行中添加它们。

Answer 27

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

声明： 我是AbacusUtil 的开发者。

Answer 28

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

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

Answer 29

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

Answer 30

为什么不制作一个简单的实用程序 function 来执行此操作？

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

Answer 31

最简单的方法：您可以使用这种方法将多个元素添加到任何类型的集合中，例如 ArrayList 和 HashSet

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

Answer 32

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

Answer 33

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

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

Answer 34

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

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

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