数组、list、set、map集合之间相互转换

在项目开发过程中，会遇到不同类型集合之间的转换问题，对于集合转换，最简单的方式就是for循环，通过遍历将一个集合中的元素转换为另外一个集合的元素，在java8之后又提供了stream操作，进一步简化了代码开发。下面就介绍几种集合间相互转化的方式：

1. 数组和List列表之间的转换
   将数组转换为List：

// 数组 转 List
Integer[] arr = { 1, 2, 3 };
// 不可变集合
List<Integer> list1 = Arrays.asList(arr);

// 可变集合
ArrayList<Integer> list2 = new ArrayList<>(Arrays.asList(arr));

// 借用集合工具
List<Integer> list3 = new ArrayList<>();
Collections.addAll(list3, arr);

// 使用stream
List<Integer> list4 = Arrays.stream(arr).collect(Collectors.toList());
1
2
3
4
5
6
7
8
9
10
11
12
13
14

上面的几种方式进行转换的数组必须是对象类型，对于基本类型的数组只能借助stream进行转换：

Integer[] arr = { 1, 2, 3 };
List<Integer> list = Arrays.stream(arr).collect(Collectors.toList());
1
2

将List转换为数组：

// List转数组
List<Integer> list = Arrays.asList(1, 2, 3, 3);

// toArray方法
Integer[] arr1 = list.toArray(new Integer[list.size()]);
System.out.println(JSONObject.toJSONString(arr1));
// 使用stream
Integer[] arr2 = list.stream().toArray(Integer[]::new);
// 转基本类型数组
int[] arr3 = list.stream().mapToInt(Integer::intValue).toArray();
int[] arr4 = list.stream().mapToInt(i -> i).toArray();
1
2
3
4
5
6
7
8
9
10
11

2. List与Set之间转换

// List转数组
List<Integer> list = Arrays.asList(1, 2, 3, 3);

// new对象方式
HashSet<Integer> set1 = new HashSet<>(list);
// 使用stream
Set<Integer> set2 = list.stream().collect(Collectors.toSet());
// 使用addAll方法
Set<Integer> set3 = new HashSet<>();
set3.addAll(list);
1
2
3
4
5
6
7
8
9
10

将Set转换为List方法基本一致，Set集合是去重的，在将List转换为Set时要注意数据的丢失。

3. List转Map
   将List转Map最简单的方式就是使用stream中的collect方法，但是要注意键的重复问题，因为重复的键在使用该api时会报错：

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @Author xingo
 * @Date 2023/11/16
 */
public class CollectTest {

    public static void main(String[] args) {
        // list转map
        List<User> list = Stream.of(
                User.builder().id(1).name("name-1").build(),
                User.builder().id(2).name("name-2").build(),
                User.builder().id(3).name("name-3").build(),
                User.builder().id(5).name("name-4").build()
        ).collect(Collectors.toList());

        // 通过stream
        Map<Integer, User> map = list.stream().collect(Collectors.toMap(User::getId, user -> user));

//        Map map = list.stream().collect(Collectors.toMap(user -> user.getId(), user -> user));
//        Map map = list.stream().collect(Collectors.toMap(new Function() {
//            @Override
//            public Integer apply(User user) {
//                return user.getId();
//            }
//        }, new Function() {
//            @Override
//            public User apply(User user) {
//                return user;
//            }
//        }));

        // 通过for循环
//        Map map = new HashMap<>(list.size());
//        list.forEach(user -> map.put(user.getId(), user));
    }

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @Builder
    public static final class User {
        private int id;
        private String name;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55