函数式接口详解(Java)

1.1 函数式接口概述

函数式接口:有且仅有一个抽象方法的接口

Java中函数式编程体现就是Lambda表达式,所以函数式接口就是可以适用于Lambda使用的接口

只有确保接口中仅有一个抽象方法,Java中的Lambda才能顺利地进行推导

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

  • @Functionallnterface
  • 放在 接口定义的上方:如果接口是函数式接口,编译通过;如果不是,编译失败

注意:

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

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

需求

  • 定义一个类(RunnableDemo),在类中提供两个方法
    • 一个方法是:startThread(Runnable r) 方法参数Runnabler是一个函数式接口
    • 一个方法是主方法,在主方法中调用startThread方法

如果方法的参数是一个函数式接口,我们可以用Lambda表达式作为参数传递

  • startThread(()->System.out.println(Thread.currentThread().getName()+“线程启动了”));
public class RunnableDemo {
    public static void main(String[] args) {
        startThread(()-> System.out.println(Thread.currentThread().getName()+"线程启动了"));
    }

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

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

需求

  • 定义一个类(ComparatorDemo),在类中提供两个方法
    • 一个方法是:Comparator< String > getComparator() 方法返回值Comparator是一个函数式接口
    • 一个方法是主方法,在主方法中调用getComparator方法

如果一个方法的返回值是一个函数式接口,我们可以把一个Lambda表达式作为结果返回

  • private static Comparator<String> getComparator() {    
    	//Lambda表达式写法
        return (s1, s2) -> s1.length() - s2.length();
    }
    
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class ComparatorDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("cccc");
        list.add("aa");
        list.add("b");
        list.add("ddd");

        System.out.println("排序前" + list);
        Collections.sort(list, getComparator());
        System.out.println("排序后" + list);
    }

    //如果一个方法的返回值是一个函数式接口,我们可以把一个Lambda表达式作为结果返回
    private static Comparator<String> getComparator() {
        //使用匿名内部类实现
//        return new Comparator() {
//            @Override
//            public int compare(String s1, String s2) {
//                return s1.length()-s2.length();
//            }
//        };

        //Lambda表达式写法
        return (s1, s2) -> s1.length() - s2.length();
    }
}

2.1 常用的函数式接口

Java 8在java.util.function包下预定义了大量的函数式接口供我们使用

我们重点学习下面4个接口

  • Supplier接口
  • Consumer接口
  • Predicate接口
  • Function接口

2.1.1 Supplier接口

Supplier< T >:包含一个无参的方法

  • T get():获得结果
  • 该方法不需要参数,他会按照某种实现逻辑(由Lambda表达式实现)返回一个数据
  • Supplier< T >接口也被称为生产型接口,如果我们指定了接口的泛型是什么类型,那么接口中的get方法就会产生什么类型的数据供我们使用
import java.util.function.Supplier;

public class SupplierDemo {
    public static void main(String[] args) {
        String s = getString(()->"张三");
        int i = getInteger(()->18);

        System.out.println(s+","+i);
    }

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

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

练习:

  • 定义一个类(SupplierTest),在类中提供两个方法
    • 一个方法是:int getMax(Supplier< Integer > sup) 用于返回一个int数组中的最大值
    • 一个方法是主方法,在主方法中调用getMax方法
import java.util.function.Supplier;

public class SupplierTest {
    public static void main(String[] args) {
        int[] i = {3,75,32,76,98,42};
        int maxValue = getMax(()->{
           int max = i[0];
            for (int j = 1; j < i.length; j++) {
                if(i[j]>max){
                    max = i[j];
                }
            }
            return max;
        });

        System.out.println(maxValue);
    }

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

2.1.2 Consumer接口

Consumer< T >:包含两个方法

  • void accept(T t):对给定的参数执行此操作
  • default Consumer < T > andThen(Consumer after):返回一个组合的Consumer,依次执行此操作,然后执行after操作
  • Consumer< T >接口也被称为消费型接口,它消费的数据类型由泛型指定
import java.util.function.Consumer;

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

        operatorString("张三", (s) -> System.out.println(s));

        operatorString("张三", (s) -> System.out.println(s), (s)-> System.out.println(new StringBuilder(s).reverse().toString()));
    }

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

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

练习:

  • String[] strArray = {“张三,30”, “李四,21”, “王五,18”};
  • 字符串数组中有多条信息,请按照格式:
    • 把打印姓名的动作作为第一个Consumer接口的Lambda实例
    • 把打印年龄的动作作为第二个Consumer接口的Lambda实例
    • 将两个Consumer接口按照顺序组合到一起使用
import java.util.function.Consumer;

public class ConsumerTest {
    public static void main(String[] args) {
        String[] strArray = {"张三,30", "李四,21", "王五,18"};
        printInfo(strArray,
                s1 -> System.out.print("姓名:" + s1.split(",")[0] + ","),
                s2 -> System.out.println("年龄:" + s2.split(",")[1]));
    }

