Java基础day26——Lambda、FunctionInterface、StreamAPI

最新推荐文章于 2024-09-15 19:46:31 发布

liang79096

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量1.1k

点赞数 35

文章标签： java 开发语言

本文链接：https://blog.csdn.net/liang79096/article/details/138161616

版权

1.Lambda表达式

1.格式与介绍说明

演示

package com.atguigu.java;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

/*
    案例：演示
 */
public class LambdaTest {
    public static void main(String[] args) {

        List<Integer> list = new ArrayList<>();
        list.add(50);
        list.add(20);
        list.add(30);
        list.add(18);
        list.add(56);

        /*
        //需求：获取集合中大于等于20的值  并排序
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()){
            Integer next = iterator.next();
            if (next < 20){
                iterator.remove();//要用迭代器去删除
            }
        }

        Collections.sort(list);
        System.out.println(list);
*/

        //StreamAPI结合Lambda表达式
        list.stream().filter(x -> x >= 20).sorted().map(x -> x + " ").forEach(System.out::print);
    }
}

格式（形参列表） ->{方法体}

package com.atguigu.java;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/*
    lambda表达式 ：对匿名内部类的对象的一种简写

    lambda表达式的格式 : (形参列表) -> {方法体}

    说明 ：
        -> : lambda操作符

 */
interface MyInterface<T>{
    int test(T t1,T t2);
}

public class LambdaTest2 {


    @Test
    public void test3(){

        //创建匿名内部类的对象
        Comparator<Integer> c = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return 0;
            }
        };
        List<Integer> list = new ArrayList<>();
        Collections.sort(list,c);//传了一个list集合和匿名内部类的对象


        //===================

        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return 0;
            }
        });

        System.out.println("=======================lambda==============================");

        //lambda表达式（本质就是匿名内部类的对象 - 只不过是对匿名内部类的对象的一种简写）
        Comparator<Integer> c2  = (Integer o1, Integer o2) -> {
            return 0;
        };

        Collections.sort(list,c2);

        //============r=========

        Collections.sort(list,(Integer o1, Integer o2) -> {
            return 0;
        });

    }

    @Test
    public void test2(){
        //创建匿名内部类的对象
        MyInterface<Integer> mi = new MyInterface<Integer>() {
            @Override
            public int test(Integer t1, Integer t2) {
                return 0;
            }
        };

        //使用lambda表达式-创建匿名内部类的对象
        MyInterface<Integer> mi2 = (Integer t1, Integer t2) ->{
            return 0;
        };


        //=====================案例==================================
        demo((Integer t1, Integer t2) -> {
            return t1 - t2;
        });
    }
    /*
        演示 ：匿名内部类的对象和lambda表达式的比较
     */
    @Test
    public void test(){
        //调用方法demo
        demo(new MyInterface<Integer>() {
            @Override
            public int test(Integer t1, Integer t2) {
                return t1 - t2;
            }
        });

        //使用lambda表达式
        demo((t1,t2) -> t1 -  t2);
    }




    public void demo(MyInterface<Integer> mi){

    }
}

2.lambda的简写条件

{方法体}中只有一个语句时可以省略{}和；

{方法体}中只有一个语句时且该语句为return语句可以同时省略return{}和；

要不然一起省略要不然不省略

（形参列表）类型已知且根据泛型列表可以自动推断那就可省略数据类型

若形参个数只有一个，且类型已知且可自动判断则数据类型和（）可以一起省略，但形参名就不能省略

（形参列表）是空参时，（）不能省略

如果lambda体只有一条执行语句那么大括号和return都可以省略不写

package com.atguigu.java;

import org.junit.Test;

import java.util.Comparator;
import java.util.function.Consumer;
import java.util.function.Supplier;

public class LambdaTest3 {
    /*
     * 当{Lambda体}中只有一句语句时，可以省略{}和{;}
     * 当{Lambda体}中只有一句语句时，并且这个语句还是一个return语句，那么{、return、;}三者可以省略。它们三要么一起省略，要么都不省略。
     * 当Lambda表达式(形参列表)的类型已知，获取根据泛型规则可以自动推断，那么(形参列表)的数据类型可以省略。
     * 当Lambda表达式(形参列表)的形参个数只有一个，并且类型已知或可以自动推断，则形参的数据类型和()可以一起省略，但是形参名不能省略。
     * 当Lambda表达式(形参列表)是空参时，()不能省略
     */
    //如果lambda体只有一条执行语句 那么大括号和return都可以省略不写
    @Test
    public void test(){
        //匿名内部类的对象
        Comparator<Integer> c = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        };

