Stream API

stream介绍

1. java类库的补充，写出更简洁高效的代码。

2. 处理集合的关键抽象概念，操作集合像sql,高效处理数据的方式。

   什么是stream

3. stream 关注的是对数据的运算，与cpu打交道。而集合；存储；内存

4. 特点
   1. 自己不会存储元素
   2. 不可变性
   3. 操作的延迟的，调用了终止操作才会执行。

5. Stream执行流程

   1. 实例化
   2. 中间操作
   3. 终止操作：一旦终止，产生结果之后就不能用了。

      Stream的中间操作

6. 
   

   代码

public class test {
    public static void main(String[] args) {
        /**
         *  创建流的举例
         */
        //1.通过集合
        List<String> l = new ArrayList<>();
        //顺序流
        Stream<String> stream = l.stream();
        //并行流
        Stream<String> stringStream = l.parallelStream();
        //2.通过数组
        Integer[] integers = {1, 2, 3, 4, 4};
        Stream<Integer> stream1 = Arrays.stream(integers);
        //3.通过Stream.of
        Stream<Integer> integers1 = Stream.of(integers);
        //4.无线流
        //迭代
        Stream.iterate(0, T -> T + 2).limit(10).forEach(System.out::println);
        //生成
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
        /**
         * 中间操作
         */
        //1.筛选和切片
        //filter(Predicate p) 从流中过滤排除某些元素
        stream1.filter(t -> Integer.compare(t, 1) > 0).forEach(System.out::println);
        //limit(n) 截断流，使元素不超过给定数量
        Stream<Integer> stream2 = Arrays.stream(integers);
        stream2.filter(t -> Integer.compare(t, 1) > 0).limit(2).forEach(System.out::println);
        // skip(n) 跳过n个元素，不足n个，返回一个空流
        System.out.println("*********************");
        Stream<Integer> stream3 = Arrays.stream(integers);
        stream3.filter(t -> Integer.compare(t, 1) > 0).skip(4).forEach(System.out::println);
        //distinct 筛选，通过hashcode和equals 去除重复的。
        System.out.println("*********************");
        Stream<Integer> stream4 = Arrays.stream(integers);
        stream4.filter(t -> Integer.compare(t, 1) > 0).distinct().forEach(System.out::println);
        //2.映射
        //map(Function f)接收一种元素转换成另外一种形式
        System.out.println("*********************");
        List<String> list = Arrays.asList("aa", "bb");
        list.stream().map(s -> s.toUpperCase()).forEach(System.out::println);
        //flatmap(Function f)接收一种元素，当返回一个流时，打开中括号。
        list.stream().flatMap(test::getCharacterStream).forEach(System.out::println);
        //3.排序
        //sorted/sorted(comparator com)
        System.out.println("*********************");
        List<Integer> list1 = Arrays.asList(1, 31, 5, 123, 2, 3123);
        list1.stream().sorted().forEach(System.out::println);
        /**
         * 终止操作
         */
        //1.匹配与查找
        //allMatch所有元素都匹配
        System.out.println("*********************");
        boolean b = list1.stream().allMatch(i -> i > 1);
        System.out.println(b);
        //anyMatch任意元素匹配
        boolean b1 = list1.stream().anyMatch(i -> i > 2);
        System.out.println(b1);
        //noneMatch没有元素匹配
        boolean b2 = list1.stream().noneMatch(i -> i > 100000);
        System.out.println(b2);
        //findFirst()找第一个
        Optional<Integer> first = list1.stream().findFirst();
        //findAny找任意一个
        Optional<Integer> any = list1.stream().findAny();
        //max（comparator）最大
        list1.stream().max(Integer::compareTo);
        //min（comparator）最小
        list1.stream().min(Integer::compareTo);
        //count()总条数
        long count = list1.stream().count();
        //forEach(Consumer)内部迭代
        list1.stream().forEach(System.out::println);
        //2.归约
        //reduce(identity, BinaryOperator)求和，有初始值
        Integer reduce1 = list1.stream().reduce(10, Integer::sum);
        System.out.println(reduce1);
        //reduce(BinaryOperator)求和，没有初始值
        Optional<Integer> reduce = list1.stream().reduce((o1, o2) -> o1 + o2);
        System.out.println(reduce);
    }
    public static Stream<Character> getCharacterStream(String str) {
        List<Character> list = new ArrayList<>();
        for (Character c : str.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }
}