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
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
