JAVA 函数式接口

 

 

函数式接口概述

概念：
有且仅有一个抽象方法的接口

如何检测一个接口是不是函数式接口？

• • @FunctionalInterface
  • 放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败

注意事项：
我们自己定义函数式接口的时候，@FunctionalInterface是可选的，就算我不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。但是，建议加上该注解

函数式接口作为方法的参数

 

@FunctionalInterface
public interface Runnable {
    void run();
}

/*需求描述：
        定义一个类(RunnableDemo)，在类中提供两个方法

        一个方法是：startThread(Runnable r) 方法参数Runnable是一个函数式接口
        一个方法是主方法，在主方法中调用startThread方法*/
public class RunnableDemo {
    public static void main(String[] args) {
        //在主方法中调用startThread方法

        //方式一：匿名内部类
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "：线程启动了");
            }
        });

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

        //方式二：Lambda表达式
        startThread(() -> System.out.println(Thread.currentThread().getName() + "：线程启动了"));
    }


    public static void startThread(Runnable r) {
        new Thread(r).start();
    }
}

 

函数式接口作为方法的返回值

如果一个方法的返回值是一个函数式接口，可以把一个lambda表达式作为结果返回。

/*需求描述
        定义一个类(ComparatorDemo)，在类中提供两个方法
        一个方法是：Comparator getComparator() 方法返回值Comparator是一个函数式接口
        一个方法是主方法，在主方法中调用getComparator方法*/
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class ComparatorDemo {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> arr=new ArrayList<>();
        //添加元素
        arr.add("aa");
        arr.add("ssss");
        arr.add("ddd");
        arr.add("cccccc");

        System.out.println("排序前："+arr);

       // static <T> void sort(List<T> list, Comparator<? super T> c) 根据指定的比较器引起的顺序对指定的列表进行排序。
        Collections.sort(arr,getComparator());

        System.out.println("排序后："+arr);
    }

    public static Comparator<String> getComparator(){
//        方式一：匿名内部类
//        return new Comparator<String>() {
//            @Override
//            public int compare(String s1, String s2) {
//                return s1.length()-s2.length();
//            }
//        };

//        方式二：Lambda表达式
        return (s1,s2)->s1.length()-s2.length();
    }
}

 

常用函数式接口之Supplier

Supplier接口:
Supplier接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用。

常用方法:
只有一个无参的方法

 

T get() 按照某种实现逻辑(由Lambda表达式实现)返回一个数据

import java.util.function.Supplier;

public class SupplierDemo {
    public static void main(String[] args) {
        Integer i = getInteger(() -> 10086);
        System.out.println(i);

        String s = getString(() -> "令狐冲");
        System.out.println(s);
    }

    //定义一个方法，返回一个整数数据
    public static Integer getInteger(Supplier<Integer> sup){
        return sup.get();
    }

    //定义一个方法，返回一个字符串数据
    public static String getString(Supplier<String> sup){
        return sup.get();
    }
}

 

Supplier接口练习之获取最大值

 

/*案例需求
        定义一个类(SupplierTest)，在类中提供两个方法
        一个方法是：int getMax(Supplier sup) 用于返回一个int数组中的最大值
        一个方法是主方法，在主方法中调用getMax方法*/
import java.util.function.Supplier;
public class SupplierDemo02 {
    public static void main(String[] args) {
        //定义一个int数组
        int[] arr = {19, 50, 28, 37, 46};


        int maxNumber = getMax(() -> {
            int max = arr[0];

            for (int i = 0; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            return max;
        });

        System.out.println(maxNumber);
    }

    public static int getMax(Supplier<Integer> sup){
        return sup.get();
    }
}

 

 

常用函数式接口之Consumer

Consumer接口:
Consumer接口也被称为消费型接口，它消费的数据的数据类型由泛型指定

常用方法:
Consumer：包含两个方法:

void accept(T t) 对给定的参数执行此操作

default Consumer andThen(Consumer after)返回一个组合的Consumer，依次执行此操作，然后执行after操作

 

import java.util.function.Consumer;

public class ConsumerDemo {
    public static void main(String[] args) {

        //操作一：控制台输出字符串
        operatorString("令狐冲",s -> System.out.println(s));
        //操作二：将字符串转为StringBuilder，反转后转化为String
        operatorString("令狐冲",s-> System.out.println(new StringBuilder(s).reverse().toString()));

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

        //传入两个操作使用andThen完成
        operatorString("令狐冲",s-> System.out.println(s),
                s -> System.out.println(new StringBuilder(s).reverse().toString()));
    }

    //定义一个方法，消费一个字符串数据
    public static void operatorString(String name,Consumer<String> con){
            con.accept(name);
    }

    //定义一个方法，用不同的方式消费同一个字符串数据两次
    public static void operatorString(String name,Consumer<String> con1,Consumer<String> con2){
//            con1.accept(name);
//            con2.accept(name);
              con1.andThen(con2).accept(name);
    }
}

 

Consumer接口练习之按要求打印信息

 

/*案例需求
        String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33"};
        字符串数组中有多条信息，请按照格式：“姓名：XX,年龄：XX"的格式将信息打印出来

        要求：
        把打印姓名的动作作为第一个Consumer接口的Lambda实例
        把打印年龄的动作作为第二个Consumer接口的Lambda实例
        将两个Consumer接口按照顺序组合到一起使用*/
import java.util.function.Consumer;

public class ConsumerTest {

    public static void main(String[] args) {
        String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33"};

        printInfo(
            strArray,
            str -> System.out.print("姓名："+str.split(",")[0]),
            str-> System.out.println(",年龄："+Integer.parseInt(str.split(",")[1]))
        );

    }