        System.out.println("====================lamdba==================");

        //如果lambda体只有一条执行语句 那么大括号和return都可以省略不写
        Comparator<Integer> c2 = (Integer o1, Integer o2) ->  o1 - o2;

    }

    /*
    如果lambda体中只有一条执行语句那么大括号可以省略不写
     */
    @Test
    public void test2(){
        //匿名内部类的对象
        Consumer<String> c = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        System.out.println("====================lamdba==================");

        //如果lambda体中只有一条执行语句那么大括号可以省略不写
        Consumer<String> c2 = (String s) -> System.out.println(s);

    }

    /*
    当Lambda表达式(形参列表)的类型已知，获取根据泛型规则可以自动推断，那么(形参列表)的数据类型可以省略。
     */
    @Test
    public void test3(){
        /*
        方法的形参是泛型的类型
        public interface Consumer<T> {
            void accept(T t);
         }
         */
        //匿名内部类的对象
        Consumer<String> c = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };

        //当Lambda表达式(形参列表)的类型已知，获取根据泛型规则可以自动推断，那么(形参列表)的数据类型可以省略。
        //lambda表达式
        Consumer<String> c2 = (s) -> System.out.println(s);


        System.out.println("=================================");

        Comparator<Integer> c3 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        };
        //当Lambda表达式(形参列表)的类型已知，获取根据泛型规则可以自动推断，那么(形参列表)的数据类型可以省略。
        //lambda
        Comparator<Integer> c4 = (o1,o2) -> o1 - o2;

    }

    /*
    当Lambda表达式(形参列表)的形参个数只有一个，并且类型已知或可以自动推断，则形参的数据类型和()可以一起省略，但是形参名不能省略。
     */
    @Test
    public void test4(){
        //匿名内部类的对象
        Consumer<String> c = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };

        //lambda
        //当Lambda表达式(形参列表)的形参个数只有一个，并且类型已知或可以自动推断，则形参的数据类型和()可以一起省略，但是形参名不能省略。
        Consumer<String> c2 = s -> System.out.println(s);

    }

    /*
    当Lambda表达式(形参列表)是空参时，()不能省略
     */
    @Test
    public void test5(){
        //创建匿名内部类的对象
        Supplier<String> s = new Supplier<String>() {
            @Override
            public String get() {
                return "a";
            }
        };

        //lambda表达式
        //当Lambda表达式(形参列表)是空参时，()不能省略
        Supplier<String> s2 = () -> "a";

    }
}

3.需要注意的点

方法的形参列表返回值类型

package com.atguigu.java;

import org.junit.Test;

import java.util.function.Supplier;

public class LambdaTest4 {
    @Test
    public void test(){
        new Supplier<String>() {
            @Override
            public String get() {
                return null;
            }
        };

        //lambda 注意：1.方法的形参列表  2.方法的返回值类型
        //Supplier<Integer> s =  () -> "a";

    }

}

2.数式接口

1.函数式接口

lambda表达式只能是函数式接口

函数式接口中只能是一个抽象方法（可以有与Object相同的方法）

可以有默认方法和静态方法（还有常量）

在接口上使用注解@FunctionalInterface判断接口是否为函数式

package com.atguigu.java2;

import org.junit.Test;

import java.util.Comparator;
import java.util.function.Consumer;
import java.util.function.Supplier;

/*
    函数式接口：只有一个抽象方法（如果有和Object类中一样的方法的抽象方法也可以）的接口叫作函数式接口

    说明：
        1.lambda表达式只能是函数式接口
        2.函数式接口中只能一个抽象方法（如果有和Object类中一样的方法的抽象方法也可以）
        3.函数式接口中可以有默认方法和静态方法(也可以有常量)
        4.可以在接口上使用注解@FunctionalInterface判断接口是否为函数式接口

 */
//下面的接口不能使用lambda表达式 因为不是一个函数式接口
//@FunctionalInterface - 报错因为不是函数式接口
interface MyInterface<T>{
    void say(T t,T t2);
    void show(T t);
}

@FunctionalInterface //用来说明该接口是函数式接口
interface MyInterface2{
    int ID = 10;

    void test();

    default void say(){

    }

    static void demo(){

    }

}

public class FunctionInterfaceTest {
    @Test
    public void test(){
        new Supplier<String>() {
            @Override
            public String get() {
                return null;
            }
        };

        new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {

            }
        };

