常用的函数式接口

时间：2019-10-04 11:44:38 阅读：107 评论：0 收藏：0 [点我收藏+]

常用函数式接口

仅含有一个抽象方法的接口（不是只有一个方法）
该接口常与Lambda表达式相联系
Lambda表达式延迟加载，可避免性能浪费

Supplier -生产型接口

java.util.function.Supplier<泛型T> 接口仅包含一个无参的方法：T get(),用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口，也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。
Supplier<>接口被称为生产型接口，指定接口的泛型是什么类型，那么接口的get方法就会生产什么类型的数据，有返回值。

package cn.learn;

import java.util.function.Supplier;

public class function {
    //定义一个方法，方法参数传递Supplier<>接口，泛型执行String.get方法就会返回一个String
    public static String getString(Supplier<String> stringSupplier){
        return stringSupplier.get();
    }

    public static void main(String[] args) {
        //调用getString方法，方法的参数是一个函数式表达接口，所以传递lambda表达式
        String str = getString(() ->{
           //生产一个字符串，并返回
           return "aaa"; 
        });

        System.out.println(str);

        //优化Lambda表达式
        str = getString(() -> "aaa");

        System.out.println(str);
        
    }
}

练习：求数组元素最大值

package cn.learn;

import java.util.function.Supplier;

public class function {
    public static Integer getMax(Supplier<Integer> stringSupplier){
        return stringSupplier.get();
    }

    public static void main(String[] args) {
        //定义一个数组
        int[] arr = new int[]{3,55,66,77,88,-5};

        //调用getMax方法,使用Lambda表达式简写
        int integermax = getMax(() ->{
           //获取数组最大值并返回
           int max = arr[0];
            for (int i = 1; i < arr.length; i++) {
                if (max < arr[i]){
                    max = arr[i];
                }
            }
            return max;
        });

        /******
        //调用getMax方法
        getMax(new Supplier<Integer>() {
            @Override
            public Integer get() {
                //获取数组最大值并返回
                int max = arr[0];
                for (int i = 1; i < arr.length; i++) {
                    if (max < arr[i]) {
                        max = arr[i];
                    }
                }
                return max;
            }
        });
        *******/

        System.out.println(integermax);
    }
}

Consumer -消费型接口

java.util.function.Consumer<泛型>接口正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定
Consumer接口中包含抽象方法void accept(T t),意为消费一个指定泛型的数据，无返回值

package cn.learn;

import java.util.function.Consumer;

public class function {
    //accept方法接受的数据可以输出、计算等
    public static void print(Integer year,Consumer<Integer> age){
        age.accept(year);
    }

    public static void main(String[] args) {

        //消费方式：直接输出
        print(2018,(year) -> System.out.println("你的出生年是"+year));

        //消费方式：反转字符串
        print(2018,(year) -> {
            String string = year.toString();
            String re = new StringBuilder(string).reverse().toString();
            System.out.println(re);
        });
    }
}

Consumer方法中的默认方法——andThen
如果一个方法的参数和返回值全部是Consumer类型，那么就可以实现：消费数据的时候，首先做一个操作，然后在做一个操作，实现组合，而这个方法就是Consumer接口中的default方法
JDK源码

   default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }

注：java.util.Object的requireNonNull静态方法将会在参数为null时主动抛出NullPointerException异常，这就省去编写if语句和抛出空指针异常的麻烦。

若想实现组合效果，需要两个Lambda表达式即可，而andThen的语义正是“一步接一步”操作，例如两个步骤组合的情况:
- Consumer<泛型String> con1;
  Consumer<泛型String> con2;
  String str = "hello";
  con1.accept(str);
  con2.accept(str);


package cn.learn;

import java.util.function.Consumer;

public class function {
    //把两个Consumer接口组合到一起，再对数据进行消费
    public static void method(String str,Consumer<String> con1,Consumer<String> con2){
        
        //使用原始方式
        con1.accept(str);
        con2.accept(str);
        
    }

