Stream API说明
java8中有两大最为重要的改变。第一个是lambda表达式；另一个则是Stream API。
Stream API（java.util.stream）把真正的函数式编程风格引入到java中。这是目前为止对java类库最好的补充，因为Steam API 可以极大的提供java程序员的生产力，让程序员写出更高效、干净、简介的代码
Stream 是 java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用Stream API 来并行执行操作。简言之，Stream API 提供了一种高效且易于使用的处理数据的方式。
为什么要使用Stream API
实际开发中，项目中多数数据源都来自于Mysql，Oracle等。但现在数据源可以更多了，有MongoDB，Redis等，而这些NoSQL的数据就需要java层面去处理。
Stream和Collection集合的区别：Collection是一种静态的内存数据结构，而Stream是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向CPU，通过CPU实现计算。
Stream到底是什么呢？
是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。
”集合讲的是数据，Stream讲的是计算！“
注意
1. Stream 自己不会存储元素
2. Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
3. Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
Stream的操作三个步骤
1 . 创建Stream
一个数据源(如: 集合、数组) ,获取一个流
（1）通过Collection系列集合提供的stream()方法或者parallelStream()方法来创建Stream。
（2）通过Arrays中的静态方法stream()获取数组流。
（3）通过Stream类的静态方法of()获取数组流。
（4）可以使用静态方法 Stream.iterate() 和Stream.generate(), 创建无限流。
（5）创建空流 Stream<String> empty = Stream.empty();
2.中间操作
一个中间操作链，对数据源的数据进行处理
1 - 筛选与切片
1. filter(Predicate<? super T> predicate) --接收lambda，从流中排除某些元素。
2. limit(n) -- 截断流，使其元素不超过给定数量。
3. skip（n）-- 跳过元素，返回一个人扔掉了前n个元素的流。若流中的元素不足n个，则返回一个空流
4. distinct() -- 筛选，通过流所生成元素的hashCode()和equals() 去除重复元素
2 - 映射
1. map(Function f) -- 接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每一元素上，并将其映射成一个新的元素。
2. flatMat(Function f) -- 接收一个函数作为参数，将流中的每一个值都换成另一个流，然后把所有流连接成一个流。
3 - 排序
1. sorted() --自然排序
2. sorted(Comparator com) -- 定制排序
1 - 匹配与查找 1. boolean allMatch(Predicate<? super T> predicate); -- 检查是否匹配所有元素。 2. boolean anyMatch(Predicate<? super T> predicate); -- 检查是否至少匹配一个元素。 3. boolean noneMatch(Predicate<? super T> predicate); -- 检查是否从没有匹配的元素 4. Optional<T> findFirst(); -- 返回第一个元素 5. Optional<T> findAny(); -- 返回当前流中任意一个元素 6. long count(); -- 返回流中元素的总个数 7. Optional<T> max(Comparator<? super T> comparator); -- 返回流中最大值 8. Optional<T> min(Comparator<? super T> comparator); -- 返回流中的最小值 9. void forEach(Consumer<? super T> action); -- 内部迭代 2 - 规约 1.T reduce(T identity, BinaryOperator<T> accumulator); -- 可以将流中元素反复结合起来，得到一个值，返回一个 T 3 - 收集 <R, A> R collect(Collector<? super T, A, R> collector); -- 将流转换为其他形式，接收一个Collector接口的实现,用于给Stream中元素做汇总的方法
3.终止操作(终端操作)
一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用
1 - 匹配与查找
1. boolean allMatch(Predicate<? super T> predicate); -- 检查是否匹配所有元素。
2. boolean anyMatch(Predicate<? super T> predicate); -- 检查是否至少匹配一个元素。
3. boolean noneMatch(Predicate<? super T> predicate); -- 检查是否从没有匹配的元素
4. Optional<T> findFirst(); -- 返回第一个元素
5. Optional<T> findAny(); -- 返回当前流中任意一个元素
6. long count(); -- 返回流中元素的总个数
7. Optional<T> max(Comparator<? super T> comparator); -- 返回流中最大值
8. Optional<T> min(Comparator<? super T> comparator); -- 返回流中的最小值
9. void forEach(Consumer<? super T> action); -- 内部迭代
2 - 规约
1. T reduce(T identity, BinaryOperator<T> accumulator); -- 可以将流中元素反复结合起来，得到一个值，返回一个 T
2. Optional<T> reduce(BinaryOperator<T> accumulator); -- 可以将流中元素反复结合起来，得到一个值，返回一个 Optional <T>
3 - 收集
<R, A> R collect(Collector<? super T, A, R> collector); -- 将流转换为其他形式，接收一个Collector接口的实现,用于给Stream中元素做汇总的方法
代码练习
数据准备
package com.sgl.stream;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/*
<!-- Lombok包 -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.0</version>
<scope>provided</scope>
</dependency>
*/
@Data // get set toString 方法
@AllArgsConstructor //全参构造方法
@NoArgsConstructor //空参构造方法
public class Person {
private int id;
private String name;
private int age;
private double salary;
}
package com.sgl.stream;
import java.util.ArrayList;
import java.util.List;
/**
* 提供用于测试的数据
*
* @author not_simple
* @version 1.0
* @date 2020/5/27 16:31
*/
public class PersonData {
public static List<Person> getPersons(){
List<Person> list =new ArrayList<>();
list.add(new Person(1001,"马化腾",34,1234.33));
list.add(new Person(1002,"马云",12,9876.66));
list.add(new Person(1003,"刘强东",33,3210.11));
list.add(new Person(1004,"雷军",26,7563.12));
list.add(new Person(1005,"李彦宏",65,5555.65));
list.add(new Person(1006,"比尔盖茨",42,9501.43));
list.add(new Person(1007,"任正非",26,4333.32));
list.add(new Person(1008,"扎克伯格",35,2500.32));
return list;
}
}
测试Stream的实例化
package com.sgl.stream;
import org.junit.Test;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;
/**
* 1. Stream 关注的是对数据的运算，与 CPU打交道
* 集合关注的是数据的存储，与内存打交道
*
* 2.
* （1）. Stream 自己不会存储元素
* （2）. Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
* （3）. Stream 操作是延时执行的。这意味着他们会等到需要结果的时候才执行
*
* 3. Stream 执行流程
* （1）. Stream的实例化
* （2）. 一系列的中间操作（过滤、映射、...）
* （3）. 终止操作
*
* 4. 说明：
* 4.1 一个中间操作链，对数据源的数据进行处理
* 4.2 一旦执行中翅操作，就回执行中间操作链，并产生结果。之后，不会再被使用
*
*
*
*
* @author not_simple
* @version 1.0
* @date 2020-6-3 13:28:57
*/
//测试Stream的实例化
public class StreamAPITest {
//通过Collection系列集合提供的stream()方法或者parallelStream()方法来创建Stream。
@Test
public void test1(){
List<Person> list = PersonData.getPersons();
/**
* 流的特性：支持并行流与顺序流
* 并行流：多个线程同时运行
* 顺序流：使用主线程，单线程
*/
// default Stream<E> stream() : 返回一个顺序流
Stream<Person> stream = list.stream();
// default Stream<E> parallelStream() : 返回一个并行流
Stream<Person> parallelStream = list.parallelStream();
}
///创建Stream 方式二: 通过数组
@Test
public void test2(){
int[] arr = new int[] {1,2,3,4,5,6};
// public static <T> Stream<T> stream(T[] array)
IntStream stream = Arrays.stream(arr);
Person person1 = new Person(1001,"sgl",1,123);
Person person2 = new Person(1002,"sgl11",2,143);
Person[] arr1 = new Person[]{person1,person2};
Stream<Person> stream1 = Arrays.stream(arr1);
}
//创建Stream 方式二: 通过Stream类的静态方法of()获取数组流。
@Test
public void test3(){
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
}
//创建Stream方式四： 创建无限流。
@Test
public void test4(){
//迭代
// public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
//遍历前10个偶数
Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);
//生成
// public static<T> Stream<T> generate(Supplier<T> s)
Stream.generate(Math::random).limit(10).forEach(System.out::println);
}
//创建Stream 方式五：创建空流
@Test
public void test5(){
Stream<String> empty = Stream.empty();
}
}
测试Stream的中间操作
package com.sgl.stream;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
/**
* 测试Stream的中间操作
*
* @author not_simple
* @version 1.0
* @date 2020/6/3 14:49
*/
public class StreamAPITest2 {
//1 - 筛选与切片
@Test
public void test1(){
List<Person> list = PersonData.getPersons();
//Stream<T> filter(Predicate<? super T> predicate); --接收lambda，从流中排除某些元素。
Stream<Person> stream = list.stream();
// 练习：查询员工表中薪资大于7000的员工信息
stream.filter(e -> e.getSalary() > 7000 ).forEach(System.out::println);
System.out.println();
//limit(n) -- 截断流，使其元素不超过给定数量。
list.stream().limit(3).forEach(System.out::println);
System.out.println();
//skip（n）-- 跳过元素，返回一个人扔掉了前n个元素的流。若流中的元素不足n个，则返回一个空流
list.stream().skip(3).forEach(System.out::println);
System.out.println();
//distinct() -- 筛选，通过流所生成元素的hashCode()和equals() 去除重复元素
list.add(new Person(1010,"刘庆东",26,33.33));
list.add(new Person(1010,"刘庆东",26,33.33));
list.add(new Person(1010,"刘庆东",26,33.33));
list.add(new Person(1010,"刘庆东",26,33.33));
list.add(new Person(1010,"刘庆东",26,33.33));
list.stream().distinct().forEach(System.out::println);
}
//2 - 映射
@Test
public void test2(){
// map(Function f) -- 接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每一元素上，并将其映射成一个新的元素。
List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
// 练习1：获取员工姓名长度大于3的员工的姓名
List<Person> persons = PersonData.getPersons();
Stream<String> nameStream = persons.stream().map(p -> p.getName());
nameStream.filter(name -> name.length() > 3 ).forEach(System.out::println);
// 练习2:
Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest2::formStringToStream);
streamStream.forEach(s -> s.forEach(System.out::println));
System.out.println();
// flatMat(Function f) -- 接收一个函数作为参数，将流中的每一个值都换成另一个流，然后把所有流连接成一个流。
// 练习2:
list.stream().flatMap(StreamAPITest2::formStringToStream).forEach(System.out::println);
}
// 将一个String 转换成 Stream
public static Stream<Character> formStringToStream(String str){
ArrayList<Character> list = new ArrayList<>();
for (Character c: str.toCharArray()) {
list.add(c);
}
return list.stream();
}
//3 - 排序
@Test
public void test4(){
// sorted() --自然排序
List<Integer> list = Arrays.asList(12, 33, 65, 87, 43, 0, -93, 4);
list.stream().sorted().forEach(System.out::println);
System.out.println();
/*
java.lang.ClassCastException: com.sgl.stream.Person cannot be cast to java.lang.Comparable
抛出异常原因 com.sgl.stream.Person 没有实现Comparable接口
*/
// List<Person> persons = PersonData.getPersons();
// persons.stream().sorted().forEach(System.out::println);
//sorted(Comparator com) -- 定制排序
List<Person> persons = PersonData.getPersons();
persons.stream().sorted( (e1,e2) -> Double.compare(e1.getSalary(),e2.getSalary())).forEach(System.out::println);
}
}
测试Stream的终止操作
package com.sgl.stream;
import org.junit.Test;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* 测试Stream的终止操作
*
* 1 - 匹配与查找
* 1. boolean allMatch(Predicate<? super T> predicate); -- 检查是否匹配所有元素。
* 2. boolean anyMatch(Predicate<? super T> predicate); -- 检查是否至少匹配一个元素。
* 3. boolean noneMatch(Predicate<? super T> predicate); -- 检查是否从没有匹配的元素
* 4. Optional<T> findFirst(); -- 返回第一个元素
* 5. Optional<T> findAny(); -- 返回当前流中任意一个元素
* 6. long count(); -- 返回流中元素的总个数
* 7. Optional<T> max(Comparator<? super T> comparator); -- 返回流中最大值
* 8. Optional<T> min(Comparator<? super T> comparator); -- 返回流中的最小值
* 9. void forEach(Consumer<? super T> action); -- 内部迭代
*
* 2 - 规约
* 1. T reduce(T identity, BinaryOperator<T> accumulator); -- 可以将流中元素反复结合起来，得到一个值，返回一个 T
* 2. Optional<T> reduce(BinaryOperator<T> accumulator); -- 可以将流中元素反复结合起来，得到一个值，返回一个 Optional <T>
* 3 - 收集
* <R, A> R collect(Collector<? super T, A, R> collector); -- 将流转换为其他形式，接收一个Collector接口的实现,用于给Stream中元素做汇总的方法
*
* @author not_simple
* @version 1.0
* @date 2020/6/3 16:27
*/
public class StreamAPITest3 {
// 1 - 匹配与查找
@Test
public void test1(){
List<Person> persons = PersonData.getPersons();
// boolean allMatch(Predicate<? super T> predicate); -- 检查是否匹配所有元素。
// 练习：是否所有员工的年龄都大于18
boolean b = persons.stream().allMatch(e -> e.getAge() > 18);
System.out.println(b);
// boolean anyMatch(Predicate<? super T> predicate); -- 检查是否至少匹配一个元素。
// 练习：是否存在员工的工资大于 10000
boolean anyMatch = persons.stream().anyMatch(e -> e.getSalary() > 10000);
System.out.println(anyMatch);
// boolean noneMatch(Predicate<? super T> predicate); -- 检查是否从没有匹配的元素
// 练习：是否存在员工姓 “雷”
boolean noneMatch = persons.stream().noneMatch(e -> e.getName().startsWith("雷"));
System.out.println(noneMatch);
// Optional<T> findFirst(); -- 返回第一个元素
Optional<Person> first = persons.stream().findFirst();
System.out.println(first);
// Optional<T> findAny(); -- 返回当前流中任意一个元素
Optional<Person> any = persons.stream().findAny();
System.out.println(any);
//并行流
Optional<Person> parPerson = persons.parallelStream().findAny();
System.out.println(parPerson);
}
@Test
public void test2(){
List<Person> persons = PersonData.getPersons();
// long count(); -- 返回流中元素的总个数
long count = persons.stream().filter(e -> e.getSalary() > 5000).count();
System.out.println(count);
System.out.println();
// Optional<T> max(Comparator<? super T> comparator); -- 返回流中最大值
// 练习:返回最高的工资：
Stream<Double> maxSalary = persons.stream().map(e -> e.getSalary());
Optional<Double> max = maxSalary.max(Double::compareTo);
System.out.println(max);
// Optional<T> min(Comparator<? super T> comparator); -- 返回流中的最小值
// 练习：返回最低工资的员工
Optional<Person> min = persons.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
System.out.println(min);
// void forEach(Consumer<? super T> action); -- 内部迭代
persons.stream().forEach(System.out::println);
}
//2 - 规约
@Test
public void test3(){
// T reduce(T identity, BinaryOperator<T> accumulator); -- 可以将流中元素反复结合起来，得到一个值，返回一个 T
// 练习1：计算 1 - 10 的自然数的和
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
Integer reduce = list.stream().reduce(0, Integer::sum);
System.out.println(reduce);
// Optional<T> reduce(BinaryOperator<T> accumulator); -- 可以将流中元素反复结合起来，得到一个值，返回一个 Optional <T>
// 练习2: 计算公司所有员工工资的总和
List<Person> persons = PersonData.getPersons();
Stream<Double> doubleStream = persons.stream().map(e -> e.getSalary());
// Optional<Double> reduce1 = doubleStream.reduce(Double::sum);
Optional<Double> reduce1 = doubleStream.reduce((d1, d2) -> d1 + d2);
System.out.println(reduce1);
}
//3 - 收集
@Test
public void test4(){
// <R, A> R collect(Collector<? super T, A, R> collector); -- 将流转换为其他形式，接收一个Collector接口的实现,用于给Stream中元素做汇总的方法
//练习1：查找工资大于6000的员工
List<Person> persons = PersonData.getPersons();
List<Person> list = persons.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
list.forEach(System.out::println);
System.out.println();
Set<Person> set = persons.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());
set.forEach(System.out::println);
System.out.println();
Collection<Person> collect = persons.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toCollection(ArrayList::new));
collect.forEach(System.out::println);
}
}
2159
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
