jdk8 新特性之函数式接口

刺骨的言语ヽ痛彻心扉 2023-03-13 11:48 29阅读 0赞

## 一、函数式接口说明 ##

### 1、函数式接口条件 ###

（1）、只包含一个抽象方法的接口，称为函数式接口。

（2）、你可以通过Lambda表达式来创建该接口的对象。（若Lambda表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方法上进行声明）。

（3）、我们可以在任意函数式接口上使用@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口，同时javadoc也会包含一条声明，说明这个接口是一个函数式接口。

### 2、@FunctionalInterface 注解说明 ###

*  1.此注解表明该接口是一个函数式接口，所谓的函数式接口，是指“有且只有一个抽象方法”
 *  2.接口中的静态方法，默认方法（default修饰），以及java.lang.Object类中的方法都不算抽象方法。
 *  3.如果接口符合函数式接口的定义，则此注解加不加无所谓，加了会方便编译器检查。如果不符合函数式接口定义，则此注解会报错。

函数式接口其实是继承于Object的。

### 3、Lambda 简写/省略规则 ###

**示例：**  
该示例来自第二步骤

// 简写前
    (Integer t) -> { return t * 2; };
    
    // 简写后
    t ->  t * 2;

**简写：**  
1、传入参数可以省略类型，如: `(t) -> { return t * 2; };`  
2、传入参数如果只有一个，可以省略括号,如： `t -> { return t * 2; };`  
3、返回参数没有复杂业务,一行代码可完成逻辑，可以省略 **大括号+分号+ return**，如： `t -> { t * 2 };`

**缺点：**  
当然，Lambda表达式虽然简洁，也是有缺点的：就是降低了代码的可读性，比如一眼看不出来原来的函数式接口是什么。所以什么情况用Lambda，要多写多练才会用的恰当。

### 4、使用函数式接口及 Lambda 创建一个线程 ###

// 创建线程
    new Thread(() -> {
         // 业务逻辑
         System.out.println("666");
    }).start();
    
     // 简单业务逻辑--可简写为
     new Thread(() -> System.out.println("666")).start();

可以看出 Runnable 接口是一个函数式接口，可以使用Lambda 来创建异步线程  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDYzNjU1_size_16_color_FFFFFF_t_70]

### 5、四大内置函数式接口（+其他） ###

只包含一个抽象方法的接口，称为函数式接口。  
可以通过 Lambda 表达式来创建该接口的对象。（若Lambda表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方法上进行声明）。  
我们可以在任意函数式接口上使用@FunctionalInterfaceFunctionalInterface注解，这样做可以检查它是否是一个函数式接口，同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDYzNjU1_size_16_color_FFFFFF_t_70 1]  
其他接口  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDYzNjU1_size_16_color_FFFFFF_t_70 2]

## 二、函数式接口创建 ##

### 1、创建函数式接口 ###

@FunctionalInterface
    interface Fun3 {
        // 抽象方法，必须只有一个
        Integer run(Integer num);
    }

### 2、使用 ###

`(t) -> t * 2` 为使用run方法实现，（）中的为传递的参数，-> 后的为run 方法的实现逻辑（ t \* 2 ）

class Test3 {
        // TODO  测试
        public static void main(String[] args) {
            Fun3 fun3 = (t) -> t * 2;
            // 调用刚定义的实现逻辑
            Integer num = fun3.run(5);
            System.out.println("n * 2 = " + num);   // 输出10
       }
    }

// 简写： `Fun3 fun3 = (t) -> t * 2;` \--> 完整写法: `Fun3 fun4 = (t) -> { return t * 2; };`

## 三、创建类似于 forEach 的函数式接口 （函数式接口作为参数） ##

### 1、创建函数式接口 ###

@FunctionalInterface
    interface Fun<T> {
        void run(T t);
    }
    
    
    /**
     * TODO  创建类，使用函数式接口作为参数，并调用函数式接口中的 run 方法
     */
    class FunClass {
        public <T> void forEach(List<T> list, Fun fun) {
            for (T t : list) {
                fun.run(t);
            }
        }
    }

