一、概述
将集合或数组 转换成一种流的元素序列。流不是集合中的元素，也不是一种数据结构，不负责数据的存储。Stream 流也不会改变源对象（源集合）Stream 接口中几乎所有方法的参数都是四大函数式接口接口类型的参数。而函数式接口可以使用 lambda 表达式来简化开发，并且 Stream 接口中的方法基本都是返回对象本身（返回对象本身的方法可以使用链式编程）。所以在使用 Stream 流式计算时，基本上都用到了函数式接口、lambda表达式 和 链式编程。
1.1、特性： 不存储数据、不改变数据源、不可重复使用
可以看作一根管道，用于数据的转换，所以不会存储数据，也不会影响原来的数据。因为stream是一根管道，不可重复使用就是stream用完一次之后，数据就输出了
Stream stream1 = Stream.of(1,2,3);
//创建stream2过滤stream1
Stream stream2 = stream1.filter(s->s.equals(1));
//下句代码会出错，因为stream1流用过一次，消失了
Stream stream3 = stream1.filter(s->s.equals(1));
1.2、生成流的方式
Array.stream()-用于基本类型
parallelStream() 是并行流方法，并行流就是把内容分成多个数据块，使用不同的线程分别处理每个数据块的流。
Arrays.stream(new int[]{1,2,3}); //使用Array的静态方法创建流
但要注意的是，不是所有情况的适合，有些时候并行甚至比顺序进行效率更低，而有时候因为线程安全问题，还可能导致数据的处理错误，因此并行的性能问题非常值得我们思考。下面这个例子就比较慢，因为JVM对基本类型还要装箱开箱操作，不如直接串行计算了
int i = Stream.iterate(1, a -> a + 1).limit(100).parallel().reduce(0, Integer::sum);
Stream.of()-用于任何类型
Stream.of(1,"小明",2,new ArrayList<>()); //使用Stream的静态方法创建流
Stream.iterate-函数流
//iterate() ： 依次对每个新生成的值应用函数; generate() ：接受一个函数，生成一个新的值
//生成流，首元素为 0，之后依次加 2
Stream.iterate(0, n -> n + 2)
//生成流，为 0 到 1 的随机双精度数
Stream.generate(Math :: random)
//生成流，元素全为 1
Stream.generate(() -> 1)
Files.lines()-用于文件流
Stream stream = Files.lines(Paths.get(“data.txt”));
XXX.stream()-用于集合
Collection collection = new ArrayList();
collection.stream(); // 使用Collection类里的成员方法stream()方式创建流
1.3、反转流到集合
一般是用Stream.collect()的方法来实现的，下面给一个转为List的例子
public static void main(String[] args) {
// 将数组变成一个列表集合
List<Integer> list = Arrays.asList(14, 3, 5, 7, 12);
// List集合获取 Stream 流
Stream<Integer> stream = list.stream();
// 操作 Stream 流
List<Integer> collect = stream
// 获取 > 5 的元素
.filter((i) -> { return i > 5; })
// 对元素进行升序排序
.sorted()
// 将 Stream 流转换成 List 集合
.collect(Collectors.toList());
// 遍历 转换后的 List 集合
for (Integer i : collect) {
System.out.println(i);
}
}
二、中间节点与终值节点
2.1、中间节点
懒节点不会自动执行，所以下例代码不会打印hello
public static void main(String[] args) {
List list = new ArrayList();
Stream.of(list).filter(a->{
System.out.println("hello");
return true;
}); //没有打印结果
}
2.2、终值节点
这时在最后加了.toArray()方法，相当于加上了终值节点，那么此时终值节点+前面的节点都会执行
public static void main(String[] args) {
List list = new ArrayList();
Stream.of(list).filter(a->{
System.out.println("hello");
return true;
}).toArray(); //打印输出hello
}
可以查看Stream的API，如果方法的返回值为Stream<T>的基本都是中间节点
三、Stream的方法
常用的方法如下：
- 中间节点：filter()、map()、mapToInt()、flatMap()、sorted()、peek()、reduce()、distinct()
- 终值节点：forEach()、toArray()、collect()
@Data
public class AppleStore {
int id; //编号
String color; //颜色
double weight; //重量
String origin; //产地
}
3.1、迭代：peek()
public class StreamTest {
private static List<AppleStore> appleStores = new ArrayList();
static {
appleStores.add(new AppleStore(1,"red",1.2,"重庆"));
appleStores.add(new AppleStore(2,"red",1.5,"四川"));
appleStores.add(new AppleStore(3,"yellow",2.6,"重庆"));
appleStores.add(new AppleStore(4,"yellow",2.9,"四川"));
appleStores.add(new AppleStore(5,"red",3.2,"杭州"));
}
public static void main(String[] args) {
//peek()是执行每个节点的方法
//peek里的方法会挨个执行，也就是节点会挨个执行，也称作责任链模式
appleStores.stream().peek(appleStore -> System.out.println(appleStore.getColor())) //打印苹果的颜色
.peek(appleStore -> System.out.println(appleStore.getWeight())) //打印苹果的重量
.peek(appleStore -> System.out.println(appleStore.getOrigin())) //打印苹果的产地
.toArray();
}
}
red1.2重庆
red1.5四川
yellow2.6重庆
yellow2.9四川
red3.2杭州
3.2、终点：foreach()
foreach功能和peek相同，不同是foreach是终值节点，也就是不能再往下继续执行，但执行的结果是和上面是一样的。
appleStores.stream().peek(apple -> System.out.println(apple.getColor())) //打印苹果编号
.peek(apple -> System.out.println(apple.getWeight())) //打印苹果颜色
.forEach(sout-> System.out.println(sout.getOrigin()));
red1.2重庆
red1.5四川
yellow2.6重庆
yellow2.9四川
red3.2杭州
3.3、流式处理
3.3.1、过滤：filter(Predicate predicate)
@Test
public void name2() {
appleStores.stream().filter(appleStore -> appleStore.getColor().equals("red")) //过滤出红色的苹果
.peek(appleStore -> System.out.println(appleStore)) //到第二个节点只有红色苹果的数据了
.toArray();
}
AppleStore(id=1, color=red, weight=1.2, origin=重庆)
AppleStore(id=2, color=red, weight=1.5, origin=四川)
AppleStore(id=5, color=red, weight=3.2, origin=杭州)
3.3.2、转换：map(Function<? super T, ? extends R> mapper)
@Test
public void name3() {
//此时数据全部变成了String字符串 因为map中的方法是getColor()，映射成为的是String，对象Stream<String>
appleStores.stream().map(appleStore -> appleStore.getColor()) //获取苹果的颜色
.peek(color -> System.out.print(color+"--"))//循环的是Stream<String>
.toArray();
}
red--red--yellow--yellow--red--
3.3.3、去重：distinct()
@Test
public void name4() {
appleStores.stream().map(appleStore -> appleStore.getColor()) //获取苹果的颜色
.distinct() //去重
.peek(color -> System.out.print(color+"--"))
.toArray();
}
red--yellow
3.3.4、排序：Comparator<? super T> comparator
@Test
public void name5() {
List<Integer> collect = appleStores.stream() // 获取appleStores的流
.map(appleStore -> appleStore.getId()) // 转换功能：获取id，从List<AppleStore>转换成了List<int>
// 从小到大排序 (本质是调用compareTo()方法，所以类要实现CompareAble接口)
.sorted()
//从大到小排序
.sorted(Comparator.reverseOrder())
// 多字段排序，升序排序（先根据年龄排序，如果年龄相同，则年龄相同的用户根据 id 排序），多字段需要自己实现，也可以用自带的API排序
.sorted(Comparator.comparing(User::getAge).thenComparing(User::getId))
.limit(3) // 取前三个元素
.collect(Collectors.toList()); //将stream流转回List集合
System.out.println(collect);
}
3.3.5、截取：limit(long maxSize) 截取（截取前面n个元素）
public static void main(String[] args) {
// 将数组变成一个列表集合
List<Integer> list = Arrays.asList(5, 3, 7, 9, 4);
// 获取集合的 Stream 流对象
list.stream()
// 截取（截取前面前4个元素）
.limit(4)
// 遍历
.forEach(System.out::println);
}
3.3.6、丢弃：skip(long n) 丢弃（丢弃前面n个元素）
public static void main(String[] args) {
// 将数组变成一个列表集合
List<Integer> list = Arrays.asList(5, 3, 7, 9, 4);
// 获取集合的 Stream 流对象
list.stream()
// 丢弃（丢弃前面4个元素）
.skip(4)
// 遍历
.forEach(System.out::println);
}
3.3.7、计数：count() 计数（返回流中元素个数）
public static void main(String[] args) {
// 将数组变成一个列表集合
List<Integer> list = Arrays.asList(5, 3, 7, 9, 4);
// 获取集合的 Stream 流中元素个数
long count = list.stream().count();
}
3.3.8、拼接：concat(Stream<? extends T> a, Stream<? extends T> b) 拼接（对两个流对象进行拼接）
public static void main(String[] args) {
// 将数组变成一个列表集合
List<Integer> list_01 = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> list_02 = Arrays.asList(6, 7, 8, 9, 0);
// 将两个 Stream 流拼接（首尾合并），成一个新的 Stream 流
Stream<Integer> stream = Stream.concat(list_01.stream(), list_02.stream());
stream.forEach(System.out::println);
}
3.3.9、比较：Optional max(Comparator<? super T> comparator) 根据Comparator比较器获取最大的元素
public static void main(String[] args) {
// 将数组变成一个列表集合
List<Integer> list = Arrays.asList(5, 3, 7, 9, 4);
// 获取序列中的值最大的元素
Optional<Integer> max = list.stream().max(Comparator.comparing((integer -> integer)));
// 获取序列中的值最小的元素
Optional<Integer> max = list.stream().min(Comparator.comparing((integer -> integer)));
System.out.println(max.get());
}
3.3.10、分割：flatMap(T -> Stream) 将流中的每一个元素 T 映射为一个流，再把每一个流连接成为一个流
@Test
public void name6() {
List<String> list = new ArrayList<>();
list.add("aaa bbb ccc");
list.add("ddd eee fff");
list.add("ggg hhh iii");
list = list.stream().map(s -> s.split(" ")).flatMap(Arrays::stream).collect(Collectors.toList());
System.out.println(list);
}
//[aaa, bbb, ccc, ddd, eee, fff, ggg, hhh, iii]
3.3.11、匹配: xxxMatch(T -> boolean)
//是否存在一个 person 对象的 age 等于 20：
boolean b = list.stream().anyMatch(person -> person.getAge() == 20);
//是否所有元素都匹配给定的 T -> boolean 条件
boolean result = list.stream().allMatch(Person::isStudent);
//是否没有元素匹配给定的 T -> boolean 条件
boolean result = list.stream().noneMatch(Person::isStudent);
3.3.12、查找：findAny() 和 findFirst()
- indAny()：找到其中一个元素 （使用 stream() 时找到的是第一个元素；使用 parallelStream()并行时找到的是其中一个元素）
- findFirst()：找到第一个元素
值得注意的是，这两个方法返回的是一个 Optional 对象，它是一个容器类，能代表一个值存在或不存在。
3.3.13、归约：reduce((T, T) -> T) 和 reduce(T, (T, T) -> T)
将集合中的所有元素经过指定运算，折叠成一个元素输出，如：求最值、平均数等，这些操作都是将一个集合的元素折叠成一个元素输出。在流中，reduce函数能实现归约。reduce函数接收两个参数：初始值和进行归约操作的Lambda表达式（用于组合流中的元素，如求和，求积，求最大值等）
int age = list.stream().reduce(0, (person1,person2)->person1.getAge()+person2.getAge());
//计算年龄总和：
int sum = list.stream().map(Person::getAge).reduce(0, (a, b) -> a + b);
//与之相同:其中，reduce 第一个参数 0 代表起始值为 0，lambda (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 类型
Optional sum = list.stream().map(Person::getAge).reduce(Integer::sum);
3.4、采集置换：collect()
Stream采集功能分为List、map、group by、数组、求最大值、求任意值等
@Test
public void name5() {
List<Integer> collect = appleStores.stream() // 获取appleStores的流
.map(appleStore -> appleStore.getId()) // 转换功能：获取id，从List<AppleStore>转换成了List<int>
.limit(3) // 取前三个元素
.collect(Collectors.toList()); //将stream流转回List集合，依赖Collectors类中的几个toXxx()方法
System.out.println(collect);
}
[1, 2, 3]
