Java8的两个重大改变,一个是Lambda表达式,另一个就是本节要讲的Stream API表达式。Stream 是Java8中处理集合的关键抽象概念,它可以对集合进行非常复杂的查找、过滤、筛选等操作,在新版的JPA【连接数据库】中,也已经加入了Stream。如:
@Query("select u from User u")
Stream findAllByCustomQueryAndStream();
Stream readAllByFirstnameNotNull();
@Query("select u from User u")
Stream streamAllPaged(Pageable pageable);
Stream API给我们操作集合带来了强大的功用,同时Stream API操作简单,容易上手。
- 创建Stream 从一个数据源,如集合、数组中获取流。
- 中间操作 一个操作的中间链,对数据源的数据进行操作。
- 终止操作 一个终止操作,执行中间操作链,并产生结果
假设我们现在有一个List
- 拿到所有姓张的
- 拿到名字长度为3个字的
- 打印这些数据
下面代码为大家展现Stream流与JDK8之前对该需求的操作方法:
package test.StreamTest;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* @作者:徐志豪
* @创建时间 2022/7/20 20:16
* 为什么要使用Stream流 书写优雅,提高性能
**/
public class WhyWeUseStream {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰");
//需求:1.拿到所有姓张的 2.拿到名字长度为3个字的 3.打印这些数据
//传统做法 for循环,new新的ArrayList存放需求的数据
//1.拿到所有姓张的
List nameList = new ArrayList<>();
for (String s : list) {
if (s.startsWith("张")){
nameList.add(s);
}
}
//2.拿到名字长度为3个字的
List lengthList = new ArrayList<>();
for (String s : list) {
if (s.length()==3){
lengthList.add(s);
}
}
//3.打印这些数据
for (String s : nameList) {
System.out.println(s);
}
System.out.println("------------");
for (String s : lengthList) {
System.out.println(s);
}
System.out.println("+++++++++++++++++++++++++++++++");
//Stream流实现上述需求
//1.拿到所有姓张的并打印
list.stream()
.filter((str)->str.startsWith("张"))
.forEach(System.out::println);
System.out.println("------------");
//2.拿到名字长度为3个字的并打印
list.stream()
.filter((str)->str.length()==3)
.forEach(System.out::println);
}
}
我们可以看到传统做法想要实现上述的需求,需要不断的循环和创建新的集合来接操作后的数组,这样性能不高,而且比较繁琐
Stream流操作中,其中 list.stream()是创建stream流,filter()属于中间操作,forEach()属于终止操作。具体这三个操作步骤会在下面详细讲述:
(1)通过Collection对象的Stream()或parallerStream()方法
List list = new ArrayList<>();
//串行 单线程
Stream stream = list.stream();
//并行 多线程
Stream stringStream = list.parallelStream();
(2)通过Arrays类的Stream()方法
Integer[] arr = {1,2,3,4,5,6};
Stream stream1 = Arrays.stream(arr);
(3)通过Stream接口的of(),iterate(),generate()方法
Stream integerStream = Stream.of(1, 2, 3, 4, 5, 6, 7);
Stream stringStream1 = Stream.of("1", "2", "3", "4");
(4)通过IntStream,LongStream,DoubleStream接口中的of(),range(),rangeClosed()方法
IntStream intStream = IntStream.of(1, 2, 3, 4, 5, 6);
DoubleStream doubleStream = DoubleStream.of(1.1, 2.2, 3.3, 4.4, 5.5);
用下面这个集合来举例:
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰","张无忌");
}
(1).limit(n) 从list中取出n个元素
list.stream().limit(2).forEach(System.out::println);
(2).skip(n) 从list第n个元素开始,取出所有元素
list.stream().skip(3).forEach(System.out::println);
(3).distinct() 去除重复
list.stream().distinct().forEach(System.out::println);
(4).filter(Predicate predicate) 筛选条件
括号中的内容为一个断言型函数式接口,其中的T为当前集合中元素的类型。
下面的中间操作我们换一个集合来举例,为大家附上集合代码,直接cv拿来用就可以:
Person类:
class Person {
private String name;
private Integer age;
private String country;
private char sex;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getCountry() {
return country;
}
public void setCountry(String country) {
this.country = country;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", country='" + country + '\'' +
", sex=" + sex +
'}';
}
public Person(String name, Integer age, String country, char sex) {
this.name = name;
this.age = age;
this.country = country;
this.sex = sex;
}
}
PersonList集合:
public static void main(String[] args) {
List personList = new ArrayList<>();
personList.add(new Person("欧阳雪",18,"中国",'F'));
personList.add(new Person("Tom",24,"美国",'M'));
personList.add(new Person("Harley",22,"英国",'F'));
personList.add(new Person("向天笑",20,"中国",'M'));
personList.add(new Person("李康",22,"中国",'M'));
personList.add(new Person("小梅",20,"中国",'F'));
personList.add(new Person("何雪",21,"中国",'F'));
personList.add(new Person("李康",22,"中国",'M'));
}
由此可见,在我们这个例子中,filter()中的内容中的T应该为Person类。
我们知道断言型函数式接口返回值为boolean,所以他的用法就是让结果是true的元素留下,结果是false的元素筛选掉。
找出年龄大于20的人并打印输出:
personList.stream()
.filter((person)->person.getAge()>20)
.forEach(System.out::println);
(5).map(Function mapper ) 将元素转换成其他形式或提取信息。
其中的T在这里应为Person
.map() 接收一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新的元素。就好比将现有元素,经过map方法处理过后,变成一个新的元素,这个元素就是你想过滤后的,你需要的元素,过滤的要求就是map中的Function函数型函数式接口。
打印出集合中所有人的年龄各式多少:
personList.stream()
.map((person -> person.getAge()))
.forEach(System.out::println);
这里的map中的Lambda表达式可以转换为实例方法引用的形式:
.map((Person::getAge))
(6).sorted() / .sort(Comparator comparator) 对元素进行排序
我们可以看到这个操作方法进行了重载,可以是无参(自带默认排序)或是传入一个比较器参数(自定义排序规则)
打印出所有的中国人并按照年龄升序排序:
personList.stream()
.filter((p) -> p.getCountry().equals("中国"))
.sorted((p1,p2)->p1.getAge()-p2.getAge())
.forEach(System.out::println);
(1).count() 计算元素的个数
求中国人的个数并打印输出:
long num = personList.stream()
.filter((p) -> p.getCountry().equals("中国"))
.count();
System.out.println("中国人的个数为"+num);
(2).forEach() 遍历
遍历元素,一般用于遍历输出。
打印输出所有元素:
personList.stream().forEach(System.out::println);
(3).reduce () 规约 元素反复结合,得到一个值 传参方式有如下两种:
Integer identity,BinaryOperatoraccumulator
BinaryOperatoraccumulator
第一种传参方式的第一个参数为默认值,后面的参数为合并方式。
第二种传参方式与第一种的第二个参数相同
求元素中的年龄总和:
Optional reduce = personList.stream()
.map((person -> person.getAge()))
.reduce((a1, a2) -> a1 + a2);
System.out.println(reduce.get());
(4).collect() 收集 将流转换为其他形式
参数 接收一个Collector接口实现 ,用于给Stream中汇总的方法 ,常见的有Collecters.toList等等
将元素中年龄大于20的人收集并转为list:
List collect = personList.stream()
.filter((person -> person.getAge() > 20))
.collect(Collectors.toList());
System.out.println(collect);
(5).max(Comparator comparator) 最大值 传入一个比较器参数
.min(Comparator comparator) 最小值 传入一个比较器参数
求集合中年龄最大的人:
Optional min = personList.stream()
.min((p1, p2) -> p1.getAge() - p2.getAge());
System.out.println(min.get());
求集合中年龄最小的人:
Optional max = personList.stream()
.max((p1, p2) -> p1.getAge() - p2.getAge());
System.out.println(max.get());
(6).allMatch(Predicate predicate) 检查是否匹配所有元素
.anyMatch(Predicate predicate) 检查是否至少匹配一个元素
.noneMatch(Predicate predicate) 检查是否没有匹配所有元素
//match->
// allMatch 都满足返回true
boolean b = personList.stream()
.allMatch((person -> person.getAge() < 25));
System.out.println(b);
// anyMatch 只要有满足条件的就返回true
boolean b1 = personList.stream()
.anyMatch(person -> person.getAge() == 18);
System.out.println(b1);
// noneMatch 都不满足返回true
boolean b2 = personList.stream()
.noneMatch(person -> person.getAge() < 10);
System.out.println(b2);
(7).findFirst() 返回第一个元素
.findAny() 返回当前流中的任意元素
//find ->
// findFirst 返回第一个满足条件的元素
//返回第一个年龄大于20的人
Optional first = personList.stream()
.filter(person -> person.getAge() > 20)
.findFirst();
System.out.println(first.get());
// findAny 随机返回一个满足条件的元素 一般用在parallelStream()中
//随机返回一个中国人
Optional p = personList.parallelStream()
.filter(person -> person.getCountry().equals("中国"))
.findAny();
System.out.println(p.get());