list数组初始化 - java数组初始化




在一行中初始化ArrayList (20)

简单的答案

在Java 8或更早版本中:

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

这将为您提供由数组支持的List ,因此它不能更改长度。
但你可以调用List.set ,所以它仍然是可变的。

在Java 9中:

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

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

答案越短

您可以使用静态导入使Arrays.asList更短:

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

静态导入:

import static java.util.Arrays.asList;  

任何现代IDE都会建议并自动为您做。
例如,在IntelliJ IDEA中,按Alt+Enter并选择Static import method...

但是,我不建议缩短Java 9 List.of方法,因为只是变得混乱。
List.of已经足够短并且读得很好。

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

或者您可以从Stream转到List

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

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

如果你真的特别需要一个java.util.ArrayList

(你可能没有。)
引用JEP 269 (强调我的):

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

如果你想预先填充一个ArrayList 在之后添加它(为什么?),请使用

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

或者在Java 9中:

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

或使用Stream

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

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

编程到接口,而不是实现

你说你已经在代码中将列表声明为ArrayList ,但是如果你使用的是ArrayList中不属于List某个成员,你应该这样做。

你很可能不会这样做。

通常,您应该通过您将要使用的最通用接口(例如IterableCollectionList )声明变量,并使用特定实现(例如ArrayListLinkedListArrays.asList() )初始化它们。

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

例如:

// Iterable if you just need iteration, for (String s : strings):
Iterable<String> strings = new ArrayList<>();   

// Collection if you also need .size() or .stream():
Collection<String> strings = new ArrayList<>(); 

// List if you also need .get(index):
List<String> strings = new ArrayList<>();       

// Don't declare a specific list implementation
// unless you're sure you need it:
ArrayList<String> strings = new ArrayList<>();  // You don't need ArrayList

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

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

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

有一个更好的方法吗?


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

SetMap也有类似的方法。


为什么不做一个简单的实用功能呢?

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

你可以使用StickyListStickyList

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

使用Eclipse Collections (以前的GS Collections ),您可以编写以下内容:

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

您还可以更具体地了解类型以及它们是Mutable还是Immutable。

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


使用Java 9 ,正如JDK Enhancement Proposal - 269中所建议的那样,现在可以使用集合文字来实现 -

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文件中进一步澄清 -

备择方案

语言变化已被多次考虑,并被拒绝:

项目硬币提案,2009年3月29日

项目硬币提案,2009年3月30日

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

优先考虑语言提案,优先于本message.概述的基于库的提案message.

进一步阅读=> 在Java 9中重载的方便工厂方法的重点是什么


关于最紧凑的方法是:

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

只需使用以下代码如下。

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

在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编译它。


如果你只是将它声明为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"));

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

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

问题是,引用该list实例需要进行相当多的输入。

还有其他选择,例如使用实例初始化程序创建匿名内部类(也称为“双括号初始化”):

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

但是,我不太喜欢那个方法,因为你最终得到的是ArrayList一个子类,它有一个实例初始化器,并且创建该类只是为了创建一个对象 - 这对我来说似乎有点过头了。

如果Project CoinCollection Literals提议被接受(它将在Java 7中引入,但它也不可能成为Java 8的一部分),那本应该不错的是。):

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

不幸的是,它不会帮助你,因为它将初始化一个不可变的List而不是一个ArrayList ,而且,它还没有,如果有的话。


实际上,它可以在一行中完成:

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

尝试使用此代码行:

Collections.singletonList(provider)

您可以使用以下语句:

代码片段:

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

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

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

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

最好的方法:

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> values = Stream.of("One", "Two").collect(Collectors.toList());

集合文字没有进入Java 8,但是可以使用Stream API在一个相当长的行中初始化列表:

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

如果您需要确保ListArrayList

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

import com.google.common.collect.ImmutableList;

....

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




initialization