使用stream流根据对象属性对复杂list对象去重_stream去重对象

日常开发中，我们可能会遇到这样一种情况，需要对数据库查询出来的数据进行一个二次处理，从而达到我们需要的数据结构。stream流正是java8提供的对复杂list操作方便工具。
我们先介绍如何使用stream流根据对象属性对复杂list对象去重，再介绍一下stream流最常用的一些操作：

使用stream流根据对象属性对复杂list对象去重

例子1

实体类：

import lombok.Data;

@Data
public class SyncUserDto {

    private String id;
    private String name;
    private String code;
    private String departmentCode;
    private String departmentName;
    private String position;
    private String phone;
    private String mobile;
    private String email;
    private Integer sex;
    private String idcard;
    private Integer status;
    private String account;
    private String weighting;
    private String photourl;
    private String openid;
    private String userid;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

去重操作：

            //去重
             ArrayList<SyncUserDto> collect = syncUserDtos.stream().collect(Collectors.collectingAndThen(
                    Collectors.toCollection(
                            () -> new TreeSet<>((o1, o2) -> {
                                if (o1.getAccount().compareTo(o2.getAccount()) == 0) {
                                    return 0;
                                } else {
                                    return o1.getAccount().compareTo(o2.getAccount());
                                }
                            }))
                    , ArrayList::new)
            );
1
2
3
4
5
6
7
8
9
10
11
12

例子2

实体类：

public class User {
	
	private String id;
	private String name;
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public User(String id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

去重：

public class Demo {
    public static void main(String[] args) {
    	
        List<User> list = new ArrayList<>();
        User u1 = new User("a", "aaa");
        User u2 = new User("a", "aaa");
        User u3 = new User("b", "aaa");
        User u4 = new User("a", "b");
        User u5 = new User("b", "a");

        list.add(u1);
        list.add(u2);
        list.add(u3);
        list.add(u4);
        list.add(u5);
        list.add(u1);
        list.add(u2);
        list.add(u3);
        list.add(u4);
        list.add(u5);
        List<User> unique=list.stream().collect(Collectors.collectingAndThen(
        		Collectors.toCollection(
        				()->new TreeSet<>((o1,o2)->{
        					  if (o1.getName().compareTo(o2.getName()) == 0) {
        		                    return 0;
        		                } else {
        		                    return o1.getName().compareTo(o2.getName());
        		                }
        				}))
        				, ArrayList::new)
        		);
       

        System.out.println("根据对象属性name进行去重");
        System.out.println("----------	去重前----------");
        System.out.println("集合中元素的个数为："+list.size());
        for (User user : list) {
            System.out.println(user.toString()+"--姓名："+user.getName());
        }
        System.out.println("-----------去重后----------");
         System.out.println("集合中元素的个数为："+unique.size());
        for (User user : unique) {
            System.out.println(user.toString()+"--姓名："+user.getName());
        }
    }
}
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

stream流常用操作

forEach()：遍历流中的对象

public class Aoo {
    public static void main(String[] args) {
        // 定义一个集合
        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("李四");
        list.add("李四");
        list.add("李四");
        list.add("李四");
        list.add("李四");
 
        //遍历流的对象
        list.stream().forEach((name) -> System.out.println(name));
    }
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

filter()：filter对流对象进行过滤

 
public class Aoo {
    public static void main(String[] args) {
        // 定义一个集合
        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四二");
        list.add("李四我");
        list.add("李四去晚");
        list.add("李四请问");
        list.add("李四去");
        list.add("李四我");
 
        //过滤流的对象
        list.stream().filter((name) -> name.length()==2);
    }
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

map()：map()是对集合中的对象进行映射的,将对象从一种类型转换成另一种类型

 
public class Aoo {
    public static void main(String[] args) {
        // 定义一个集合
        ArrayList<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        list.add("6");
        list.add("7");
 
        //map()是对集合中的对象进行映射的,将对象从一种类型转换成另一种类型
        list.stream().map(num -> Integer.parseInt(num));
    }
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

count()：count是对流数据统计的方法，但是count之后返回的是long类型，所以无法再进行流操作。

public class Aoo {
    public static void main(String[] args) {
        // 定义一个集合
        ArrayList<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        list.add("6");
        list.add("7");
 
        //count()对流数据进行统计
        System.out.println(list.stream().count());
    }
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

limit()：选取流数据的前多少条数据

 
public class Aoo {
    public static void main(String[] args) {
        // 定义一个集合
        ArrayList<String> list = new ArrayList<>();
        list.add("李四1");
        list.add("李四2");
        list.add("李四3");
        list.add("李四4");
        list.add("李四5");
        list.add("李四6");
        list.add("李四7");
        //limit() 选取流数据的前多少条数据
        list.stream().limit(2);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

skip()：跳过流数据的前多少条数据，该方法与limit()方法刚好相反

public class Aoo {
    public static void main(String[] args) {
        // 定义一个集合
        ArrayList<String> list = new ArrayList<>();
        list.add("李四1");
        list.add("李四2");
        list.add("李四3");
        list.add("李四4");
        list.add("李四5");
        list.add("李四6");
        list.add("李四7");
        //skip() 跳过流数据的前多少条数据
        list.stream().skip(2);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

concat()：Stream的静态方法concat()实现对两个流数据进行合并

public class Aoo {
    public static void main(String[] args) {
        // 定义一个集合
        ArrayList<String> list = new ArrayList<>();
        list.add("李四1");
        list.add("李四2");
        list.add("李四3");
        list.add("李四4");
        list.add("李四5");
        list.add("李四6");
        list.add("李四7");
        // 定义一个集合
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("1");
        list1.add("2");
        list1.add("3");
        list1.add("4");
        list1.add("5");
        list1.add("6");
        list1.add("7");
        //concat()实现对两个流数据进行合并
        Stream.concat(list.stream(),list1.stream());
    }
 
}
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