集合对象的几种初始化方式

1. 最简单的方式是通过new构建一个对象，构建对象后再进行赋值：

// 通过new创建并赋值
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);

Set<Integer> set = new HashSet<>();
set.add(1);
set.add(2);
set.add(3);

Map<Integer, Integer> map = new HashMap<>();
map.put(1, 1);
map.put(2, 2);
map.put(3, 3);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2. new对象的同时进行赋值：

// 创建对象同时赋值
List<Integer> list = new ArrayList<Integer>() {{
    add(1);
    add(2);
    add(3);
}};

Set<Integer> set = new HashSet<Integer>() {{
    add(1);
    add(2);
    add(3);
}};

Map<Integer, Integer> map = new HashMap<Integer, Integer>() {{
    put(1, 1);
    put(2, 2);
    put(3, 3);
}};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

3. 对于list集合还可以通过Arrays.asList来构建，但是这种方式构建的集合是不可变的：

// 通过Arrays.asList构建
List<Integer> list = Arrays.asList(1, 2, 3);
1
2

当我们向集合中添加元素时会报错：

list.add(4);
1

抛出的异常：

Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.AbstractList.add(AbstractList.java:148)
	at java.util.AbstractList.add(AbstractList.java:108)
	at org.example.CollectTest.main(CollectTest.java:23)
1
2
3
4

4. 可以通过Stream构建集合：

// 通过stream创建
List<Integer> list = Stream.of(1, 2, 3).collect(Collectors.toList());

Set<Integer> set = Stream.of(1, 2, 3).collect(Collectors.toSet());

Map<Integer, Integer> map = Stream.of(1, 2, 3).collect(Collectors.toMap(key -> key, val -> val));
1
2
3
4
5
6

这种方式构建map集合时，要注意key不能重复，否则会报错：

Map<Integer, Integer> map = Stream.of(1, 2, 3, 3).collect(Collectors.toMap(key -> key, val -> val));
1

抛出的异常：

Exception in thread "main" java.lang.IllegalStateException: Duplicate key 3
	at java.util.stream.Collectors.lambda$throwingMerger$0(Collectors.java:133)
	at java.util.HashMap.merge(HashMap.java:1254)
	at java.util.stream.Collectors.lambda$toMap$58(Collectors.java:1320)
	at java.util.stream.ReduceOps$3ReducingSink.accept(ReduceOps.java:169)
	at java.util.Spliterators$ArraySpliterator.forEachRemaining(Spliterators.java:948)
	at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:481)
	at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:471)
	at java.util.stream.ReduceOps$ReduceOp.evaluateSequential(ReduceOps.java:708)
	at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
	at java.util.stream.ReferencePipeline.collect(ReferencePipeline.java:499)
	at org.example.CollectTest.main(CollectTest.java:20)
1
2
3
4
5
6
7
8
9
10
11
12

5. 构建单个元素的集合，个人感觉这种构建方式非常简单，而且在项目中用的场景还挺多。

// 构建单个元素的集合
List<Integer> list = Collections.singletonList(1);

Set<Integer> set = Collections.singleton(1);

Map<Integer, Integer> map = Collections.singletonMap(1, 1);
1
2
3
4
5
6

这种方式构建的集合也是不可变集合，添加元素会报错。

6. 构建空集合

// 构建空集合
List list = Collections.EMPTY_LIST;

Set set = Collections.EMPTY_SET;

Map map = Collections.EMPTY_MAP;
1
2
3
4
5
6

这种方式构建的集合不可变，添加元素会抛异常，但是这种集合有什么用呢！想了一下有时候我们向前端返回接口数据时，如果没有查询到数据返回值就是null，没有意义的null值前端不希望返回，这时候使用这种空集合返回给前端就可以避免多余的判断逻辑，而且空集合对象不用重复构建，节省了内存空间，集合的不可变更省去了多线程的安全问题。所以这种方式非常适合这种场景的使用。