package java8.stream;

import java.util.*;
import java.util.stream.Stream;

public class GetStreamTest {

    public static void main(String[] args) {
        //1、通过java.util.Collection的方法 default Stream<E> stream()
        List<String> list= Arrays.asList("a","b","c");
        Stream<String> stream = list.stream();

        Set<String> set=new HashSet<>();
        Stream<String> stream1 = set.stream();

        Map<String,Object> map=new HashMap<>();
        Stream<String> stream2 = map.keySet().stream();
        Stream<Map.Entry<String, Object>> stream3 = map.entrySet().stream();
        Stream<Object> stream4 = map.values().stream();


        //2、通过java.util.stream.Stream的方法static<T> Stream<T> of(T... values)
        Stream<String> stream5 = Stream.of();
        Stream<String> stream6 = Stream.of("a", "b");;
        String[] ss=new String[]{"a","b"};
        Stream<String> stream7 = Stream.of(ss);

        //【注意】基本数据类型不能使用Stream，会将整个数据作为流处理
        int[] arr=new int[]{1,3};
        Stream<int[]> stream8 = Stream.of(arr);
    }

}

package java8.stream;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class StreamUseNotice {

    public static void main(String[] args) {

        List<String> list= Arrays.asList("a","c");

        //1、stream只能使用一次
        Stream<String> stream = list.stream();
//        stream.count();
//        stream.count();
//        第二次使用报错：Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed

        //2、stream非终结方法返回的stream为新的stream
//        Stream<String> stream1 = stream.filter(s -> s.equals("a"));
//        System.out.println(stream);
//        System.out.println(stream1);
        //结果：
        // java.util.stream.ReferencePipeline$Head@7ba4f24f
        //java.util.stream.ReferencePipeline$2@3b9a45b3


        //3、stream不调用终结方法，中间的不会执行
//        stream.filter(s -> {
//            System.out.println("未调用终结方法");
//           return true;
//        });
        //结果：未输出任何信息
        stream.filter(s -> {
            System.out.println("调用终结方法");
            return true;
        }).count();
        //结果:
        //调用终结方法
        //调用终结方法
    }
}

