Java重温学习笔记，Java8新特性：函数式接口

Posted 2021-06-23 那些年的事儿

函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。函数式接口可以被隐式转换为 lambda 表达式。

一、基本定义和使用

import java.util.List;

public class MyDemo {
    @FunctionalInterface
    interface GreetingService {
        void sayMessage(String message);
    }

    public static void main(String[] args) {
        GreetingService greetService1 = message -> System.out.println("Hello " + message);
        greetService1.sayMessage("World");
    }

}

二、在Java8 以前，已有大量函数式接口形式的接口（接口中只存在一个抽象方法），只是没有强制声明

• java.lang.Runnable
• java.util.concurrent.Callable
• java.security.PrivilegedAction
• java.util.Comparator
• java.io.FileFilter
• java.nio.file.PathMatcher
• java.lang.reflect.InvocationHandler
• java.beans.PropertyChangeListener
• java.awt.event.ActionListener
• javax.swing.event.ChangeListener

三、Java8 新增加的函数接口在java.util.function 包下，它包含了很多类：

序号	接口 & 描述
1	BiConsumer<T,U> 代表了一个接受两个输入参数的操作，并且不返回任何结果
2	BiFunction<T,U,R> 代表了一个接受两个输入参数的方法，并且返回一个结果
3	BinaryOperator<T> 代表了一个作用于于两个同类型操作符的操作，并且返回了操作符同类型的结果
4	BiPredicate<T,U> 代表了一个两个参数的boolean值方法
5	BooleanSupplier 代表了boolean值结果的提供方
6	Consumer<T> 代表了接受一个输入参数并且无返回的操作
7	DoubleBinaryOperator 代表了作用于两个double值操作符的操作，并且返回了一个double值的结果。
8	DoubleConsumer 代表一个接受double值参数的操作，并且不返回结果。
9	DoubleFunction<R> 代表接受一个double值参数的方法，并且返回结果
10	DoublePredicate 代表一个拥有double值参数的boolean值方法
11	DoubleSupplier 代表一个double值结构的提供方
12	DoubleToIntFunction 接受一个double类型输入，返回一个int类型结果。
13	DoubleToLongFunction 接受一个double类型输入，返回一个long类型结果
14	DoubleUnaryOperator 接受一个参数同为类型double,返回值类型也为double 。
15	Function<T,R> 接受一个输入参数，返回一个结果。
16	IntBinaryOperator 接受两个参数同为类型int,返回值类型也为int 。
17	IntConsumer 接受一个int类型的输入参数，无返回值 。
18	IntFunction<R> 接受一个int类型输入参数，返回一个结果 。
19	IntPredicate ：接受一个int输入参数，返回一个布尔值的结果。
20	IntSupplier 无参数，返回一个int类型结果。
21	IntToDoubleFunction 接受一个int类型输入，返回一个double类型结果 。
22	IntToLongFunction 接受一个int类型输入，返回一个long类型结果。
23	IntUnaryOperator 接受一个参数同为类型int,返回值类型也为int 。
24	LongBinaryOperator 接受两个参数同为类型long,返回值类型也为long。
25	LongConsumer 接受一个long类型的输入参数，无返回值。
26	LongFunction<R> 接受一个long类型输入参数，返回一个结果。
27	LongPredicate R接受一个long输入参数，返回一个布尔值类型结果。
28	LongSupplier 无参数，返回一个结果long类型的值。
29	LongToDoubleFunction 接受一个long类型输入，返回一个double类型结果。
30	LongToIntFunction 接受一个long类型输入，返回一个int类型结果。
31	LongUnaryOperator 接受一个参数同为类型long,返回值类型也为long。
32	ObjDoubleConsumer<T> 接受一个object类型和一个double类型的输入参数，无返回值。
33	ObjIntConsumer<T> 接受一个object类型和一个int类型的输入参数，无返回值。
34	ObjLongConsumer<T> 接受一个object类型和一个long类型的输入参数，无返回值。
35	Predicate<T> 接受一个输入参数，返回一个布尔值结果。
36	Supplier<T> 无参数，返回一个结果。
37	ToDoubleBiFunction<T,U> 接受两个输入参数，返回一个double类型结果
38	ToDoubleFunction<T> 接受一个输入参数，返回一个double类型结果
39	ToIntBiFunction<T,U> 接受两个输入参数，返回一个int类型结果。
40	ToIntFunction<T> 接受一个输入参数，返回一个int类型结果。
41	ToLongBiFunction<T,U> 接受两个输入参数，返回一个long类型结果。
42	ToLongFunction<T> 接受一个输入参数，返回一个long类型结果。
43	UnaryOperator<T> 接受一个参数为类型T,返回值类型也为T。

四、对于Java8中提供的这么多函数式接口，开发中常用的函数式接口有以下几个

Predicate，Consumer，Function，Supplier

五、函数式接口实例

1. Predicate

java.util.function.Predicate<T> 接口定义了一个名叫 test 的抽象方法，它接受泛型 T 对象，并返回一个boolean值。在对类型 T进行断言判断时，可以使用这个接口，通常称为断言性接口 。

import java.util.function.*;

public class MyDemo {
    public static void main(String[] args) {
        Predicate<String> p01=(str)->str.isEmpty()||str.trim().isEmpty();
        
        System.out.println(p01.test(""));
        System.out.println(p01.test("  "));
        System.out.println(p01.test("admin"));
    }
}

2. Consumer

java.util.function.Consumer<T>接口定义了一个名叫 accept 的抽象方法，它接受泛型T，没有返回值(void)。如果需要访问类型 T 的对象，并对其执行某些操作，可以使用这个接口，通常称为消费性接口。

import java.util.*;
import java.util.function.*;

public class MyDemo {
    public static void main(String[] args) {
        Consumer<Collection> c01 = (collection) -> {
            if (null != collection && collection.size() > 0) {
                for (Object c : collection) {
                    System.out.println(c);
                }
            }
        };
         
        List<String> list = new ArrayList<String>();
        list.add("张三");
        list.add("李四");
        list.add("赵五");
         
        // 遍历list 输出元素内容到控制台
        c01.accept(list);
    }
}

3. Function

java.util.function.Function<T, R>接口定义了一个叫作apply的方法，它接受一个泛型T的对象，并返回一个泛型R的对象。如果需要定义一个Lambda，将输入的信息映射到输出，可以使用这个接口，通常称为功能性接口。

import java.util.*;
import java.util.function.*;

public class MyDemo {
    public static void main(String[] args) {
        Function<String,String> f01=(password)->Base64.getEncoder().encodeToString(password.getBytes());
        System.out.println(f01.apply("123456"));
    }
}

4. Supplier

java.util.function.Supplier<T>接口定义了一个get的抽象方法，它没有参数，返回一个泛型T的对象，这类似于一个工厂方法，通常称为功能性接口。

import java.util.*;
import java.util.function.*;

public class MyDemo {
     // 随机产生totalNumber个整型集合
    public static List<Integer> supplier(int totalNumber, Supplier<Integer> sup){
        List<Integer> list = new ArrayList<Integer>();
        for (int i = 0; i < totalNumber; i++) {
            list.add(sup.get());
        }
        return list;
    }
    
    public static void main(String[] args) {
        Random ran = new Random();
        List<Integer> list = supplier(10, () -> ran.nextInt(10));

        for (Integer i : list) {
            System.out.println(i);
        }
    }
}

 

本文参考：

https://www.cnblogs.com/lotbyte/p/10656999.html

https://www.runoob.com/java/java8-functional-interfaces.html