Java 在一行中初始化ArrayList

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

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

ArrayList places=new ArrayList（）；
地点。添加（“布宜诺斯艾利斯”）；
添加（“科尔多瓦”）；
地点。添加（“拉普拉塔”）；

然后，我对代码进行了如下重构：

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

ArrayList places=新建ArrayList(
数组。asList（“布宜诺斯艾利斯”、“科尔多瓦”、“拉普拉塔”）；

有更好的方法吗？

实际上，初始化

ArrayList

的“最佳”方法可能是您编写的方法，因为它不需要以任何方式创建新的

列表：

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

但是，我不太喜欢这种方法，因为最终得到的是
ArrayList
的一个子类，它有一个实例初始值设定项，创建该类只是为了创建一个对象——这对我来说似乎有点过分了

如果for被接受的话会更好（计划在Java7中引入它，但它也不太可能成为Java8的一部分）：

List=[“A”、“B”、“C”]；

不幸的是，它在这里对您没有帮助，因为它将初始化一个不可变的
列表，而不是
ArrayList
，而且，它还不可用，如果可能的话。
实际上，初始化
ArrayList
的“最佳”方法可能是您编写的方法，由于不需要以任何方式创建新的
列表
：

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

但是，我不太喜欢这种方法，因为最终得到的是
ArrayList
的一个子类，它有一个实例初始值设定项，创建该类只是为了创建一个对象——这对我来说似乎有点过分了

如果for被接受的话会更好（计划在Java7中引入它，但它也不太可能成为Java8的一部分）：

List=[“A”、“B”、“C”]；

不幸的是，它在这里对您没有帮助，因为它将初始化一个不可变的
列表
，而不是一个
数组列表
，而且，它还不可用，如果它真的可用的话。
如果您只是将它声明为
列表
，它必须是一个数组列表吗

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

如果只将其声明为
列表
，则会更简单-它必须是ArrayList吗

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

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

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

publicstaticarraylistcreatearraylist（字符串…元素）{
ArrayList=新建ArrayList（）；
for（字符串元素：元素）{
列表。添加（元素）；
}
退货清单；
}
....
ArrayList places=createArrayList(
“圣保罗”、“里约热内卢”、“巴西利亚”）；

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

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

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

publicstaticarraylistcreatearraylist（T…元素）{
ArrayList=新建ArrayList（）；
对于（T元素：元素）{
列表。添加（元素）；
}
退货清单；
}
您可以创建工厂方法：

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

publicstaticarraylistcreatearraylist（字符串…元素）{
ArrayList=新建ArrayList（）；
for（字符串元素：元素）{
列表。添加（元素）；
}
退货清单；
}
....
ArrayList places=createArrayList(
“圣保罗”、“里约热内卢”、“巴西利亚”）；

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

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

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

publicstaticarraylistcreatearraylist（T…元素）{
ArrayList=新建ArrayList（）；
对于（T元素：元素）{
列表。添加（元素）；
}
退货清单；
}
导入com.google.common.collect.ImmutableList；
....
列表位置=不可变列表（“布宜诺斯艾利斯”、“科尔多瓦”、“拉普拉塔”）；
导入com.google.common.collect.ImmutableList；
....
列表位置=不可变列表（“布宜诺斯艾利斯”、“科尔多瓦”、“拉普拉塔”）；
简单的答案
Java 10或更高版本：
这将为您提供一个不可变的
列表
，因此它无法更改。

在大多数情况下，在预填充时，这就是您想要的

爪哇9
如果您使用的是Java 9，则不能使用
var
关键字：

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

任何现代IDE*都会为您提供建议和帮助

我不建议将
的

列表方法静态导入为的，因为这样会让人困惑

* 例如，在IntelliJ IDEA中，您按下

Alt+Enter

并选择

静态导入方法…

使用

流

s 为什么它必须是一个

列表

？
对于Java 8或更高版本，您可以使用更灵活的

流

：

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

或者您可以从

流

转到

列表

：

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

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

或在Java 8或更早版本中：

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

但同样，最好直接使用

流

，而不是将其收集到

列表

*您可能不需要专门的

ArrayList

。引述：

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

（强调矿山）

程序到接口，而不是实现 您说过您已经在代码中将列表声明为

ArrayList

，但只有在使用

ArrayList

中不在

list

中的某个成员时，才应该这样做

而你很可能不会这么做

通常，您只需通过将要使用的最通用接口（例如

Iterable

、

Collection

、或

List

）声明变量，并使用特定实现（例如

ArrayList

、

LinkedList

或

Arrays.asList（）

）初始化它们

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

例如，如果你要通过

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

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

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

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

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

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

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

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

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

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

class A{}
class B extends A{}

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

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

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

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

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

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<String> places = Lists.newArrayList("Buenos Aires", "Córdoba", "La Plata");

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

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

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

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

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

Collections.singletonList(messageBody)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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