Java8新特性3 Stream

https://blog.csdn.net/y_k_y/article/details/84633001

（1）概念

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

特点：

        1 . 不是数据结构，不会保存数据。

        2. 不会修改原来的数据源，会产生一个新流。

        3. 惰性求值，流在中间处理过程中，只是对操作进行了记录，并不会立即执行，需要等到执行终止操作的时候才会进行实际的计算。

集合关注的是数据，流关注的是计算。 

（2）操作

1. 创建Stream：一个数据源（集合、数组），获取一个流。
2. 中间操作：对数据源的数据进行处理。
3. 终止操作：产生结果。

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))); //求平均值

    }
}