Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，
可以执行非常复杂的查找、过滤和映射数据等操作。

Stream操作分类
-中间操作
无状态：unordered() filter() map() mapToInt() mapToLong() mapDouble()
flatMap() flatMapToInt() flatMapToLong() flatMapToDouble() peek()
有状态：distinct() sorted() limit() skip()
-终止操作
非短路操作：forEach() forEachOrdered() toArray() reduce() collect() max() min() count()
短路操作：anyMatch() allMatch() noneMatch() findFirst() findAny()

无状态：指元素的处理不受之前元素的影响；

有状态：指该操作只有拿到所有元素之后才能继续下去。

非短路操作：指必须处理所有元素才能得到最终结果；

短路操作：指遇到某些符合条件的元素就可以得到最终结果，如 A || B，只要A为true，则无需判断B的结果。

-流的常用创建方法
1.使用Collection下的stream()和paralleStream()方法
List list = new ArrayList();
Stream stream = list.stream();
Stream parallelStream = list.parallelStream();

2.使用Arrays中的Stream()方法，将数组转成流
Iteger[] nums = new Integer[10];
Stream stream = Arrays.stream(nums);

3.使用Stream中的静态方法：of() iterate() generate()
Stream stream1 = Stream.of(1,2,3,4,5,6);

Stream Stream2 = Stream.iterate(0, (x) -> x + 2).limit(6);
Stream2.forEach(System.out::println); // 0 2 4 6 8 10

Stream stream3 = Stream.generate(Math::random).limit(2);
Stream3.forEach(System.out::println);

4.使用BufferReader.lines()方法,将每行内容转成流
BufferedReader reader = new BufferedReader(new FileReader(“F:\test_stream.txt”));
Stream lineStream = reader.lines();
lineStream.forEach(Systrm.out::println);

5.使用Pattern.splitAsStream()方法，将字符串分隔成流
Pattern pattern = Pattern.compile(",");
Stream stringStream = pattern.splitAsStream(“a,b,c,d”);
StringStream.forEach(System.out::println);

-流的中间操作
筛选与切片
filter:过滤流中的某些元素
limit(n):获取n个元素
skip(n):跳过n元素，配合limit(n)可实现分页
distinct:通过流中元素的hashcode()和equals()去除重复元素
Stream stream = Stream.of(6, 4, 5, 7, 10, 2, 13, 28);
stream.filter(s -> s > 5) //6 7 10 13 28
.distinct() //6 7 10 13 28
.skip(2) //10 13 28
.limit(2); //10 13
stream.forEach(System.out::println);

映射
map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。

List list = Arrays.asList(“a,b,c”, “1,2,3”);

//将每个元素转成一个新的且不带逗号的元素
Stream s1 = list.stream().map(s -> s.replaceAll(",", “”));
s1.forEach(System.out::println); //abc 123

Stream s3 = list.stream().flatMap(s -> {
//将每个元素转成一个stream
String[] split = s.split(",");
Stream s2 = Arrays.stream(split);
return s2;
});
s3.forEach(System.out::println); //a b c 1 2 3

排序
sorted()：自然排序，流中元素需实现Comparable接口
sorted(Comparator com)：定制排序，自定义Comparator排序器

List list = Arrays.asList(“aa”, “ff”, “dd”);
//String 类自身已实现Compareble接口
list.stream().sorted().forEach(System.out::println);// aa dd ff

Student s1 = new Student(“aa”, 10);
Student s2 = new Student(“bb”, 20);
Student s3 = new Student(“aa”, 30);
Student s4 = new Student(“dd”, 40);
List studentList = Arrays.asList(s1, s2, s3, s4);

// 自定义排序，先按姓名升序，姓名相同则按年龄升序
studentList.stream().sorted(
(o1, o2) -> {
if(o1.getName().equals(o2.getName())){
return o1.getAge - o2.getAge();

}else{
return o1.getName().compareTo(o2.getName());

}
}
).forEach(System.out::println);

消费
peek：如同于map，能得到流中的每一个元素。但map接收的是一个Function表达式，有返回值；而peek接收的是Consumer表达式，没有返回值。
Student s1 = new Student(“aa”, 10);
Student s2 = new Student(“bb”, 20);
List studentList = Arrays.asList(s1, s2);

studentList.stream()
.peek(o -> o.setAge(100))
.forEach(System.out::println);

//结果
Student{name=“aa”, age=100}
student{name=“bb”, age=100}

-流的终止操作

​