        new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return 0;
            }
        };
    }
}

//因为A类的父类是Object类 而Object类中有equals方法 A继承了equals方法所以不用实现接口中的equals方法
class A implements Comparator<A>{
    @Override
    public int compare(A o1, A o2) {
        return 0;
    }
}

2.消费、供给、判断、功能型接口

消费型：无返回值

供给型：有值但无形参

判断型：返回值为boolean 有形参

功能型：有返回值有形参

package com.atguigu.java2;

import org.junit.Test;

import java.util.function.Function;
import java.util.function.IntConsumer;
import java.util.function.Predicate;
import java.util.function.Supplier;

public class FunctionInterfaceTest2 {

    /*
        消费型接口 ： 没有返回值
     */
    @Test
    public void test(){
        new IntConsumer() {
            @Override
            public void accept(int value) {

            }
        };

        //lambda
        IntConsumer a =  value -> System.out.println(value);
    }

    /*
        供给型接口 : 有返回值但是没有形参列表
     */
    @Test
    public void test2(){
        new Supplier<String>() {
            @Override
            public String get() {
                return null;
            }
        };

        //lambda表达式
        Supplier<String>  s = () -> "a";
    }
    /*
        判断型接口 : 返回值类型为boolean 有形参
     */
    @Test
    public void test3(){
        new Predicate<Integer>() {
            @Override
            public boolean test(Integer a) {
                return a > 20;
            }
        };

        //lambda
        Predicate<Integer> p = a -> a > 20;
    }
    
    /*
        功能型接口 : 有返回值有形参
     */
    @Test
    public void test4(){
        new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.parseInt(s);
            }
        };

        //lambda表达式
        Function<String,Integer> f = s -> Integer.parseInt(s);
    }



}

3.方法的引用（了解）

进一步简化

package com.atguigu.java3;

import org.junit.Test;

import java.io.PrintStream;
import java.util.Arrays;
import java.util.Comparator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Stream;

/*
    方法的引用(了解) ：对lambda表达式的进一步简化

    当Lambda表达式满足一些特殊的情况时，还可以再简化：
        （1）Lambda体只有一句语句，并且是通过调用一个对象的/类现有的方法来完成的
        （2）并且Lambda表达式的形参正好全部用上，Lambda体中没有额外的数据参与


    方法的引用的格式
         实例对象名::实例方法
         类名::静态方法
         类名::实例方法
 */
public class LambdaTest {
    /*
    类名::实例方法
     */
    @Test
    public void test4(){

        //匿名对部类的对象
        new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //比较两个字串的内容
                /*
                 public int compareTo(String anotherString) {
                 }
                 */
                return o1.compareTo(o2);
            }
        };
        //lambda表达式
        Comparator<String> s = (o1,o2) -> o1.compareTo(o2);

        //方法的引用
        Comparator<String> s2 = String::compareTo;//类名::实例方法 ----- 第一个参数作为调用者  第二个参数作为实参

    }

    /*
    实例对象名::实例方法
     */
    @Test
    public void test3(){
        //匿名内部类的对象
        new Consumer<String>() {
            @Override
            public void accept(String s) {
                /*
                 public void println(String x) {
                 }
                 */
                PrintStream ps = System.out;
                ps.println(s);
            }
        };

        //lambda表达式
        Consumer<String> c = s -> System.out.println(s);

        //方法的引用
        Consumer<String> c2 = System.out::println;
    }

    /*
        类名::静态方法
     */
    @Test
    public void test(){
        //匿名内部类的对象
        new Supplier<Double>() {
            @Override
            public Double get() { // 抽象方法 ： 看返返回值 和 形参列表

                /*
                 public static double random() {

                 }
                 */
                return Math.random();//调用的方法 ： 看返返回值 和 形参列表
            }
        };

        //lambda表达式
        Supplier<Double> s = () -> Math.random();

        //方法的引用
        Supplier<Double> s2 = Math::random; //类名 :: 方法名
    }
    /*
        类名::静态方法名
     */
    @Test
    public void test2(){
        //匿名内部类的对象
        new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {//抽象方法 ： 观察 返回值 和 形参列表
                /*
                 public static int parseInt(String s) {
                 }
                 */
                return Integer.parseInt(s);//抽象方法 ： 观察 返回值 和 形参列表
            }
        };

        //lambda表达式
        Function<String,Integer> f = s -> Integer.parseInt(s);//可以alt + 回车  自动替换（不能替换就没有提示）

        //方法的引用
        Function<String,Integer> f2 = Integer::parseInt;
    }
}

