java8- lambda 表达式、函数接口及四大内置函数接口 详解

lambda 表达式、函数接口及四大内置函数接口 详解

优点

• 简化代码

• 更加容易并行计算

语法

​ lambda表达式的标准语法（）-> { }

​ -> 左侧 () 内为 参数

​ -> 右侧 { } lambda 方法体

函数接口

定义：

​ 接口中 只有一个 必须 实现的方法，这种接口就是 函数接口

注解标识：

​ java8 以后可以使用 @FunctionalInterface 进行标识

源码{各种入参方式}

1. 入参：无

   返回值：无

   /**
    * 入参：无
    * 返回值：无
    *
    * 函数接口
    */
   @FunctionalInterface
   interface NullParamVoid {
       void test();
   }
   
       /**
        * 入参：无
        * 返回值：无
        * 测试
        */
       @Test
       public void test1(){
   
           // 匿名内部类的方式
           NullParamVoid nullParamVoid = new NullParamVoid() {
               @Override
               public void test() {
                   System.out.println("测试方式: 匿名内部类\n");
               }
           };
           // lamda 表达式 标准语法
           NullParamVoid nullParamVoid1 = () -> {
               System.out.println("测试方式: lanbda表达式\n");
           };
           // lamda 表达式 简化
           NullParamVoid nullParamVoid2 = () -> System.out.println("测试方式: lanbda表达式 \n如果lambda 体的代码只有一行，大括号 可以省略");
   
           System.out.println("无入参，无返回值的 函数接口测试 \n ");
   
           nullParamVoid.test();
           nullParamVoid1.test();
           nullParamVoid2.test();
   
       }
   

2. 入参：无

   返回值：有

   /**
    * 入参：无
    * 返回值：有
    *
    * 函数接口
    */
   @FunctionalInterface
   interface NullParamReturn {
       String test();
   }
   
   /**
        * 入参：无
        * 返回值：有
        * 测试
        */
   @Test
   public void test2(){
   
       // 匿名内部类的方式
       NullParamReturn interfaceInstance = new NullParamReturn() {
           @Override
           public String test() {
               return "匿名内部类";
           }
       };
       // lamda 表达式 标准语法
       NullParamReturn interfaceInstance1 = () -> {
           return "lamda 表达式 标准语法";
       };
       // lamda 表达式 简化
       NullParamReturn interfaceInstance2 = () -> "测试方式: lanbda表达式 \n如果lambda 体的代码只有一行，大括号 可以省略";
   
       System.out.println("无入参，有返回值的 函数接口测试 \n ");
   
       System.out.println(interfaceInstance.test());
       System.out.println(interfaceInstance1.test());
       System.out.println(interfaceInstance2.test());
   
   }
   

3. 入参：有 一个

   返回值：无

   note:与4 类似 见 4具体实现

4. 入参：有 一个

   返回值：有

   /**
    * 入参：一个
    * 返回值：有
    *
    * 函数接口
    */
   @FunctionalInterface
   interface OneParamReturn {
       T test(T x);
   }
   /**
        * 入参：一个
        * 返回值：有
        * 测试
        */
   @Test
   public void test3(){
   
       // 匿名内部类的方式
       OneParamReturn interfaceInstance = new OneParamReturn() {
           @Override
           public Integer test(Integer x) {
               return  ++x;
           }
       };
       // lamda 表达式 标准语法
       OneParamReturn interfaceInstance1 = (Integer x) -> {
           return ++x;
       };
   
       // lamda 表达式 简化1
       // lambda 体 只有一行代码 可以省略 {}
       OneParamReturn interfaceInstance2 = (Integer x) -> ++x;
   
       // lamda 表达式 简化
       // 可以不写入参 类型
       OneParamReturn interfaceInstance3 = (x) -> ++x;
   
       // lamda 表达式 简化
       // 如果入参只有一个 参数 可以 省略 （）
       OneParamReturn interfaceInstance4 = x -> ++x;
   
   
       System.out.println("一个入参，有返回值的 函数接口测试 \n ");
   
       System.out.println(interfaceInstance.test(1));
       System.out.println(interfaceInstance1.test(1));
       System.out.println(interfaceInstance2.test(1));
       System.out.println(interfaceInstance3.test(1));
       System.out.println(interfaceInstance4.test(1));
   
   }
   

   note:

