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

  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. 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. 对于list集合还可以通过Arrays.asList来构建,但是这种方式构建的集合是不可变的:
// 通过Arrays.asList构建
List<Integer> list = Arrays.asList(1, 2, 3);

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

list.add(4);

抛出的异常:

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. 可以通过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));

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

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

抛出的异常:

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. 构建单个元素的集合,个人感觉这种构建方式非常简单,而且在项目中用的场景还挺多。
// 构建单个元素的集合
List<Integer> list = Collections.singletonList(1);

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

Map<Integer, Integer> map = Collections.singletonMap(1, 1);

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

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

Set set = Collections.EMPTY_SET;

Map map = Collections.EMPTY_MAP;

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

你可能感兴趣的:(windows,开发语言)