4.类、数组的引用

形式

类名：：new

数组的类型：：new

package com.atguigu.java3;

import org.junit.Test;

import java.util.function.Function;

public class LambdaTest2 {

    /*
        类的引用：
         类名::new
     */
    @Test
    public void test(){
        //匿名内部类的对象
        new Function<Integer, Person>() {
            @Override
            public Person apply(Integer integer) {
                //1.new的对象正好是抽象方法的返回值类型  2.抽象方法的形参正好是构造器要传的实参
                return new Person(integer);
            }
        };
        //lambda表达式
        Function<Integer, Person> f = i -> new Person(i);
        //类的引用
        Function<Integer, Person> f2 = Person::new;
    }

    /*
        数组的引用：
            数组的类型::new
     */
    @Test
    public void test2(){
        //匿名内部类的对象
        new Function<Integer, int[]>() {
            @Override
            public int[] apply(Integer integer) {
                //1.创建的数组正好是抽象方法的返回值类型  2.抽象方法的形参正好是数组的长度
                return new int[integer];
            }
        };

        //lambda表达式
        Function<Integer, int[]> f = i -> new int[i];
        //数组的引用
        Function<Integer, int[]> f2 = int[] :: new;
    }
}

class Person{
    public Person(int a){
        System.out.println("public Person(int a)");
    }
}

5.Stream的API

1.Steam的特性

自己不储存元素

不改变源对象每次处理返回新的Stream

操作延迟执行

创建方法：集合数组通过Stream的of 创建无限流

package com.atguigu.java4;


import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Supplier;
import java.util.function.UnaryOperator;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/*

    ①Stream 自己不会存储元素。
    ②Stream 不会改变源对象。每次处理都会返回一个持有结果的新Stream。
    ③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

    说明：可以把Stream想象成一条流（流水线）在流的上面有很多操作（过滤，转换，排序,.....）
 */
public class StreamAPI {
    static List<Integer> list = new ArrayList<>();
    static {
        list.add(10);
        list.add(20);
        list.add(15);
        list.add(19);
        list.add(59);
    }
    /*
        通过集合创建Stream
        * public default Stream<E> stream() : 返回一个顺序流
        * public default Stream<E> parallelStream() : 返回一个并行流
     */
    @Test
    public void test(){


        Stream<Integer> stream = list.stream();
        /*
            forEach :遍历流中的元素
         */
        /*
        stream.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });
         */

        //lambda表达式
        //stream.forEach(i -> System.out.println(i));

        //方法的引用
        //stream.forEach(System.out::println);


        list.stream().forEach(System.out::println);
    }

    @Test
    public void test2(){
        list.parallelStream().forEach(System.out::println);
    }


    /*
        通过数组创建Stream:
        public static <T> Stream<T> stream(T[] array): 返回一个流
     */
    @Test
    public void test3(){
        int[] numbers = {12,89,23,65,32};
        Arrays.stream(numbers).forEach(System.out::println);
    }
    /*
        创建 Stream方式三：通过Stream的of()
            public static<T> Stream<T> of(T... values) : 返回一个顺序流
     */
    @Test
    public void test4(){

       Stream.of(1, 2, 3, 4, 5).forEach(System.out::println);

    }

    /*
    创建 Stream方式四：创建无限流**
    可以使用静态方法 Stream.iterate() 和 Stream.generate(), 创建无限流。
    * public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f):返回一个无限流
    *
     */
    @Test
    public void test5(){
        /*
        iterate(final T seed, final UnaryOperator<T> f)
        seed : 初始化
        f : 返回计算后的新值
         */
        /*
        Stream.iterate(2, new UnaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer) {
                System.out.println("integer:" + integer);
                return integer + 1;
            }
        }).limit(20).forEach(System.out::println);

         */
        Stream.iterate(2,i -> i + 1).forEach(System.out::println);
    }
    /*
    public static<T> Stream<T> generate(Supplier<T> s) ：返回一个无限流
     */
    @Test
    public void test6(){
        /*
        Stream.generate(new Supplier<Double>() {
            @Override
            public Double get() {//不断的调用此方法 获取返回值并输出
                return Math.random();
            }
        }).forEach(System.out::println);
        */

        //Stream.generate(() -> Math.random()).forEach(System.out::println);

        Stream.generate(Math::random).forEach(System.out::println);


    }
}