5. 入参：有 多个

   返回值：无

   note:与6 类似 见6 具体实现

6. 入参：有 多个

   返回值：有

   /**
    * 入参：多个
    * 返回值：有
    *
    * 函数接口
    */
   @FunctionalInterface
   interface MoreParamReturn {
       R test(T x,T y);
   }
   
   
   /**
        * 入参：多个
        * 返回值：有
        * 测试
        */
   @Test
   public void test4(){
   
       // 匿名内部类的方式
       MoreParamReturn interfaceInstance = new MoreParamReturn() {
           @Override
           public Integer test(Integer x, Integer y) {
               return x + y;
           }
       };
       // lamda 表达式 标准语法
       MoreParamReturn interfaceInstance1 = (Integer x, Integer y) -> {
           return x + y;
       };
   
       // lamda 表达式 简化1
       // lambda 体 只有一行代码 可以省略 {}
       MoreParamReturn interfaceInstance2 = (Integer x, Integer y) -> x + y;
   
       // lamda 表达式 简化
       // 可以不写入参 类型
       // 敲黑板： 多个参数 要么类型 全部省略 要么 全部不省略  不允许 省略部分
       MoreParamReturn interfaceInstance3 = (x, y) -> x + y;
   
       System.out.println("多个入参，有返回值的 函数接口测试 \n ");
   
       System.out.println(interfaceInstance.test(1, 2));
       System.out.println(interfaceInstance1.test(1, 2));
       System.out.println(interfaceInstance2.test(1, 2));
       System.out.println(interfaceInstance3.test(1, 2));
   
   }
   

   note:

四大核心函数接口及子接口

对比

函数接口	入参类型	返回类型
Function	T	R
Consumer	T	void
Supplier	N/A	T
Predicate	T	boolean

Function

package java.util.function;

import java.util.Objects;

@FunctionalInterface
public interface Function {
    R apply(T var1);

    default  Function compose(Function before) {
        Objects.requireNonNull(before);
        return (v) -> {
            return this.apply(before.apply(v));
        };
    }

    default  Function andThen(Function after) {
        Objects.requireNonNull(after);
        return (t) -> {
            return after.apply(this.apply(t));
        };
    }

    static  Function identity() {
        return (t) -> {
            return t;
        };
    }
}

Consumer

package java.util.function;

import java.util.Objects;

@FunctionalInterface
public interface Consumer {
    void accept(T var1);

    default Consumer andThen(Consumer after) {
        Objects.requireNonNull(after);
        return (t) -> {
            this.accept(t);
            after.accept(t);
        };
    }
}

Supplier

package java.util.function;

@FunctionalInterface
public interface Supplier {
    T get();
}

Predicate

package java.util.function;

import java.util.Objects;

@FunctionalInterface
public interface Predicate {
    boolean test(T var1);

    default Predicate and(Predicate other) {
        Objects.requireNonNull(other);
        return (t) -> {
            return this.test(t) && other.test(t);
        };
    }

    default Predicate negate() {
        return (t) -> {
            return !this.test(t);
        };
    }

    default Predicate or(Predicate other) {
        Objects.requireNonNull(other);
        return (t) -> {
            return this.test(t) || other.test(t);
        };
    }

    static  Predicate isEqual(Object targetRef) {
        return null == targetRef ? Objects::isNull : (object) -> {
            return targetRef.equals(object);
        };
    }

    static  Predicate not(Predicate target) {
        Objects.requireNonNull(target);
        return target.negate();
    }
}