    public static void main(String[] args) {
        
        //原始使用方式，调用method方法，需要传递两个Lambda表达式
        method("Hello",(str) -> {
            //消费方式：转为大写
            System.out.println(str.toUpperCase());
        },(str) ->{
            //消费方式：转为小写
            System.out.println(str.toLowerCase());
        });
        
    }
}

连接两个接口再进行消费（谁在前，谁先消费），可以改为
con1.andThen(con2).accept(str);

package cn.learn;

import java.util.function.Consumer;

public class function {
    //andThen需要两个Consumer接口，可以把两个Consumer接口组合到一起，再对数据进行消费
    public static void method(String str,Consumer<String> con1,Consumer<String> con2){
        
        //先使用con1消费数据，再使用con2
        con1.andThen(con2).accept(str);

    }

    public static void main(String[] args) {

        //原始使用方式，调用method方法，需要传递两个Lambda表达式
        method("Hello",(str) -> {
            //消费方式：转为大写
            System.out.println(str.toUpperCase());
        },(str) ->{
            //消费方式：转为小写
            System.out.println(str.toLowerCase());
        });

    }
}

练习：格式化打印信息

package cn.learn;

import java.util.function.Consumer;

public class function {
    //使用两个Consumer来消费字符串，泛型为字符数组
    public static void method(String[] str,Consumer<String[]> con1,Consumer<String[]> con2){

        //先使用con1消费数据，再使用con2
        con1.andThen(con2).accept(str);

    }

    public static void main(String[] args) {

        //定义一个字符串数组
        String[] person ={"小王,男","大王,女"};

        //原始使用方式，调用method方法，需要传递两个Lambda表达式
        method(person,(str) -> {
            //消费方式：取人名
            for (String name:str) {
                //取第一个元素
                System.out.println(name.split(",")[0]);
            }
        },(str) ->{
            //消费方式：取性别
            for (String name:str) {
                //取第一个元素
                System.out.println(name.split(",")[1]);
            }
        });
    }
}

结果：
小王
大王
男
女

另一种写法

package cn.learn;

import java.util.function.Consumer;

public class function {
    //使用两个Consumer来消费字符串，泛型为字符数组
    public static void method(String[] str,Consumer<String> con1,Consumer<String> con2){
        //将遍历写在此处，预防重复造轮子
        for (String message:str) {
            //先使用con1消费数据，再使用con2
            con1.andThen(con2).accept(message);
        }


    }

    public static void main(String[] args) {

        //定义一个字符串数组
        String[] person ={"小王,男","大王,女"};

        //原始使用方式，调用method方法，需要传递两个Lambda表达式
        method(person,(message) -> {
            //消费方式：取人名
                System.out.println(message.split(",")[0]);
        },(message) ->{
            //消费方式：取性别
                System.out.println(message.split(",")[1]);
        });
    }
}

结果：
小王
男
大王
女

Predicate -判断接口

有时候我们需要对某种数据类型的数据进行判断，从而得到一个boolean值的结果，这时可以使用java.util.function.predicate<泛型>接口
Predicate接口中含有一个抽象方法：boolean test(T t)。用于条件判断的场景，返回值为布尔值

