Java基础学习Lambda与Stream

 /*
    函数式接口 :
        java.util.function包下提供了系列的函数式接口

        四大内置函数式接口 :
            消费型接口 Consumer<T>
                void accept(T t)

            函数型接口 Function<T,R>
                R apply(T t)

            段言型接口 Predicate<T>
                boolean test(T t)

            供给型接口 Supplier<T>
                T get()
 */

    /*
    方法引用 :  看得懂,可以慢慢推导分析
        简化lambda表达式,是lambda表达式的另外一种表现形式

    前提 : 如果lambda 表达式的lambda体{}中的实现就是通过调用另外一个方法实现的,这时候可以考虑是否可以通过方法引用来简化

    语法  ::
        对象::成员方法名
        类名::静态方法名
        类名::成员方法名

    分析是否能够通过方法引用简化的条件 : 1,2必须都满足才可以使用方法引用进行简化
        1.lambda体是否是通过调用另外一个方法实现的
        2. 满足a -> 对象::成员方法名 | 类名::静态方法名   满足b -> 类名::成员方法名
            a. 所引用的方法的参数列表与返回值与lambda表达式的参数列表与返回值保持一致
            b. lambda参数列表的第一个参数,作为内部调用方法的对象存在,lambda如果存在多个参数,参数列表的第二个参数开始匹配内部所引用方法的参数列表,返回值要匹配

 */

        public static void main(String[] args) {
                //对象::成员方法名
                List<String> list = List.of("aaa","bbb","ccc");
        
                //1.lambda体是否是通过调用另外一个方法实现的 √ println    2. a. 所引用的方法的参数列表与返回值与lambda表达式的参数列表与返回值保持一致 √   -->对象::成员方法名
                list.forEach(s-> System.out.println(s));
                //通过方法引用简化 对象::成员方法名
                list.forEach(System.out::println);
        
                //类名::静态方法名
                //BiFunction<Integer,Integer,Integer> bi = (x,y)->Math.max(x,y);
                //1.lambda体是否是通过调用另外一个方法实现的 √  max   2.a.所引用的方法的参数列表与返回值与lambda表达式的参数列表与返回值保持一致  √  -->类名::静态方法名
                //通过方法引用简化  类名::静态方法名
                BiFunction<Integer,Integer,Integer> bi = Math::max;
        
                System.out.println(bi.apply(100,101));
        
                //1.lambda体是否是通过调用另外一个方法实现的 √   compareTo
                //2. b)lambda参数列表的第一个参数,作为内部调用方法的对象存在,lambda如果存在多个参数,参数列表的第二个参数开始匹配内部所引用方法的参数列表,返回值要匹配  -->类名::成员方法名
                //Comparator<String> com = (x,y)-> x.compareTo(y);
        
                //通过方法引用简化  类名::成员方法名
                Comparator<String> com = String::compareTo;
        
                System.out.println(com.compare(new String("aaa"),new String("bbb")));;
            }

    /*
    IO : 数据的传输
    数组|集合 : 存储数据
    Stream : 数据的运算
        对数据源所产生的元素序列进行流式运算

    使用步骤 :
        1.创建Stream
        2.一系列的流式中间操作 (返回一个持有结果的新的流)
        3.终止行为

    注意 :
        1.Stream流本身不存储数据
        2.Stream流的操作不影响数据源
        3.Stream的流是一次性的流
        4.惰性加载|延迟执行 : 当没有获取终止行为时,所有的中间操作都不会执行
 */

        public static void main(String[] args) {
                //获取Stream的方式 :
                //1.static <T> Stream<T> of(T... values) 返回其元素为指定值的顺序有序流。
                Stream<Integer> stream1 = Stream.of(1,2,3,4,5);
                stream1.forEach(System.out::println);
        
                //2.Collection --> default Stream<E> stream() 返回以此集合为源的顺序 Stream 。
                List<Character> chs = List.of('c','b','d');
                Stream<Character> stream2 = chs.stream();
                stream2.forEach(System.out::println);
        
                //3.Arrays -->stream()
                String[] arr = {"aaa","bbb","ccc"};
                Stream<String> stream3 = Arrays.stream(arr);
                stream3.forEach(System.out::println);
            }