Java 8 List stream 应用案例，持续更新

2021/03/25 16:51

1、List 按条件过滤后，统计数据

long count = hkUserCheckedVos.stream().filter(s -> s.getChecked() == 1).count();
2、List 按条件过滤后，返回某个字段形成的集合list结果，如下：
List<String> collect = hkUserCheckedVos.stream()
.filter(s -> s.getChecked() == 1)
.map(e -> e.getUserUuid())
.collect(Collectors.toList());

3、关于stream中关于sorted的使用总结，如下：

@Data
static   class User {
private String name;
//age
private int age;
//分数
private double fraction;

public User(String name, int age, double fraction) {
this.name = name;
this.age = age;
this.fraction = fraction;
}
}

public static void main(String[] args) {
List<User> userList = new ArrayList<>();

//返回 对象集合以UsergetAge升序排序:年龄   --默认升序
userList.stream().sorted(Comparator.comparing(User::getAge));

//返回 对象集合以UsergetAge降序排序  ===这里写在前面 和写在后面要看清楚，弄明白
userList.stream().sorted(Comparator.comparing(User::getAge).reversed()); //排序结果后再排序,
userList.stream().sorted(Comparator.comparing(User::getAge, Comparator.reverseOrder()));//是直接进行排序

//返回 对象集合以UsergetAge升序排序:**年龄并返回前n个元素**  --默认升序  ==下面同样写法
userList.stream().sorted(Comparator.comparing(User::getAge)).limit(2);

//返回 对象集合以UsergetAge升序排序:**年龄并去除前 n 个元素**  --默认升序 ==下面同样写法
userList.stream().sorted(Comparator.comparing(User::getAge)).skip(2);

//返回 对象集合以UsergetAge升序 getFraction升序
userList.stream().sorted(Comparator.comparing(User::getAge).thenComparing(User::getFraction));

//先以getAge升序,升序结果进行getAge降序,再进行getFraction升序
userList.stream().sorted(Comparator.comparing(User::getAge).reversed().thenComparing(User::getFraction));

//先以getAge降序,再进行getFraction升序
userList.stream().sorted(Comparator.comparing(User::getAge, Comparator.reverseOrder()).thenComparing(User::getFraction));

//先以getAge升序,升序结果进行getAge降序,再进行getFraction降序
userList.stream().sorted(Comparator.comparing(User::getAge).reversed().thenComparing(User::getFraction, Comparator.reverseOrder()));

//先以getAge降序,再进行getFraction降序
userList.stream().sorted(Comparator.comparing(User::getAge, Comparator.reverseOrder()).thenComparing(User::getFraction, Comparator.reverseOrder()));

//先以getAge升序,升序结果进行getAge降序,再进行getFraction升序,结果进行getAge降序getFraction降序
userList.stream().sorted(Comparator.comparing(User::getAge).reversed().thenComparing(User::getFraction).reversed());

//先以getAge升序,再进行getFraction降序
userList.stream().sorted(Comparator.comparing(User::getAge).thenComparing(User::getFraction, Comparator.reverseOrder()));

}

4、过滤方法 filter(T -> boolean)
保留 boolean 为 true 的元素
ist = list.stream()
.filter(s -> s.getAge() > 20)
.collect(Collectors.toList());
说明：过滤年龄大于20的人员。

5、限制条件 limit(long n)
返回前n个数据
list = list.stream()
.limit(5)
.collect(Collectors.toList());
6、限制条件 skip(long n)
去除前 n 个元素
list = list.stream()
.skip(5)
.collect(Collectors.toList());
7、flatMap(T -> Stream<R>)
将流中的每一个元素 T 映射为一个流，再把每一个流连接成为一个流
List<String> list = new ArrayList<>();

list = list.stream().map(s -> s.split(" ")).flatMap(Arrays::stream).collect(Collectors.toList());
上面例子中，我们的目的是把 List 中每个字符串元素以" "分割开，变成一个新的 List<String>。
首先 map 方法分割每个字符串元素，但此时流的类型为 Stream<String[ ]>，因为 split 方法返回的是 String[ ] 类型；所以我们需要使用 flatMap 方法，先使用Arrays::stream将每个 String[ ] 元素变成一个 Stream<String> 流，然后 flatMap 会将每一个流连接成为一个流，最终返回我们需要的 Stream<String>
8、anyMatch(T -> boolean)
流中是否有一个元素匹配给定的 T -> boolean 条件
是否存在一个 person 对象的 age 等于 20：
boolean b = list.stream().anyMatch(s -> s.getAge() == 20);
9、allMatch(T -> boolean)
流中是否所有元素都匹配给定的 T -> boolean 条件
boolean b = list.stream().allMatch(s -> s.getAge() == 20);
10、noneMatch(T -> boolean)
流中是否所有元素都匹配给定的 T -> boolean 条件
boolean b = list.stream().noneMatch(s -> s.getAge() == 20);
11、findAny() 和 findFirst()
findAny()：找到其中一个元素 （使用 stream() 时找到的是第一个元素；使用 parallelStream() 并行时找到的是其中一个元素）
Optional<Integer> any = list.stream().filter(x -> x > 1).findAny();
findFirst()：找到第一个元素
Optional<Integer> first = list.stream().findFirst();
12、reduce((T, T) -> T) 和 reduce(T, (T, T) -> T)
用于组合流中的元素，如求和，求积，求最大值等
计算年龄总和：
int sum = list.stream().map(Person::getAge).reduce(0, (a, b) -> a + b);
int sum = list.stream().map(Person::getAge).reduce(0, Integer::sum);
计算年龄总乘积：
int sum = list.stream().map(Person::getAge).reduce(1, (a, b) -> a * b);
Optional<Integer> sum = list.stream().map(Person::getAge).reduce(Integer::sum);
13、count() 返回流中元素个数，结果为 long 类型
list.stream().map(Person::getAge).count()
14、collect() 收集
.collect(Collectors.toList());
15、forEach() 循环
list.stream().forEach(System.out::println);
list.stream().forEach(PersonMapper::insertPerson);



import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
* @Author: Liu Yue
* @Descripition:
* @Date; Create in 2021/3/30 9:34
**/
public class Test {

public static void main(String[] args) {
List<Person> list = new ArrayList<>();

list = list.stream()
.limit(2)
.collect(Collectors.toList());
list.stream().forEach(System.out::println);

System.out.println(list.stream().map(Person::getAge).count());
int sum = list.stream().map(Person::getAge).reduce(0, (a, b) -> a + b);
System.out.println(sum);
System.out.println(list.stream().map(Person::getAge).reduce(0, Integer::sum));
System.out.println(list.stream().map(Person::getAge).count());
}
}

import lombok.Data;

/**
* @Author: Liu Yue
* @Descripition:
* @Date; Create in 2021/3/30 9:37
**/
@Data
public class Person {

public  Person(){
}
public  Person(String name,int age){
this.name = name;
this.age = age;
}
private String name;
private int age;
}

16、根据某个字段去除重复，其中getReportProject是项目名称，list根据项目名称过滤重复的项目名称的数据

 ArrayList<HkUserReport> collect = tem1.stream().
collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(
Comparator.comparing(HkUserReport::getReportProject))), ArrayList::new));

0 评论
1 收藏
0