package java8.stream;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class StreamMethodTest {

    public static void main(String[] args) {
//        testForEach();
//        testCount();
//        testFilter();
//        testLimit();
//        testSkip();
//        testMap();
//        testSort();
//        testDistinct();
//        testMatch();
//        testFind();
//        testMax_Min();
//        testReduce();
//        testMap_Reduce();
//        testMapToInt();
        testConcat();
    }

    /**
     * 将多个流 合并 为一个流
     */
    private static void testConcat() {
        Stream<String> stringStream = Stream.of("a");
        Stream<Integer> integerStream = Stream.of(1, 2);
        Stream<? extends Serializable> concatStream = Stream.concat(stringStream, integerStream);
        concatStream.forEach(a->System.out.println(a));

        //【注意】：合并后，之前的流不能再进行操作
    }

    /**
     * 将Integer流转换为 int流，减少内存空间，装箱拆箱操作
     */
    private static void testMapToInt() {
        Stream<Integer> integerStream = Stream.of(1, 3, 4);
        IntStream intStream = integerStream.mapToInt(a -> {
            return a.intValue();
        });
    }

    private static void testMap_Reduce() {
        //得到所有人年龄总和
        Optional<Integer> reduceSum = Stream.of(new Person("jack", 12), new Person("jack1", 13), new Person("jack3", 19)).map(a -> a.getAge()).reduce((x, y) -> x + y);
        System.out.println(reduceSum.get());
        //获取最大的年龄
        Optional<Integer> reduceMax = Stream.of(new Person("jack", 12), new Person("jack1", 13), new Person("jack3", 19)).map(a -> a.getAge()).reduce((x, y) -> x > y ? x:y);
        System.out.println(reduceMax.get());
        //统计a出现的次数
        Integer countA = Stream.of("a", "b", "a").map(s -> {
            if (s.equals("a")) {
                return 1;
            } else {
                return 0;
            }
        }).reduce((x, y) -> x + y).get();
        System.out.println(countA);
    }

    /**
     * 对流中的元素进行 处理，最终返回一个结果
     */
    private static void testReduce() {
         //T reduce(T identity, BinaryOperator<T> accumulator);
        //identity:默认值、accumulator：流中元素处理逻辑
//        Integer reduce = Stream.of(1, 3, 2, 4).reduce(0, (a, b) -> {
//            return a + b;
//        });
        //简化后
        Integer reduce = Stream.of(1, 3, 2, 4).reduce(0, (a, b) -> a + b);
        System.out.println(reduce);
        //获取最大值
        Integer reduceMax = Stream.of(1, 3, 2, 4).reduce(0, (a, b) -> a > b ? a : b);
        System.out.println(reduceMax);
    }

    /**
     * 找 流中的最大值、最小值
     */
    private static void testMax_Min() {
        Optional<Integer> max = Stream.of(1, 3, 4).max((a, b) -> {
            return a.compareTo(b);
        });
        System.out.println(max.get());
        //简化后
        System.out.println(Stream.of(1, 3, 4).max((a,b)->a.compareTo(b)).get());

    }

    /**
     * 查找流中的第一个元素  findFirst,findAny都是找第一个元素
     */
    private static void testFind() {
        Stream<Integer> stream = Stream.of(1, 3, 4);
//        Optional<Integer> first = stream.findFirst();
//        System.out.println(first.get());
        Optional<Integer> any = stream.findAny();
        System.out.println(any.get());
    }

    /**
     * 流中的元素是否满足某个条件
     */
    private static void testMatch() {
        Stream<Integer> stream = Stream.of(1, 3, 4);
        boolean allMatch = stream.allMatch(a -> a > 1);//流中所有元素均满足某个条件
        boolean anyMatch = stream.anyMatch(a -> a > 2);//流中任意一个元素满足某个条件
        boolean noneMatch = stream.noneMatch(a -> a < 0);//流中所有元素不满足某个条件
    }

    /**
     * 对流中的元素 去重
     */
    private static void testDistinct() {
        //基本类型
        Stream<Integer> stream = Stream.of(1, 2, 3, 1, 2, 3);
        stream.distinct().forEach(a->System.out.println(a));
        //String类型
        Stream<String> stream1 = Stream.of("a", "b", "c", "c", "c");
        stream1.distinct().forEach(a->System.out.println(a));
        //自定义类型
        Stream<Person> stream2 = Stream.of(new Person("jack", 12), new Person("jack", 12), new Person("rose", 12), new Person("jack", 12));
        stream2.distinct().forEach(a->System.out.println(a));
    }



    /**
     * 对流中元素进行排序|自定义排序
     */
    private static void testSort() {
        Stream<Integer> stream = Stream.of(1, 3, 2, 5);
//        stream.sorted().forEach(a->System.out.println(a));
//        stream.sorted((a,b)->{
//            return b.compareTo(a);
//        }).forEach(a->System.out.println(a));
        //优化后
        stream.sorted((a,b)->b.compareTo(a)).forEach(a->System.out.println(a));
    }

    /**
     * 将一种类型的流  转换成  另一种类型的流
     */
    private static void testMap() {
        List<String> list=new ArrayList<>();
        Collections.addAll(list,"1","2");
        Stream<Integer> stream = list.stream().map((String s) -> {
            return Integer.parseInt(s);
        });
        stream.forEach(s->System.out.println(s));
        //简化后
        list.stream().map(s->Integer.parseInt(s)).forEach(s->System.out.println(s));
    }

    /**
     * 跳过流中的前几位元素
     */
    private static void testSkip() {
        List<String> list=new ArrayList<>();
        Collections.addAll(list,"a","b","c","d");
        list.stream().skip(2).forEach(s->System.out.println(s));
    }

    /**
     * 取流中的前几位元素
     */
    private static void testLimit() {
        List<String> list=new ArrayList<>();
        Collections.addAll(list,"a","b");
        list.stream().limit(1).forEach(s->System.out.println(s));
    }

    /**
     * 过滤流中的数据
     */
    private static void testFilter() {
        List<String> list=new ArrayList<>();
        Collections.addAll(list,"a","b");
        list.stream().filter((String s)->{
               return s.equals("a");
        }).forEach((String s)->System.out.println(s));
        //简化后
        list.stream().filter(s->s.equals("a")).forEach(s->System.out.println(s));
    }

    /**
     * 统计流中的数量
     */
    private static void testCount() {
        List<String> list=new ArrayList<>();
        Collections.addAll(list,"a","b");
        //简化后
        long count = list.stream().count();
        System.out.println(count);

    }

    /**
     * 遍历流中的元素
     */
    private static void testForEach() {
        List<String> list=new ArrayList<>();
        Collections.addAll(list,"a","b");
        //
        list.stream().forEach((String s)->{
            System.out.println(s);
        });
        //简化后
        list.stream().forEach( s-> System.out.println(s));
    }

}