一、Stream
A sequence of elements supporting sequential and parallel aggregate operations
Stream 是一组用来解决数组、汇合的 API
Java8 之所以费这么大功夫引入函数式编程，起因有二：
(1)代码简洁函数式编程写出的代码简洁且用意明确，应用 stream 接口让你从此辞别 for 循环
(2) 多核敌对，java 函数式编程使得编写并行程序从未如此简略，你须要的全副就是调用一下 parallel()办法
1、个性：
1、不是数据结构，没有外部存储
2、不反对索引拜访
3、提早计算
4、反对并行
5、很容易生成数组或汇合（List，Set）
6、反对过滤，查找，转换；汇总，聚合等操作
2、Stream 运行机制
1、Stream 分为 源 source，两头操作，终止操作
2、流的源能够是一个数组，一个汇合，一个生成器办法，一个 I / O 通道等等
3、一个流能够有零个或者多个两头操作，每个两头操作都会返回一个新的流，供下一个操作应用，一个流只会有一个终止操作
4、Stream 只有遇到终止操作，它的源才开始执行遍历操作
二、Stream 的创立
1、通过数组
2、通过汇合
3、通过 Stream.generate 办法来创立
4、通过 Stream.iterate 办法来创立
5、其余 API 创立
package com.msbline.stream;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class StreamDemo {
// 通过数组来生成
static void gen1(){String[] args = {"a","b","c","d"};
Stream<String> stream = Stream.of(args);
stream.forEach(System.out::println);
}
// 通过汇合来生成
static void gen2(){List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
Stream<String> stream = list.stream();
stream.forEach(System.out::println);
}
// 通过 generate 生成
static void gen3(){Stream<Integer> stream = Stream.generate(() ->1);
// stream.limit(3);
stream.limit(3).forEach(System.out::println);
}
// 应用 iterator
static void gen4(){Stream<Integer> stream = Stream.iterate(1, x -> x + 1);
stream.limit(10).forEach(System.out::println);
}
// 其余
static void gen5(){
String str = "abcdefg";
IntStream stream = str.chars();
stream.forEach(System.out::println);
}
public static void main(String[] args) {
// 生成操作
gen1();
System.out.println("gen2--------------------");
gen2();
System.out.println("gen3--------------------");
gen3();
System.out.println("gen4---------------------");
gen4();
System.out.println("gen5---------------------");
gen5();}
}三、Stream 罕用的 API
1、两头操作
(1)过滤 filter
(2)去重 distinct
(3)排序 sorted
(4)截取 limit、skip
(5)转换 map/flatMap
(6)其余 peek
2、终止操作
(1)循环 forEach
(2)计算 min、max、count、average
(3)匹配 anyMatch、allMatch、noneMatch、findFirst、findAny
(4)汇聚 reduce
(5)收集器 toArray collect
3、示例
public static void main(String[] args) {
// 两头操作: 如果调用办法之后返回的后果是 Stream 对象就意味着是一个两头操作
Arrays.asList(1,2,3,4,5).stream().filter((x)->x%2==0)
.forEach(System.out::println);
// 求出后果集中所有偶数的和
int count = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9).stream().filter((x) -> x % 2 == 0)
.mapToInt(x->x).sum();
System.out.println(count);
// 求汇合中的最大值
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
Optional<Integer> max = list.stream().max((a, b) -> a - b);
System.out.println(max.get());
// 求最小值
Optional<Integer> min = list.stream().min((a, b) -> a-b);
System.out.println(min.get());
Optional<Integer> any = list.stream().filter(x -> x % 2 == 0).findAny();
System.out.println(any.get());
Optional<Integer> first = list.stream().filter(x -> x % 2 == 0).findFirst();
System.out.println(first.get());
List<Integer> list1 = Arrays.asList(1, 3, 5, 6);
Stream<Integer> integerStream = list1.stream().filter(x -> {System.out.println("运行办法");
return x % 2 == 0;
});
// System.out.println(integerStream.findFirst().get());
System.out.println(integerStream.findAny().get());
System.out.println("---------------------------------");
// 获取最大值和最小值，然而不应用 min 和 max 办法
List<Integer> list2 = Arrays.asList(1, 3, 5, 6);
Optional<Integer> min1 = list2.stream().sorted().findFirst();
System.out.println(min1.get());
Optional<Integer> max1 = list2.stream().sorted((a, b) -> b - a).findFirst();
System.out.println(max1.get());
Arrays.asList("java","c#","python","scala").stream()
.sorted().forEach(System.out::println);
System.out.println("----------------------------------");
Arrays.asList("java","c#","python","scala").stream()
.sorted((a,b)->a.length()-b.length()).forEach(System.out::println);
// 想将汇合中的元素进行过滤同时返回一个汇合
System.out.println("----------------------------------");
List<Integer> list3 = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> collect = list3.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
collect.forEach(System.out::println);
System.out.println("-----------------------");
// 去重操作
Arrays.asList(1,2,3,3,3,4,5).stream().distinct().forEach(System.out::println);
System.out.println("-----------------------");
Arrays.asList(1,2,3,3,3,4,5).stream().collect(Collectors.toSet()).forEach(System.out::println);
System.out.println("-----------------------");
// 打印 20-30 这样的汇合数据
Stream.iterate(1,x->x+1).limit(50).skip(20).limit(10).forEach(System.out::println);
System.out.println("------------------------");
String str = "11,22,33,44,55";
int sum = Stream.of(str.split(",")).mapToInt(x -> Integer.parseInt(x)).sum();
System.out.println(sum);
int sum1 = Stream.of(str.split(",")).map(x -> Integer.valueOf(x)).mapToInt(x -> x).sum();
System.out.println(sum1);
int sum2 = Stream.of(str.split(",")).mapToInt(Integer::valueOf).sum();
System.out.println(sum2);
int sum3 = Stream.of(str.split(",")).map(Integer::valueOf).mapToInt(x -> x).sum();
System.out.println(sum3);
System.out.println("-------------");
// 创立一组自定义对象
String str2 = "java,scala,python";
Stream.of(str2.split(",")).map(x->new Person(x)).forEach(System.out::println);
System.out.println("-------------");
Stream.of(str2.split(",")).map(Person::new).forEach(System.out::println);
System.out.println("-------------");
Stream.of(str2.split(",")).map(x->Person.build(x)).forEach(System.out::println);
System.out.println("-------------");
Stream.of(str2.split(",")).map(Person::build).forEach(System.out::println);
System.out.println("-------------------");
// 将每个值都打印进去，同时算出最终的求和后果
String str1 = "11,22,33,44,55";
int sum4 = Stream.of(str1.split(",")).peek(System.out::println).mapToInt(Integer::valueOf).sum();
System.out.println(sum4);
System.out.println(list.stream().allMatch(x -> x == 0));
System.out.println(list.stream().allMatch(x -> x >= 0));
System.out.println(list.stream().anyMatch(x -> x >= 0));
}