2.Steam 的API

Stream distinct（）筛选去重

Stream limit（long maxSize）截断流使得元素不超过给定数量

Stream skip（long n）跳过元素返回一个扔掉了前n个元素的流

不足则返回空流与limit （n）互补

Stream peek（Consumer action）接收Lambda ，对流中每个数据执行Lambda

Stream sorted（）产生一个新流，其中按自然顺序排序

Stream map（Function f）接受一个函数作为参数该函数会被应用到每个元素

Stream flatMap（Function f）接收一个一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

package com.atguigu.java4;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;

/*
    中间操作
 */
public class StreamAPI2 {
    static List<Person> list = new ArrayList<>();
    static {
        list.add(new Person("aaa",2,100));
        list.add(new Person("longge",3,98));
        list.add(new Person("canglaoshi",9,60));
        list.add(new Person("hei",8,30));
        list.add(new Person("ha",6,59));
        list.add(new Person("hei",8,30));
        list.add(new Person("ha",6,59));
    }

    @Test
    public void test(){

        /*
        Stream<Person> stream = list.stream();

        //Stream filter(Predicate p)接收 Lambda ， 从流中排除某些元素
        Stream<Person> strem2 = stream.filter(new Predicate<Person>() {
            @Override
            public boolean test(Person person) {//只要分数及格的
                return person.score >= 60;
            }
        });

        strem2.forEach(System.out::println);
         */

        list.stream().filter(p -> p.score >= 60).forEach(System.out::println);
    }

    /*
    Stream distinct()筛选，通过流所生成元素的equals() 去除重复元素
        注意：集合中的对象所属的类必须重写equasl和hashCode方法
     */
    @Test
    public void test2(){
        list.stream()
                .distinct() //重写equals和hashCode方法后是按照内容去重
                .forEach(System.out::println);
    }

    /*
    Stream limit(long maxSize)截断流，使其元素不超过给定数量
     */
    @Test
    public void test3(){
        list.stream()
                .distinct()
                .limit(2) //获取前2个元素
                .forEach(System.out::println);
    }

    /*
    Stream skip(long n)跳过元素，返回一个扔掉了前 n 个元素的流。
            若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
     */
    @Test
    public void test4(){
        int[] numbers = {1,2,3,4,5,6};
        Arrays.stream(numbers)
                .skip(3)
                .forEach(System.out::println);
    }

    /*
    Stream peek(Consumer action)接收Lambda，对流中的每个数据执行Lambda体操作
     */
    @Test
    public void test5(){
        list.stream()
                .peek(new Consumer<Person>() {
                    @Override
                    public void accept(Person person) {
                        System.out.println("=======" + person.toString());
                    }
                })
                .forEach(System.out::println);


        list.stream()
                .peek(p -> System.out.println(p))
                .forEach(System.out::println);
    }

    /*
        Stream sorted()产生一个新流，其中按自然顺序排序
     */
    @Test
    public void test6(){
        /*
        list.stream()
                //.sorted()//自然排序
                .sorted(new Comparator<Person>() {//定制排序
                    @Override
                    public int compare(Person o1, Person o2) {
                        return o1.score - o2.score;
                    }
                })
                .forEach(System.out::println);

         */

        list.stream()
                .sorted((o1,o2) -> o1.score - o2.score)
                .forEach(System.out::println);
    }

    /*
    Stream map(Function f)接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
     */
    @Test
    public void test7(){
        /*
        list.stream()
                .filter(new Predicate<Person>() {
                    @Override
                    public boolean test(Person person) {
                        return person.name.length() > 3;
                    }
                })
                .map(new Function<Person, Integer>() {
                    @Override
                    public Integer apply(Person person) {
                        return person.id;
                    }
                })
                .filter(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) {
                        return integer > 5;
                    }
                })
                .forEach(System.out::println);

         */

        list.stream()
                .filter(p -> p.name.length() > 3)
                .map(p -> p.id)
                .filter(id -> id > 5)
                .forEach(System.out::println);
    }

    /*
    Stream flatMap(Function f)接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
     */
    @Test
    public void test8(){
        list.stream()
                .map(p -> p.name)
                .flatMap(new Function<String, Stream<?>>() {
                    @Override
                    public Stream<?> apply(String s) {
                        //"xiaocang" -> {x,i,a,o,c,a,n,g}
                        String[] split = s.split("");
                        //数组转成流
                        return Arrays.stream(split);
                    }
                })
                .forEach(System.out::println);
    }
}