```java
package cn.learn;

import java.util.function.Predicate;

public class function {
//
public static boolean checkMethod(String str, Predicate pre){
return pre.test(str);
}

public static void main(String[] args) {

    String str = "hello"; 

    //对字符串进行校验
    boolean check = checkMethod(str,(String str01) ->{
       return str01.length()>5;
    });

    boolean check1 = checkMethod(str,str01 -> str01.length()>3);

    System.out.println(check);
    System.out.println(check1);
}

}

默认方法：and -可以判断多个判断条件和“&&”差不多

package cn.learn;

import java.util.function.Predicate;

public class function {
    //
    public static boolean checkMethod(String str, Predicate<String> pre1, Predicate<String> pre2){
        //等价于return pre1.test(str) && pre2.test(str);
        return pre1.and(pre2).test(str);
    }

    public static void main(String[] args) {

        String str = "hello";

        //对字符串进行校验
        boolean check = checkMethod(str,(String str01) ->{
           return str01.length()>3;
        },(str01) ->{
            return str01.contains("1");
        });


        System.out.println(check);
    }
}

false

默认方法：or -可以判断多个判断条件和“||”差不多

package cn.learn;

import java.util.function.Predicate;

public class function {
    //
    public static boolean checkMethod(String str, Predicate<String> pre1, Predicate<String> pre2){
        //等价于return pre1.test(str) || pre2.test(str);
        return pre1.or(pre2).test(str);
    }

    public static void main(String[] args) {

        String str = "hello";

        //对字符串进行校验
        boolean check = checkMethod(str,(String str01) ->{
           return str01.length()>3;
        },(str01) ->{
            return str01.contains("1");
        });


        System.out.println(check);
    }
}

true

默认方法：negate -可以判断多个判断条件和“!”差不多


package cn.learn;

import java.util.function.Predicate;

public class function {
    //
    public static boolean checkMethod(String str, Predicate<String> pre1){
        //等价于return !pre1.test(str);
        return pre1.negate().test(str);
    }

    public static void main(String[] args) {

        String str = "hello";

        //对字符串进行校验
        boolean check = checkMethod(str,(String str01) ->{
           return str01.length()>3;
        });


        System.out.println(check);
    }
}

false

练习：集合信息筛选

将名字为2个字且为女生的字符串选到集合中，注意字符串判断需要用equals方法

package cn.learn;

import java.util.ArrayList;
import java.util.function.Predicate;

public class function {

    public static ArrayList<String> filter(String[] str, Predicate<String> pre1, Predicate<String> pre2) {

        //放外边，里边会重复申请
        ArrayList<String> correct = new ArrayList<>();
        //遍历数组
        for (String message : str) {
            boolean ifCorr = pre1.and(pre2).test(message);
            //满足条件的放入集合
            if (ifCorr) {
                correct.add(message);
            }
        }
        return correct;

    }

    public static void main(String[] args) {

        String[] str = {"小王,女", "大王,男", "小白,男", "王小白,女"};

        //对字符串进行筛选,并返回需要的集合
        ArrayList<String> list = filter(str, (String str01) -> {
            return str01.split(",")[0].length() == 2;
        }, (str01) -> str01.split(",")[1].equals("女") );


        System.out.println(list);
    }
}

[小王,女]

Function -数据类型转换接口

java.util.function.Function<T,R>接口用来根据一个数据类型得到另一个数据类型，前者称为前置条件，后者称为后置条件。
抽象方法：apply，R apply,根据类型T的参数获取R型的结果，返回的是另一个类型的值。

package cn.learn;


import java.util.function.Function;

public class function {

    public static Integer convert(String str, Function<String,Integer> function){
        //返回一个Integer类型
        return function.apply(str);
    }

    public static void main(String[] args) {
        String str = "2018";
        //调用convert方法转换类型，并用Lambda表达式重写apply方法
        Integer strInt = convert(str,(String str01) ->{
           return  Integer.parseInt(str01);
        });

        System.out.println(strInt);
    }
}

默认方法：andThen,用来进行组合操作
需求：把字符串转换为Integer类型，把结果进行运算，
再把整型转换回去

package cn.learn;


import java.util.function.Function;

public class function {

    public static String convert(String str, Function<String,Integer> fun1,Function<Integer,String> fun2){
        //返回一个String类型
        return fun1.andThen(fun2).apply(str);
    }

    public static void main(String[] args) {
        String str = "2018";
        //调用convert方法转换类型，取出字符串对应的值并进行运算，再转换为String
        str = convert(str,str01 ->Integer.parseInt(str01)+10,int01 -> int01.toString());
        System.out.println(str);
    }
}

2028

常用的函数式接口

标签：als rev 字符串转换 stat 筛选输出延迟 uil The

原文地址：https://www.cnblogs.com/huxiaobai/p/11621436.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行