java中list、map、array、实体类、字符串之间的相互转换，以及java8 stream流使用

一、list与字符串互转

这里介绍两种json包，fastjson 和 jackson，推荐使用后者，虽然fastjson使用起来简单易上手，而且较快，但是漏洞也多，详情可以参考知乎上面这个回答
fastjson 这么快，老外为什么还是热衷 jackson?

1. fastjson使用

（推荐1.2.7以上版本，因为低版本漏洞较多）

// 导入阿里的fastJson.jar
<!--添加fastjson依赖-->
 <dependency>
     <groupId>com.alibaba</groupId>
     <artifactId>fastjson</artifactId>
     <version>1.2.7</version>
 </dependency>

// 其中JSONObject和JSONArray均是继承JSON的方法，所以建议直接使用JSON抽象类即可
// list转换为json(以下六种均可)
List<User> list = new ArrayList<User>();
String str = JSON.toJSON(list).toString();
String str1 = JSON.toJSONString(list);
String str2 = JSONArray.toJSON(list).toString();
String str3 = JSONArray.toJSONString(list);
String str4 = JSONObject.toJSON(list).toString();
String str5 = JSONObject.toJSONString(list);
// json转换为list（以下三种均可）
List<User> list = JSONObject.parseArray(str, User.class);
List<User> list1 = JSON.parseArray(str, User.class);
List<User> list2 = JSONArray.parseArray(str, User.class);

实体类与字符串的转换与这个上面类似

String str = JSON.toJSONString(new User()); // 转字符串
User user = JSON.parseObject(str, User.class); // 转实体类

2. jackson使用

springboot中自带的json包底层就是引用的jackson,我这里springboot版本是2.3.2
jackson注解大全

<!--添加springboot依赖-->
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-web</artifactId>
     <version>2.3.2.RELEASE</version>
 </dependency>

	List<UserEntity> list = new ArrayList<>();
    list.add(new UserEntity().setName("xiaoMing").setAge(23));
    list.add(new UserEntity().setName("xiaoHua"));
    // jackson用于序列化的类
    ObjectMapper objectMapper = new ObjectMapper();
    // 1、list转json字符串(对象转json字符串同理)
    String str = objectMapper.writeValueAsString(list);
    System.out.println("list转json字符串：" + str);
    // 2、json字符串转list
    List<UserEntity> list2 = objectMapper.readValue(str, new TypeReference<List<UserEntity>>(){});
    System.out.println("json字符串转list：" + list2);
    // 3、json字符串转对象
    UserEntity user = objectMapper.readValue("{\"name\":\"xiaoMing\",\"age\":23}", UserEntity.class);
    System.out.println("json字符串转对象：" + user);
    // 4、json字符串转map
    Map<String, Object> map = objectMapper.readValue("{\"name\":\"xiaoMing\",\"age\":23}",new TypeReference<Map<String, Object>>(){});
    System.out.println("json字符串转map：" + map);

输出：
> list转json字符串：[{"name":"xiaoMing","age":23},{"name":"xiaoHua","age":null}]
> json字符串转list：[UserEntity(name=xiaoMing, age=23),UserEntity(name=xiaoHua, age=null)]
> json字符串转对象：UserEntity(name=xiaoMing, age=23)
> json字符串转map：{name=xiaoMing, age=23}

二、list转map

lombok常用注解

    // 这里的注解作用可点击上方链接
    @Data
    @Accessors(chain = true)
    @AllArgsConstructor
    @NoArgsConstructor
    public static class User{
        private String id;
        private String name;
    }

		// list转map
		// ::用于类与方法之间，如person -> person.getAge();可以替换成Person::getAge
        List<User> userList = Lists.newArrayList(
                new User().setId("A").setName("张三"),
                new User().setId("B").setName("李四"), 
                new User().setId("C").setName("王五")
        );
        Map<String,String> map =  userList.stream().collect(Collectors.toMap(User::getId, User::getName));
        System.out.println(map);

{A=张三, B=李四, C=王五}

其中Collectors.toMap 有三个重载方法，四个参数：

keyMapper：Key 的映射函数
valueMapper：Value 的映射函数
mergeFunction：当 Key 冲突时，调用的合并方法
mapSupplier：Map 构造器，在需要返回特定的 Map 时使用

当然，如果希望得到 Map 的 value 为对象本身时，可以这样写：

