https://blog.csdn.net/y_k_y/article/details/84633001
（1）概念
Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。
特点：
1 . 不是数据结构，不会保存数据。
2. 不会修改原来的数据源，会产生一个新流。
3. 惰性求值，流在中间处理过程中，只是对操作进行了记录，并不会立即执行，需要等到执行终止操作的时候才会进行实际的计算。
集合关注的是数据，流关注的是计算。
（2）操作
- 创建Stream：一个数据源（集合、数组），获取一个流。
- 中间操作：对数据源的数据进行处理。
- 终止操作：产生结果。
package Stream;
import org.junit.Test;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* @autour zdc
* @create 2020-03-20-22:45
*/
public class _1Test {
private List<Person> people = Arrays.asList(
new Person("zd2",11,22.3), new Person("zd2",11,22.3),
new Person("zdi",12,11d),new Person("zdi",12,11d),
new Person("zdt",113,222.3),
new Person("zdf",114,22.33),
new Person("zdf",117,22.3),
new Person("zddsd",8,22.3),
new Person("zdcfff",1100,22.3)
);
@Test
public void test1(){
//1.通过Collection提供的stream()或parrallelStream()方法
List<String> list = new ArrayList<>();
Stream<String> stream = list.stream();
//2.通过Arrays的stream()
Person[] people = new Person[10];
Stream<Person> stream1 = Arrays.stream(people);
//3.通过Stream类中的静态方法of()
Stream<String> stream2 = Stream.of("aa", "bb", "cc");
//4.创建无限量
//迭代
Stream.iterate(0, x -> x + 2).limit(10).forEach(System.out::println);
//
Stream.generate(()->Math.random()).limit(10).forEach(System.out::println);
}
/*
* 中间操作 ：多个中间操作可以连接成一个流水线，而在终止操作一次性执行全部，叫做惰性求值。
* filter(Predicate p) 过滤流
* skip(long maxSize) 跳过前几个元素，若流中元素不足n个，返回一个空流
* distinct 删除重复元素（比较hashcode equals）
*
* 映射:
* map(Function f)- 接收一个函数作为参数(接收function)，该函数会被应用到每个元素，并将其映射成一个新的元素
* flapMap(Function f)- 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
* flapMap接收Function，function必须返回一个Stream对象！！！！！
*
* 排序:
* sorted() Comparable 某个类实现了Comparable接口，会自然排序
* sorted(Comparator comparator) Comparator 定制排序
*
* 终止操作:
* allMatch()
* anyMatch()
* noneMatch()
* findFirst()
* findAny()
* count()
* max(Comparator con)
* min(Comparator con)
* forEnch(Consumer con)
*
* reduce(T iden,BinaryOperator b)
* reduce(BinaryOperator b)
*
* collect(Collector c)对流执行收集操作 如收集到list set map
* */
@Test
public void test2(){
List<Person> list = new ArrayList<Person>();
//filter是中间操作 forEach是终止操作
people.stream().filter((x)->x.getAge()<100).skip(1).distinct().forEach(p->list.add(p));
System.out.println(list);
//映射
people.stream().map((person -> {
person.setName(person.getName()+"希特勒");
return person;
})).forEach(System.out::println);
Stream<Stream<Character>> stream = people.stream().map(person -> {
//将每一个人的名字中每个字符取出来作为一个List --> Map<Stream<Character>)>
List<Character> list1 = new ArrayList<>();
for (Character character : person.getName().toCharArray()) {
list1.add(character);
}
return list1.stream();
});
// stream.forEach(sm->{
// sm.forEach(System.out::println);
// });
//flapMap- 接收一个函数作为参数，该函数必须返回Stream对象，将流中的每个值都换成另一个流，然后把所有流连接成一个流
Stream<Character> characterStream = people.stream().flatMap(person -> {
List<Character> list1 = new ArrayList<>();
for (Character character : person.getName().toCharArray()) {
list1.add(character);
}
return list1.stream();
});
characterStream.forEach(System.out::println);
people.stream().sorted(Comparator.comparing(Person::getAge)).forEach(System.out::println);
List<String> list1 = Arrays.asList("a", "sss", "ssdd", "eeff", "hwojd");
System.out.println( list1.stream().allMatch((str) -> str.length() > 1));
System.out.println(list1.stream().anyMatch((str)->str.startsWith("a")));
System.out.println(list1.stream().noneMatch((str)->str.startsWith("a")));
System.out.println(list1.stream().findFirst().get());
System.out.println(list1.stream().findAny().get());
System.out.println(list1.stream().count());
System.out.println(list1.stream().max(String::compareTo));
System.out.println(list1.stream().max(Comparator.comparingInt(String::length)));
list1.stream().forEach(System.out::println);
List<Integer> integers = Arrays.asList(1, 3, 5, 7, 9);
Integer sum = integers.stream().reduce(0, (x, y) -> x + y);
System.out.println(sum);
Set<Integer> set = integers.stream().collect(Collectors.toSet());
System.out.println( integers.stream().collect(Collectors.averagingInt(x->x))); //求平均值
}
}