3.终结操作API

boolean**allMatch（Predicate p）**检查是否匹配所有元素

| 10 | T | **reduce(T iden, BinaryOperator b)** | 可以将流中元素反复结合起来，得到一个值。返回 T |
| 11 | U | **reduce(BinaryOperator b)** | 可以将流中元素反复结合起来，得到一个值。返回 Optional<T> |

collect(Collector c)** | 将流转换为其他形式。接收一个 Collector接口的实现，
用于给Stream中元素做汇总的方法

package com.atguigu.java4;

import org.junit.Test;

import java.util.*;
import java.util.function.BinaryOperator;
import java.util.function.IntBinaryOperator;
import java.util.function.Predicate;
import java.util.stream.Collectors;

/*
    终结操作API
 */
public class StreamAPI3 {
    static List<String> list = new ArrayList<>();
    static {
        list.add("aaa");
        list.add("eee");
        list.add("ddd");
        list.add("ccc");
        list.add("bbb");
    }

    /*
    boolean**allMatch(Predicate p)**检查是否匹配所有元素
     */
    @Test
    public void test(){
        boolean b = list.stream().allMatch(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.equals("aaa");
            }
        });
        System.out.println(b);


        System.out.println( list.stream().allMatch(s -> s.equals("aaa")));
    }
    /*
           | boolean                     | **anyMatch**(**Predicate p**) | 检查是否至少匹配一个元素    |
| ------- | ----------------------------- | --------------------------- | ---------------------- |
| 3       | boolean                       | **noneMatch(Predicate  p)** | 检查是否没有匹配所有元素 |
| 4       | Optional<T>                   | **findFirst()**             | 返回第一个元素         |
| 5       | Optional<T>                   | **findAny()**               | 返回当前流中的任意元素 |
| 6       | long                          | **count()**                 | 返回流中元素总数       |
     */
    @Test
    public void test2(){
        System.out.println(list.stream().noneMatch(p -> p.equals("longge")));
        System.out.println(list.stream().anyMatch(p -> p.equals("ccc")));

        System.out.println("=============");

        Optional<String> first = list.stream().findFirst();
        System.out.println(first.get());//first.get() : 获取Optional中的值

        Optional<String> any = list.stream().findAny();
        System.out.println(any.get());

        System.out.println(list.stream().count());
    }

    /*
    |      | Optional<T> | **max(Comparator c)**                | 返回流中最大值                                               |
| ---- | ----------- | ------------------------------------ | ------------------------------------------------------------ |
| 8    | Optional<T> | **min(Comparator c)**                | 返回流中最小值                                               |
| 9    | void        | **forEach(Consumer c)**              | 迭代                                                         |

     */
    @Test
    public void test3(){
        Optional<String> max = list.stream().max((o1, o2) -> o1.compareTo(o2));
        System.out.println(max.get());

        Optional<String> min = list.stream().min(String::compareTo);
        System.out.println(min.get());

    }

    /*
    | 10   | T           | **reduce(T iden, BinaryOperator b)** | 可以将流中元素反复结合起来，得到一个值。返回 T               |
| 11   | U           | **reduce(BinaryOperator b)**         | 可以将流中元素反复结合起来，得到一个值。返回 Optional<T>     |

     */
    @Test
    public void test4(){
        int[] ns = {1,2,3,4,5};

        //有初始值
        int reduce = Arrays.stream(ns).reduce(0, new IntBinaryOperator() {
            @Override
            public int applyAsInt(int left, int right) {
                System.out.println("left:" + left + "====right:" + right);
                return left + right;
            }
        });

        System.out.println(reduce);

        System.out.println("===========================================================");

        //没有初始值
        OptionalInt reduce1 = Arrays.stream(ns).reduce(new IntBinaryOperator() {
            @Override
            public int applyAsInt(int left, int right) {
                return left + right;
            }
        });

        System.out.println(reduce1.getAsInt());
    }

    /*、
    collect(Collector c)** | 将流转换为其他形式。接收一个 Collector接口的实现，
            用于给Stream中元素做汇总的方法 |
     */
    @Test
    public void test5(){
        int[] ns = {1,2,3,4,5};

       // List<Integer> list = Arrays.stream(ns).collect(Collectors.toList());

        List<String> list = StreamAPI3.list.stream().collect(Collectors.toList());
        System.out.println(list);
    }
}

liang79096

关注

35
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