Stream流的常用方法

最近用了Stream流，感觉超好用，记录一下。

1、快速创建List

比如我有个实体类User，User有个属性Name

   
   

   
   
1

public class User {
	public User(String name, String age, int height) {
		this.name = name;
		this.age = age;
		this.height = height;
	}
	private String name;
	private String age;
	private int height;
	// setter、getter方法我就不写了
}

// 创建三个user
User user1 = new User(“111”, “18”, 180);
User user2 = new User(“222”, “18”, 175);
User user3 = new User(“333”, “19”, 170);

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16

现在我要创建3个user放到list中：

（1）、new一个list，一个一个添加

List<User> userList = new ArrayList<>();
userList.add(user1);
userList.add(user2);
userList.add(user3);

 
 

 
 
1
2
3
4

（2）、Stream流：创建动态list，可以添加元素

// stream流，创建的是动态数组，可以添加元素
List<User> userList = Stream.of(user1, user2, user3).collect(Collectors.toList());

 
 

 
 
1
2

（3）、如果创建一个固定长度的list，可以使用Arrays.asList(…args)直接返回一个list

本质是将一个数组转成list，数组的大小是固定的，所以此list不能添加元素，
如果调用add方法增加新的元素，会报异常：java.lang.UnsupportedOperationException
当元素是固定时，可以采用这个；

// 本质是将一个数组转成list，数组的大小是固定的，所以此list不能添加元素
// 如果调用add方法增加新的元素，会报异常：java.lang.UnsupportedOperationException
List<String> s = Arrays.asList("1","2","3") 

 
 

 
 
1
2
3

2、取对象的某一列：

拿上面userList举例，我取出list中所有user的name属性放到一个新的list中：

（1）、遍历

// 遍历
List<String> userNameList = new ArrayList<>();
for (User user : userList) {
	userNameList.add(user.getName());
}

 
 

 
 
1
2
3
4
5

（2）、Stream流：map

// Stream流
List<String> userNameList = userList.stream().map(User::getName).collect(Collectors.toList());

 
 

 
 
1
2

3、过滤，或者说是根据一个判断条件筛选出目标对象

还拿上面的userList，比如我要筛选出userList中name不为空的user

（1）、遍历加 if

List<User> newUserList = new ArrayList<>();
// if判断
for (User user : userList) {
	if(user.getName() != null) {
		newUserList.add(user); 
	}
}

 
 

 
 
1
2
3
4
5
6
7

（2）、Stream流：filter

// 获取userName不为空的user的List
List<User> userList = userList.stream().filter(user-> user.getName() != null).collect(Collectors.toList());

 
 

 
 
1
2

4、分组

把userList中的user根据年龄分组：

（1）、遍历加 if

Map<String, List<User>> map = new HashMap<>();
// if判断
for (User user : userList) {
	if (map.get(user.getAge()) == null) {
		map.put(user.getAge(), new ArrayList());
	}
	map.get(user.getAge()).add(user);
}

 
 

 
 
1
2
3
4
5
6
7
8

（2）、Stream流：groupingBy

Map<String, List<User>> map =userList.stream().collect( Collectors.groupingBy(User::getAge, Collectors.toList()));

 
 

 
 
1

5、求和

（1）、int、double、long:

求和的普通遍历方式跟上面差不多，就不举例了；

// int、double、long:
double max = userList.stream().mapToDouble(User::getHeight).sum();

 
 

 
 
1
2

6、Map、List互转

（1）、list转map：

a、遍历：

	Map<String, User> userMap = new Map<>();
    for (User user : userList) {
		userMap.put(user.getName(), user);
	}

 
 

 
 
1
2
3
4

b、stream流：

用Collectors的toMap方法转换List，一般会遇到两个问题。
（1）转换map，key重复问题；
代码中使用(key1,key2)->key2表达式可以解决此类问题，如果出现重复的key就使用key2覆盖前面的key1,也可以定义成(key1,key2)->key1，保留key1,根据自己的业务场景来调整。
（2）空指针异常，即转为map的value是null。这个可以用filter过滤；

	Map<String, User> userMap= userList.stream().collect(Collectors.toMap(User::getName, Function.identity(),(key1, key2)->key2));

 
 

 
 
1

（2）、map转list：

a、遍历：

	List<User> userList = new List<>();
    for (String userName : userMap.keySet()) {
		userList.add(userMap.get(userName));
	}

 
 

 
 
1
2
3
4

b、stream流：

   List<User> userList = userMap.entrySet().stream().map(e ->e.getValue()).collect(Collectors.toList());

 
 

 
 
1

7、做判断

（1）、anyMatch()：

判断的条件里，任意一个元素成功，返回true;
比如上面的userlList，我想判断是否有height > 175的：

    userList.stream().anyMatch(user -> user.getHeight() > 175);

 
 

 
 
1

（2）、allMatch()：

allMatch：判断条件里的元素，所有的都是，返回true；
比如上面的userlList，我想判断是否全部height > 175的：

    userList.stream().allMatch(user -> user.getHeight() > 175);

 
 

 
 
1

（3）、noneMatch()：

与allMatch相反，判断条件里的元素，所有的都不是，返回true

    userList.stream().noneMatch(user -> user.getHeight() > 175);

 
 

 
 
1

（4）、求取目标和：

    userList.stream().filter(user -> user.getHeight() > 175).count();

 
 

 
 
1

全部打印结果：

    System.out.println(userList.stream().anyMatch(user -> user.getHeight() > 175));
    System.out.println(userList.stream().allMatch(user -> user.getHeight() > 175));
    System.out.println(userList.stream().noneMatch(user -> user.getHeight() > 175));
    System.out.println(userList.stream().filter(user -> user.getHeight() > 175).count());

 
 

 
 
1
2
3
4

8、合并List

（1）、合并多个一维List：

   List<Integer> list1 = Arrays.asList(1, 2, 3);
   List<Integer> list2 = Arrays.asList(4, 5, 6);
   List<Integer> list3 = Arrays.asList(7, 8, 9);
   List<Integer> mergedList = Stream.of(list1, list2, list3).flatMap(Collection::stream).collect(Collectors.toList());
   System.out.println(mergedList);// [1, 2, 3, 4, 5, 6, 7, 8, 9]

 
 

 
 
1
2
3
4
5
6

结果：

（1）、合并嵌套List：

   List<String> list1 = Arrays.asList("张三", "李四", "王二麻子");
   List<String> list2 = Arrays.asList("111", "222", "333");
   // 合并前
   List<List<String>> lists = Arrays.asList(list1, list2);
   System.out.println(lists);

// 合并后
List<String> mergedList = lists.stream().flatMap(Collection::stream).collect(Collectors.toList());
System.out.println(mergedList);

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

结果：

9、分页

        Map<String,Object> map = Maps.newHashMap();
        List list = new ArrayList();
        //list -> 当前页所有数据
        map.put("list",list.stream().skip((long) (pageNo - 1) * pageSize).limit(pageSize).collect(Collectors.toList()));
        //count -> 记录总条数
        map.put("count",list.size());

 
 

 
 
1
2
3
4
5
6

以上均为个人使用记录，若有错误，欢迎指正！