Java基础25–Stream的概述
Stream的概述
Java8中有两大最为重要的改变,一个是Lambda表达式,另一个是Stream API。Stream API(java.util.stream)把真正的函数式编程风格引入到Java中,这是目前为止对Java最好的补充,因为Stream API可以极大的提高java程序员的生产力,让程序员写出高效、干净、简洁的代码。
StreamAPI:
StreamAPI是用来处理数据,处理集合等容器中的数据,处理操作有:查询、筛选、删除、过滤、统计、映射等。
希望能够用类似于SQL语法的形式对Java内存中的数据进行处理。
SQL是对数据库中的数据进行处理。
Stream本身不负责存储数据,存储数据是用集合,数组等数据结构。
Stream只负责对数据进行处理、加工。
Stream的操作分为三步:
1、创建Stream:告知Stream数据的来源是哪里?
2、加工处理:这个过程可以很多步 0~n
3、终结操作:收集结果
一旦终结就不能再加工了,如果要加工需要重新创建Stream。
Stream的特点:
(1)Stream本身不负责存储数据,存储数据是用集合,数组等数据结构。
(2)Stream是不可变,一旦修改,就会产生新的Stream对象。Stream不会修改数据源的数据。
(3)Stream的操作是一个延迟操作。所有的操作都必须延迟到终结操作时,一起处理(不到最后一步不处理)。
示例:
@Test
public void test01(){
ArrayList<Employee> list= new ArrayList<>();
list.add(new Employee(1,"张三"));
list.add(new Employee(1,"张三"));
Stream<Employee> stream = list.stream();
stream = stream.distinct();//处理,中间操作,去掉重复的元素
long count = stream.count();//统计个数 终结操作
System.out.println(count);
System.out.println("over");
System.out.println("--------------------");
//重新遍历list
//会发现list的数据还是两个,没有删除,说明Stream不会修改数据源的数据,只是统计去掉元素后元素的个数
for (Employee employee : list) {
System.out.println(employee);
}
}
}
class Employee{
private int id;
private String name;
public Employee(int id, String name) {
super();
this.id = id;
this.name = name;
}
public Employee() {
super();
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Employee [id=" + id + ", name=" + name + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + id;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
System.out.println("比较....");
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Employee other = (Employee) obj;
if (id != other.id)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
重写了hascode和equals方法
运行结果over,说明走过最后的代码到最后,但是结果没显示equals被调用, 因为stream = stream.distinct()执行是处理,中间操作,是一个延迟操作,没有结束的时候,相当于还没执行,需要终结Stream,加代码
long count = stream.count();//统计个数 终结操作
System.out.println(count);
再运行发现有调用equals方法
第一步:Stream的创建
Stream接口:
实现类
IntStream
DoubleStream
LongStream
…
一、创建Stream
- 1、方式一:通过集合创建
集合对象.stream()
@Test
public void test01(){
List<Integer> list = Arrays.asList(1,2,3,4,5);
//JDK1.8中,Collection系列集合增加了方法
Stream<Integer> stream = list.stream();
}
//Map中没有这个方法,因为Map里是键值对,遍历的话需要拿到key、value或者enry,Stream不能存在键值对
- 2、方式二:通过数组工具类Arrays
Arrays.stream(数组对象)
@Test
public void test02(){
int[] arr = {1,2,3,4,5};
IntStream stream = Arrays.stream(arr);
//int数组返回IntStream
}
@Test
public void test03(){
String[] arr = {"hello","world"};
Stream<String> stream = Arrays.stream(arr);
//返回泛型-String类型的
}
- 3、方式三:Stream接口的静态方法of方法,产生一个有限流
Stream.of(…)
@Test
public void test04(){
Stream<Integer> stream = Stream.of(1,2,3,4,5);//有限的数据,有限流
stream.forEach(System.out::println);
}
- 4、方式四:Stream接口的静态方法,产生无限两种方式
(1)generate方法,产生无限流
(2)Stream<T> iterate(T seed, UnaryOperator<T> f)
//方式一
@Test
public void test05(){
Stream<Double> stream = Stream.generate(Math::random);
stream.forEach(System.out::println);
}
//无限的数据,无限流
无限输出产生的数据
//方式二
@Test
public void test06(){
/*
* Stream<T> iterate(T seed, UnaryOperator<T> f)
* UnaryOperator接口,SAM接口,抽象方法:
*
* UnaryOperator<T> extends Function<T,T>
* T apply(T t)
*/
Stream<Integer> stream = Stream.iterate(1, num -> num+=2);
// stream = stream.limit(10);//限制循环10个数
stream.forEach(System.out::println);
}
无限流,n=1,n=n+2的无限循环
第二步:Stream的中间操作
中间的加工操作
(1)filter(Predicate p):过滤
@Test
public void test01(){
//1、创建Stream
Stream<Integer> stream = Stream.of(1,2,3,4,5,6);
//2、加工处理
//过滤:filter(Predicate p)
//把里面的偶数拿出来
/*
* filter(Predicate p)
* Predicate是函数式接口,抽象方法:boolean test(T t)
*/
stream = stream.filter(t -> t%2==0);
//流修改后需要重新接收,否则报错
//3、终结操作:例如:遍历
stream.forEach(System.out::println);
}
还可以把三个步骤连在一起写
@Test
public void test02(){
Stream.of(1,2,3,4,5,6)//创建
.filter(t -> t%2==0)//过滤
.forEach(System.out::println);//遍历
}
(2)distinct():去重
@Test
public void test03(){
Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
.distinct()
.forEach(System.out::println);
}
(3)limit(long maxSize):取有限的几个
@Test
public void test04(){
Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
.limit(3)
.forEach(System.out::println);
}
@Test
public void test05(){
Stream.of(1,2,2,3,3,4,4,5,2,3,4,5,6,7)
.distinct() //(1,2,3,4,5,6,7)
.filter(t -> t%2!=0) //(1,3,5,7)
.limit(3)
.forEach(System.out::println);
}
(4)skip(long n):跳过n个
@Test
public void test06(){
Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
.skip(5)
.forEach(System.out::println);
}
@Test
public void test07(){
Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
.skip(5)//6,2,2,3,3,4,4,5
.distinct()//6,3
.filter(t -> t%3==0)
.forEach(System.out::println);
}
(5)peek(Consumer action) 接收Lambda表达式,对流中的每个数据执行Lambda体操作
@Test
public void test08(){
long count = Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
.distinct()
.peek(System.out::println) //打印
//Consumer接口的抽象方法 void accept(T t)
//这是中间操作,还不能打印出来,没有终止是不执行的
.count();//终止 统计
System.out.println("count="+count);
}
(6)sorted():排序,按照自然排序
sorted(Comparator com):排序,按照定制排序
//定制排序
@Test
public void test09(){
//希望能够找出前三个最大值,前三名最大的,不重复
Stream.of(11,2,39,4,54,6,2,22,3,3,4,54,54)
.distinct()
.sorted()
.limit(3)
.forEach(System.out::println);
}
输出最小的三个数
//定制排序
@Test
public void test09(){
//希望能够找出前三个最大值,前三名最大的,不重复
Stream.of(11,2,39,4,54,6,2,22,3,3,4,54,54)
.distinct()
.sorted((t1,t2) -> -Integer.compare(t1, t2))//Comparator接口 int compare(T t1, T t2)
.limit(3)
.forEach(System.out::println);
}
//Integer前加一个负号,不然返回的是最小的前三个数
//因为加了一个负号,不能再优化
(7)map(Function f):接收Lambda表达式,对流中的每个数据,执行Lambda体操作,返回新的数据构成新的流
@Test
public void test10(){
Stream.of(1,2,3,4,5)
.map(t -> t+=1)//Function<T,R>接口抽象方法 R apply(T t)
.forEach(System.out::println);
}
每个数加了1
//将字符串变为大写
@Test
public void test11(){
String[] arr = {"hello","world","java"};
Arrays.stream(arr)
.map(t->t.toUpperCase())
.forEach(System.out::println);
}
(8)flatMap(Function f)
map(Function<? super T,? extends R> mapper) //map操作流中的把T对象变成R对象,由R对象构成新的流
flatMap(Function<? super T,? extends Stream<? extends R>> mapper)
//flatMap把流中的数据T对象压扁变成一个Stream,然后把一个个的Stream最后再合成一个大的Stream
@Test
public void test12(){
String[] arr = {"hello","world","java"};
Stream<String> flatMap = Arrays.stream(arr)
.flatMap(t -> Stream.of(t.split("|")));//Function<T,R>接口抽象方法 R apply(T t) 现在的R是一个Stream
flatMap.forEach(System.out::println);
}
拆分成一个一个的,再合成一个大的Stream
第二步:Stream的终结操作
创建:一步
中间:0~n步
终结:一步
三、终结操作
1、void forEach(Consumer ):遍历流中的数据(不一定是打印)
@Test
public void test01(){
Stream.of(1,2,3,4,5)
.forEach(System.out::println);
}
2、long count():统计个数**
@Test
public void test02(){
long count = Stream.of(1,2,3,4,5)
.count();
System.out.println("count = " + count);
}
3、boolean allMatch(Predicate p):是否全部 满足xx条件
boolean anyMatch(Predicate p):是否有一个满足xx条件
boolean noneMatch(Predicate p):是否全部都不满足xx条件
@Test
//判断是否都是奇数
public void test03(){
boolean result = Stream.of(1,3,5,7,9)
.allMatch(t -> t%2!=0);
System.out.println(result);
}
//判断是否有满足偶数的
@Test
public void test04(){
boolean result = Stream.of(1,3,5,7,9,6)
.anyMatch(t -> t%2==0);
System.out.println(result);
}
4、
Optional findFirst():返回第一个
Optional findAny():返回任意一个
@Test
public void test08(){
Optional<Integer> opt = Stream.of(1,3,5,7,9).findFirst();
System.out.println(opt);
}
返回的是Optional
@Test
public void test09(){
Optional<Integer> opt = Stream.of(1,2,3,4,5,7,9)
.filter(t -> t%3==0)
.findFirst();
System.out.println(opt);
}
@Test
public void test09(){
Optional<Integer> opt = Stream.of(1,2,3,4,5,7,9)
.filter(t -> t%3==0)
.findAny();
System.out.println(opt);
}
若是稳定的流,findAny()默认返回的值和findFirst()一样,若是无限流、平行流等不稳定的流,每次返回的结果不一样,若是稳定的流,一般用findFirst()代替findAny()
//若是结果为空的
@Test
public void test10(){
Optional<Integer> opt = Stream.of(1,2,4,5,7,8)
.filter(t -> t%3==0)
.findFirst();
System.out.println(opt);
}
//没有3的倍数,返回Optional.empty,不会是null,这就是Optional存在的意义,取代了原来的空指针异常的方式的处理,Optional不返回null,返回Optional.empty
没有3的倍数,返回Optional.empty,不会是null,这就是Optional存在的意义,取代了原来的空指针异常的方式的处理,Optional不返回null,返回Optional.empty
5、Optional max(Comparator c):找出最大的
Optional min(Comparator c) :找出最小的
@Test
public void test11(){
Optional<Integer> max = Stream.of(1,2,4,5,7,8)
.max((t1,t2) -> Integer.compare(t1, t2));
System.out.println(max);
}
返回的也是一个包装起来的值
6、
T reduce(T iden, BinaryOperator b) 通过反复的运算,留下最后一个结果
Optional reduce(BinaryOperator b)
@Test
public void test12(){
Integer reduce = Stream.of(1,2,4,5,7,8)
.reduce(0, (t1,t2) -> t1+t2);//BinaryOperator接口 T apply(T t1, T t2)
System.out.println(reduce);
}
运算过程:0相当于起点,再将(1,2,4,5,7,8)累加
@Test
public void test12(){
Integer reduce = Stream.of(1,2,4,5,7,8)
.reduce(0, (t1,t2) -> t1>t2?t1:t2);//BinaryOperator接口 T apply(T t1, T t2)
System.out.println(reduce);
}
两两比较,大的留下
//reduce重载的方法
@Test
public void test13(){
Optional<Integer> reduce = Stream.of(1,2,4,5,7,8)
.reduce((t1,t2) -> t1>t2?t1:t2);//BinaryOperator接口 T apply(T t1, T t2)
System.out.println(reduce);
}
7、R collect(Collector c):把流中的数据最后都收集到一起(可能收集到集合里、数组里等,都有可能)
//把偶数收集过来
@Test
public void test14(){
List<Integer> list = Stream.of(1,2,4,5,7,8)
.filter(t -> t%2==0)
.collect(Collectors.toList());
//还有Collectors.toSet()、Collectors.toMap()等
System.out.println(list);
}
Collector接口
BiConsumer 抽象方法 void accept(R r,T t)
Optional类
案例:
class Student{
private String name;
private int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Student() {
super();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
}
@Test
public void test1(){
ArrayList<Student> list = new ArrayList<>();
list.add(new Student("张三", 23));
//...
//取出流中第一个年龄大于30岁的学生
//返回的是Optional
Optional<Student> opt = list.stream()
.filter(s -> s.getAge()>30)
.findFirst();//这步返回的是Optional.empty,若是没有Optional,返回的是null,若是null,下一步操作打印学生的年龄,
//System.out.println("学生的年龄:" + stu.getAge());会报空指针异常,为了避免空指针异常,就得加各种判断,!null的判断,Optional类可以避免空指针异常
//打印该学生的年龄
Student stu = opt.orElse(new Student());
System.out.println("学生的年龄:" + stu.getAge());
}
//Optional类得到null,初始化一个student,返回它的默认值0
Optional类最开始就是为了解决和避免空指针异常的处理、判断这些
Optional实际上是个容器,它是一个装一个对象的容器。这个对象可能是个空,可能是非空。
数组和集合是装多个对象的容器。
- 1、创建Optional对象的方法:(没有构造器,构造器私有化了)
(1)Optional.of(xx); 只能装非空对象,不然会报错
(2)Optional.ofNullable(x); 装可以是null的对象
(3)Optional empty() 直接返回一个空箱子对象
@Test
public void test2(){
String str = "hello";
Optional<String> opt = Optional.of(str);
System.out.println(opt);
}
@Test
public void test3(){
String str = null;
Optional<String> opt = Optional.ofNullable(str);
System.out.println(opt);
}
- 2、如何取出Optional容器中的对象(将装好的对象拿出来)
(1)get() 必须配合of(xx)使用,因为这里面的对象不能是null,否则会报没有这样的值存在(NO value present)
@Test
public void test4(){
String str = "hello";
Optional<String> opt = Optional.of(str);
String string = opt.get();
System.out.println(string);
}
若是容器里是null
@Test
public void test5(){
String str = null;
Optional<String> opt = Optional.ofNullable(str);
// System.out.println(opt.get());//java.util.NoSuchElementException: No value present
}
会报错java.util.NoSuchElementException: No value present
(2)orElse(T other) 如果Optional容器中的对象是空的,用other代替
@Test
public void test6(){
String str = "null";
Optional<String> opt = Optional.ofNullable(str);
String string = opt.orElse("atguigu");
//若是容器里是空的,返回atguigu
System.out.println(string);
}
@Test
public void test6(){
String str = "hello";
Optional<String> opt = Optional.ofNullable(str);
String string = opt.orElse("atguigu");
System.out.println(string);
}
若是容器非空,返回容器里的值
(3)orElseGet(Supplier<? extends T> other) 如果Optional容器中的对象是空的,用other这个供给型接口提供的对象代替
@Test
public void test7(){
String str = hello;
Optional<String> opt = Optional.ofNullable(str);
String string = opt.orElseGet(String::new);
System.out.println(string);
}
若是str为null
@Test
public void test7(){
String str = null;
Optional<String> opt = Optional.ofNullable(str);
String string = opt.orElseGet(String::new);
System.out.println(string);
}
返回空字符串,不会报错
(4)orElseThrow(Supplier<? extends X> exceptionSupplier) (容器里没有值,可以用自定义异常)
@Test
public void test8(){
String str = null;
Optional<String> opt = Optional.ofNullable(str);
String string = opt.orElseThrow(()->new RuntimeException("值不存在"));
System.out.println(string);
}
- 3、其他操作
Optional filter(Predicate<? super T> predicate)
@Test
public void test9(){
String str = "hello";
Optional<String> opt = Optional.ofNullable(str);
Optional<String> opt2 = opt.filter(s->s.length()>5);//长度大于5就留下,否则不要
System.out.println(opt2);
}
不满足返回Optional.empty