userList.stream().collect(Collectors.toMap(User::getId, t -> t));
 或：
userList.stream().collect(Collectors.toMap(User::getId, Function.identity()));

{A=User(id=A, name=张三), B=User(id=B, name=李四), C=User(id=C, name=王五)}

如果键值重复用前面的会报错，所以加上第三个参数，如果有相同key做出处理

List<User> userList = Lists.newArrayList(
        new User("A","张三"),
        new User().setId("A").setName("李四"),
        new User().setId("A").setName("桃源"),
        new User().setId("C").setName("王五")
);
Map<String,String> map =  userList.stream().collect(Collectors.toMap(User::getId, User::getName, (n1, n2) -> n1+","+n2));
System.out.println(map);

{A=张三,李四,桃源, C=王五}

第四个参数是排序，这里根据treeMap排序（根据key排序）

List<User> userList = Lists.newArrayList(
        new User("2","张三"),
        new User().setId("23").setName("李四"),
        new User().setId("17").setName("桃源"),
        new User().setId("1").setName("王五")
);
Map<String,String> map =  userList.stream().collect(Collectors.toMap(User::getId, User::getName, (n1, n2) -> n1, TreeMap::new));
System.out.println(map);

{1=王五, 17=桃源, 2=张三, 23=李四}

list转map并分组

// 根据名称分组，以名称为key,把相同名称的数据保存为list放入value中
List<User> userList = Lists.newArrayList(
        new User("2","张三"),
        new User().setId("23").setName("李四"),
        new User().setId("17").setName("桃源"),
        new User().setId("1").setName("王五")
);

Map<String, List<User>> fieldMap =  userList.stream().collect(Collectors.groupingBy(User::getName));

// 以名称分组，然后相同名称的id组合成一个list,      Map>
Map<String, List<Long>> map = userList.stream().collect(
                Collectors.groupingBy(User::getName,
                        Collectors.mapping(User::getId,
                                Collectors.toList())));

三、map转list

1.通过new来获取列表

		Map<Integer, String> map = new HashMap<>();
        map.put(10, "apple");
        map.put(20, "orange");
        map.put(30, "banana");

        List<Integer> result = new ArrayList(map.keySet());
        result.forEach(System.out::println);
        
        List<String> result2 = new ArrayList(map.values());
        result2.forEach(System.out::println);

2.根据流来获取列表

		Map<Integer, String> map = new HashMap<>();
        map.put(10, "apple");
        map.put(20, "orange");
        map.put(30, "banana");
        
		List<Integer> result = map.keySet().stream()
                .collect(Collectors.toList());

        List<String> result2 = map.values().stream()
                .collect(Collectors.toList());
		// equalsIgnoreCase不区分大小写，filter过滤器(这里会过滤掉banana)
        List<String> result3 = map.values().stream()
                .filter(x -> !"banana".equalsIgnoreCase(x))
                .collect(Collectors.toList());

四、list与array互转

1.list转array

// 方法一（建议）：
// 用法：String[] y = x.toArray(new String[0]);
// 括号里面是数组长度，最好为列表的大小，如果比列表长则报错，如果比列表短则默认列表长度。
User[] b = list.toArray(new User[list.size()]);

// 方法二（不建议）：
// 先定义list大小的数组，再循环遍历list
String[] strArray2 = new String[strList.size()];
for (int i = 0; i < list.size(); i++) {
    strArray2[i] = list.get(i);
}

2.array转list

// 这里有以下两种方式，有人肯定会问第二种不是画蛇添足吗？
// 因为Arrays.asList返回list大小是定长的，不支持add、remove操作。而第二种相当于new了一个新的数组列表，因此支持增加和删除
 String[] strs={"dog","cat","cow"};
 List<String> listA = Arrays.asList(strs);
 List<String> listB = new ArrayList<>(Arrays.asList(strs));

五、一个list转另一个list

方式1：

// 通过stream().map在map方法里面进行转换
// 其中o对list1的对象，return出来的对象代表list2中的对象。
// BeanUtils类的copyProperties方法是把o中与entity相同字段数据从o转到entity
 List<StudentEntity> list1 = new ArrayList<>();
 List<LessonStudentEntity> list2 = list1.stream().map(o -> {
            LessonStudentEntity entity = new LessonStudentEntity();
            BeanUtils.copyProperties(o, entity);
            return entity;
        }).collect(Collectors.toList());
list2.forEach(System.out::println);