    //定义一个方法，完成两个操作
    public static void printInfo(String[] strArray, Consumer<String> con1,Consumer<String> con2){
        for (String str:strArray) {
            con1.andThen(con2).accept(str);
        }
    }
}

 

常用函数式接口之Predicate

Predicate接口:
Predicate接口通常用于判断参数是否满足指定的条件

常用方法:

boolean test(T t) 对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值

default Predicate negate() 返回一个逻辑的否定，对应逻辑非

default Predicate and(Predicate other) 返回一个组合判断，对应短路与

default Predicate or(Predicate other) 返回一个组合判断，对应短路或

 

test01:
import java.util.function.Predicate;

public class PredicateDemo {
    public static void main(String[] args) {

        boolean b1 = checkString("Hello", s -> s.length() > 8);
        System.out.println(b1);
        boolean b2 = checkString("HelloWorld", s -> s.length() > 8);
        System.out.println(b2);
        
    }
    
    //判断给定的字符串是否满足要求
    public static boolean checkString(String s, Predicate<String> pre){
        return pre.test(s);
    }
}

test02:
import java.util.function.Predicate;

public class PredicateDemo02 {
    public static void main(String[] args) {

        boolean b1 = checkString("Hello", s -> s.length() > 8);
        System.out.println(b1);
        boolean b2 = checkString("HelloWorld", s -> s.length() > 8);
        System.out.println(b2);

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

        boolean b3 = checkString("Hello", s -> s.length() > 8, s -> s.length() < 15);
        System.out.println(b3);
        boolean b4 = checkString("HelloWorld", s -> s.length() > 8, s -> s.length() < 15);
        System.out.println(b4);
    }

    //同一个字符串给出两个不同的判断条件，最后把这两个判断的结果做逻辑与运算的结果作为最终的结果
    public static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2 ){
        //return pre1.and(pre2).test(s);
        return pre1.or(pre2).test(s);

    }

    //判断给定的字符串是否满足要求
    public static boolean checkString(String s, Predicate<String> pre){
        return pre.negate().test(s);
    }
}

 

Predicate接口练习之筛选满足条件数据

 

/*练习描述
        String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};
        字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，并
        遍历ArrayList集合
        同时满足如下要求：姓名长度大于2；年龄大于33

        分析
        有两个判断条件,所以需要使用两个Predicate接口,对条件进行判断
        必须同时满足两个条件,所以可以使用and方法连接两个判断条件*/
import java.util.ArrayList;
import java.util.function.Predicate;

public class PredicateTest {
    public static void main(String[] args) {
        String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};

        ArrayList<String> arr = myFilter(
            strArray, 
            s -> s.split(",")[0].length() > 2,
            s -> Integer.parseInt(s.split(",")[1]) > 33
        );
        
        //遍历ArrayList集合
        for (String ss:arr) {
            System.out.println(ss);
        }
    }

private static ArrayList<String> myFilter(String[] strArray, Predicate<String> pre1,Predicate<String> pre2) {
        ArrayList<String> arrayList=new ArrayList<>();

        for (String str:strArray) {
            if (pre1.and(pre2).test(str)) {
                arrayList.add(str);
            }
        }
        return arrayList;
    }
}

 

常用函数式接口之Function

Function接口:

Function<T,R>接口通常用于对参数进行处理，转换(处理逻辑由Lambda表达式实现)，然后返回一个新的值

常用方法:

R apply(T t) 将此函数应用于给定的参数

default Function andThen(Function after)  返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果

 

示例：
import java.util.function.Function;

public class FunctionDemo {
    public static void main(String[] args) {
        //操作一：
        convert("100",s -> Integer.parseInt(s));

        //操作二：
        convert(100,i->String.valueOf(100+566));

        //使用andThen的方式连续执行两个操作
        convert("100",s -> Integer.parseInt(s),i ->String.valueOf(i+566) );
        
    }
    //定义一个方法，把一个字符串转换int类型，在控制台输出
    public static  void convert(String s, Function<String,Integer> fun){
        Integer i = fun.apply(s);
        System.out.println(i);
    }

    //定义一个方法，把一个int类型的数据加上一个整数之后，转为字符串在控制台输出
    public static  void convert(Integer i, Function<Integer,String> fun){
        String s = fun.apply(i);
        System.out.println(s);
    }

    //定义一个方法，把一个字符串转换int类型，把int类型的数据加上一个整数之后，转为字符串在控制台 输出
    public static  void convert(String s,Function<String,Integer> fun1,Function<Integer,String> fun2){
        String ss = fun1.andThen(fun2).apply(s);
        System.out.println(ss);
    }
}

 

Function接口练习之按照指定要求操作数据

 

/*练习描述
        String s = "林青霞,30";
        请按照我指定的要求进行操作：
        1:将字符串截取得到数字年龄部分
        2:将上一步的年龄字符串转换成为int类型的数据
        3:将上一步的int数据加70，得到一个int结果，在控制台输出
        请通过Function接口来实现函数拼接*/
import java.util.function.Function;

public class FunctionTest {
    public static void main(String[] args) {
        String s = "林青霞,30";
        convert(
            s,
            ss->s.split(",")[1],
            ss->Integer.parseInt(ss),
            ss->String.valueOf(ss+70));
    }

    private static void convert(String s, Function<String,String> fun1, Function<String,Integer> fun2,Function<Integer,String> fun3) {
        String ss = fun1.andThen(fun2).andThen(fun3).apply(s);

        System.out.println(ss);
    }
}