### 2、使用 ###

`(t) = run(T t) 的参数 t`, 调用时 `(t)` 可任意命名, 但实际参数内容等于 run(T t) 的参数的 t

class Test {
        // TODO  测试
        public static void main(String[] args) {
        
            ArrayList<String> lists = new ArrayList<>();
            lists.add("665");
            lists.add("666");
            lists.add("667");
           
            // 使用
            new FunClass().forEach(lists, (t) -> {
                System.out.println(t);
            });        
    
            // 省略写法
            new FunClass().forEach(lists, t -> System.out.println(t));
    
            // 继续省略写法
            new FunClass().forEach(lists, System.out::println);
            
            // 输出 
            // 665  
            // 666  
            // 667
        }
    }

## 四、使用函数式接口进行参数转换 (固定参数类型) ##

### 1、创建函数式接口 ###

@FunctionalInterface
    interface FunConverter2<F, T> {
    
        //加 - 使用static 关键字默认实现的方法不算抽象方法。
        static double add(int a, int b) {
            return a + b;
        }
    
        //减 - default 关键字默认实现的方法不算抽象方法。
        default double subtract(int a, int b) {
            return a - b;
        }
    
        // 抽象方法，必须只有一个，该抽象方法传入F 类型的数据，返回T类型的数据
        T convert(F from);
    
    }

### 2、使用 ###

class FunConverterTest {
        // TODO  测试
        public static void main(String[] args) {
    
            // 将传入的String-from，转为Integer
            FunConverter2<String, Integer> converter = (from) -> Integer.valueOf(from);
            Integer converted = converter.convert("123");
            System.out.println(converted); // 123 整型
    
            // 将传入的Integer-from，转为 String
            FunConverter2<Integer, String> converter2 = (from) -> String.valueOf(from);
            String converted2 = converter2.convert(123);
            System.out.println(converted2); // 123 字符串
    
            // 将获取传入值的2次方
            FunConverter2<Integer, Integer> converter3 = (from) -> from * from;
            Integer converted3 = converter3.convert(2);
            System.out.println(converted3); // 4
    
            // 将传入字符串转为小写
            FunConverter2<String, String> converter4 = (from) -> from.toLowerCase();
            String converted4 = converter4.convert("ABC");
            System.out.println(converted4); // abc
    
            // 将传入字符串转为大写
            FunConverter2<String, String> converter5 = (from) -> from.toUpperCase();
            String converted5 = converter5.convert("abc");
            System.out.println(converted5); // ABC
        }
    }

## 五、使用四大接口之–函数型接口 Function<T, R> 示例 ##

Function<T, R> 为函数型接口，T 为传入参数类型，R为返回参数类型

package interfaceTest;
    
    import java.util.function.Function;
    
    public class Test4 {
    
    
        // 定义一个方法用于对数组求和
        public static Integer getSum(int[] arr) {
            int sum = 0;
            for (int i : arr) {
                sum += i;
            }
            return sum;
        }
    
        // 表示传入int数组，返回Integer
        public static Integer test(Function<int[], Integer> fun, int[] arr) {
            return fun.apply(arr);
        }
    }
    
    class Test5 {
        public static void main(String[] args) {
            // Fun<Consumer<int[]>> consumerFun = Test4::test;
            int[] arr = {1, 2, 4, 5, 6, 2, 3};
            Integer num = Test4.test(Test4::getSum, arr);
            System.out.println(num); // 23
          
            //Function<int[], Integer> fun = Test4::getSum;
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDYzNjU1_size_16_color_FFFFFF_t_70 3]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDYzNjU1_size_16_color_FFFFFF_t_70]: /images/20230312/67057c3b459d455c9faaa7d538e5202f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDYzNjU1_size_16_color_FFFFFF_t_70 1]: /images/20230312/5fcc81af1bf14201ac1d99cdf4837678.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDYzNjU1_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/2020051323121798.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDYzNjU1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDYzNjU1_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200513233023857.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDYzNjU1,size_16,color_FFFFFF,t_70