方式2：

:可以用cn.hutool.core.bean包下的BeanUtil.copyToList(Collection<?> collection, Class<T> targetType, CopyOptions copyOptions)方法

六、list的stream流使用

1.list排序

1.使用年龄进行升序排序

List<StudentInfo> studentsSortName = studentList.stream().sorted(Comparator.comparing(StudentInfo::getAge)).collect(Collectors.toList());

2.使用年龄进行降序排序（使用reversed()方法）

 List<StudentInfo> studentsSortName = studentList.stream().sorted(Comparator.comparing(StudentInfo::getAge).reversed()).collect(Collectors.toList());

3.使用年龄进行降序排序，年龄相同再使用身高升序排序（根据2个字段排序）

List<StudentInfo> studentsSortName = studentList.stream().sorted(Comparator.comparing(StudentInfo::getAge).reversed().thenComparing(StudentInfo::getHeight))
                .collect(Collectors.toList());

2.list循环遍历

对列表中每个对象字段进行操作

// 单行操作
list.stream().forEach(o -> 
	o.setHead("头像") 
);

// 多行操作，用大括号
list.stream().forEach(o -> {
	o.setHead("头像")；
	o.setName("名称")；
});

3.获取list中非重复字段列表

distinct()方法是用于获取不同的（如list中有两个id为1的实体类，最终获取的collect1 列表中只有一个id为1的）

List<Long> collect1 = list.stream().map(StudentInfo::getId).distinct().collect(Collectors.toList());

4.根据某个字段去重，并对重复数据操作

例，当name相同时，去重，并且id进行相加，返回list

List<Ac> list = new ArrayList<Ac>(){
            {
                add(new Ac("A", 1));
                add(new Ac("A", 3));
                add(new Ac("B", 4));
                add(new Ac("B", 5));
            }
        };
 // 第一步：把list转为第一个map，key为name，
 // value为Ac类（a->a表示Ac对象）
 // o1和02表示的是value，这里是Ac对象，
 // 不懂list转map的可以看上面的list转map
Map<String, Ac> map= list.stream()
                .collect(Collectors.toMap(Ac::getName, a -> a, (o1,o2)-> {
                    o1.setId(o1.getId() + o2.getId());
                    return o1;
                }));
 // 第二步：获取map的所有values，生成一个列表到result。
List<Ac> result = result.values().stream().collect(Collectors.toList());

System.out.println("map："+map);
System.out.println("result："+result);

输出结果

map：{A=Ac(name=A, id=4), B=Ac(name=B, id=9)}
result：[Ac(name=A, id=4), Ac(name=B, id=9)]

5.获取两个list的交集、差集、并集

 List<String> list1 = new ArrayList<>();
 list1.add("1");
 list1.add("2");
 List<String> list2 = new ArrayList<>();
 list2.add("2");
 list1.add("3");
       
       // 交集
        List<String> intersection = list1.stream().filter(item -> list2.contains(item)).collect(Collectors.toList());

        // 差集 (list1 - list2)
        List<String> reduce1 = list1.stream().filter(item -> !list2.contains(item)).collect(Collectors.toList());

        // 差集 (list2 - list1)
        List<String> reduce2 = list2.stream().filter(item -> !list1.contains(item)).collect(Collectors.toList());

        // 并集
        List<String> listAll = list1.parallelStream().collect(Collectors.toList());
        List<String> listAll2 = list2.parallelStream().collect(Collectors.toList());
        listAll.addAll(listAll2);

        // 去重并集
        List<String> listAllDistinct = listAll.stream().distinct().collect(Collectors.toList());

6.交换list中两个对象位置

交换list中第1个和第2个对象的位置。

Collections.swap(list, 0, 1);

7.查询list中字段最大（最小）值所对应的对象

返回UserEntity实体类中date最大的对象，如果没有数据返回则返回null

list.stream().max(Comparator.comparing(UserEntity::getDate)).orElse(null)

同理也可以用min方法找出最小的

感谢以下博主的资源，附上链接：
https://blog.csdn.net/xialong_927/article/details/81872422
https://blog.csdn.net/zzzfeiyu/article/details/100640361
https://www.cnblogs.com/miracle-luna/p/11113673.html
https://blog.csdn.net/lpq374606827/article/details/93203927
https://www.cnblogs.com/codecat/p/10873757.html
https://blog.csdn.net/weixin_38256991/article/details/81672235