    private static void printInfo(String[] strArray, Consumer<String> con1, Consumer<String> con2) {
        for (String str :
                strArray) {
            con1.andThen(con2).accept(str);
        }
    }
}

2.1.3 Predicate接口

Predicate< T >:常用的四个方法

  • boolean test(T t):对给定的参数进行判断(判断逻辑由Lambda表达式实现),返回一个布尔值
  • default Predicate< T > negate():返回一个逻辑的否定,对应逻辑非
  • default Predicate< T > and():返回一个组合判断,对应短路与
  • default Predicate< T > or():返回一个组合判断,对应短路或
  • isEqual():测试两个参数是否相等
  • Predicate< T >:接口通常用于判断参数是否满足指定的条件

test(T t) 、negate()

import java.util.function.Predicate;

public class ConsumerTest {
    public static void main(String[] args) {
        boolean string = chenkString("张三", s -> s.equals("张三"));
        System.out.println(string);

        boolean hello = chenkString("hello", s -> s.length() > 8, s -> s.length() < 18);
        System.out.println(hello);
    }

    //判定给定的字符串是否满足要求
//    private static boolean chenkString(String s, Predicate pre){
//        return pre.test(s);
//    }

    private static boolean chenkString(String s, Predicate<String> pre){
        return pre.negate().test(s);
    }

//    private static boolean chenkString(String s, Predicate pre, Predicate pre1){
//        return pre.and(pre1).test(s);
//    }

    private static boolean chenkString(String s, Predicate<String> pre, Predicate<String> pre1){
        return pre.or(pre1).test(s);
    }
}

练习:

  • String[] strArray = {“张三,30”, “李四,21”, “王五,18”};
  • 字符串数组中由多条信息,请通过Predicate接口的拼装将符合要求的字符串筛选到集合Arraylist中,并遍历ArrayList集合
  • 同时满足如下小球:姓名长度大于1,年龄大于20
  • 分析
    • 有两个判断条件,所以需要使用两个Predicate接口,对条件进行判断
    • 必须同时满足两个条件,所以可以使用and方法连接两个判断条件
import java.util.ArrayList;
import java.util.function.Predicate;
public class ConsumerTest {
    public static void main(String[] args) {
        String[] strArray = {
                "张三,30", "李四,21", "王五,18"
        };
        ArrayList<String> arrayList = myFilter(strArray,
                s -> s.split(",")[0].length() > 1,
                s -> Integer.parseInt(s.split(",")[1]) > 20
        );
        for (String array : arrayList) {
            System.out.println(array);
        }
    }    
    //通过Predicate接口的拼装将符合要求的字符串筛选到集合Arraylist中    
    private static ArrayList<String> myFilter(String[] strArray, Predicate<String> pre1, Predicate<String> pre2) {        
    	//定义一个集合
        ArrayList<String> array = new ArrayList<>();        
        //遍历数组        
        for (String str : strArray) {
            if (pre1.and(pre2).test(str)) {
                array.add(str);
            }
        }
        return array;
    }
}

2.1.4 Function接口

Runction:常用的两个方法

  • R apply(T t):将此函数应用于给定的参数
  • default< V >:Function andThen(Function after):返回一个组合函数,首先将该函数应用于输入,然后将after函数应用于结果
  • Function:接口通常用于对参数进行处理,转换(处理逻辑由Lambda表达式实现),然后返回一个新值
import java.util.function.Function;

public class ConsumerTest {
    public static void main(String[] args) {
        convert("18", s -> Integer.parseInt(s));
        convert(20, integer -> String.valueOf(integer + 18));
        convert("245", s -> Integer.parseInt(s), integer -> String.valueOf(integer + 18));
    }   
    //定义一个方法,把一个字符串转换成int类型,在控制台输出
    private static void convert(String s, Function<String, Integer> fun) {
        int i = fun.apply(s);
        System.out.println(i);
    }    
    //定义一个方法,把int类型数据加上一个整数之后,转换为字符串在控制台输出
    private static void convert(int i, Function<Integer, String> fun) {
        String s = fun.apply(i);
        System.out.println(s);
    }   
    //定义一个方法,把一个字符串转换int类型,把int类型的数据加上一个整数后,转换成字符串在控制台输出
    private static void convert(String s, Function<String, Integer> fun1, Function<Integer, String> fun2) {
        String s1 = fun2.apply(fun1.apply(s));
        System.out.println(s1);
    }
}

你可能感兴趣的:(精选,lambda,函数式编程,函数式,java,函数式接口)