java8 Lambda表达式详细讲解

Lambda 表达式，它是推动 Java 8 发布的最重要新特性。

Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

使用 Lambda 表达式可以使代码变的更加简洁紧凑。

Lambda几种特性

• 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
• 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
• 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
• 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。

直接上代码, 代码简化写法

public class TestLambda {

    public  void  lambdaV1(){
        TestLambda  testLambda = new TestLambda();
        
        /*----------------------------java8 接口带返回值的-----------------------------------*/
        //格式1
        MathOperation  operation2 = new MathOperation() {
            @Override
            public int operation(int a, int b) {
                return a + b;
            }
        };
        //格式2 - java8新写法,是上面那种写法的缩写，operation就相当于这个接口方法的实现类
        MathOperation  operation =(a,b) ->a+b;
        //也可以这样子写
        MathOperation  operation1 = (a,b) ->{
            //就是如果只有一行，可以不需要大括号，可以省略，多行就不行
            return a + b;
        };
        int o1 = operation.operation(2, 3);
        int o2 = operation2.operation(2, 3);
        System.out.println(o1);
        System.out.println(o2);



        /*-------------------------java8 接口没有返回值的写法--------------------------------------*/
        //平常写法
        GreetingService  gService = new GreetingService() {
            @Override
            public void sayMessage(String message) {
                System.out.println(message);
            }
        };
        //java8写法
        GreetingService gService1 = message -> System.out.println(message);
        GreetingService gService2 = (message) -> {
            System.out.println(message);
        };
        //上面三种写法是一样的。


        /*------------------------java8 调用带接口得方法---------------------------*/
        int operate = testLambda.operate(2, 3, (a, b) -> a + b);
        System.out.println("调用带接口得方法:"+operate);



        /*-------------------------java8 :: 双冒号写法----------------------------------------*/
        List<Person> peoples = new ArrayList<>();
        //写法1
        peoples.forEach(person -> person.getAge());
        //写法2
        peoples.forEach(Person::getAge);
        //上面写法1和写法二相等。


    }

    public static void main(String[] args) {

    }

    interface MathOperation {
        int operat

下面介绍java8中常用的函数式接口

1. Function

   通过一个apply方法，传入T 类型返回R类型

   Function 总共有以下几个方法

  1.  唯一抽象方法 apply , 传入一个T类型，返回R类型

  2.  compose 方法，传入一个Function参数，先执行传入参数apply逻辑，在执行当前apply逻辑

  3.  andThen 方法 ，传入一个Function参数，先执行当前apply逻辑，在执行传入参数的逻辑

@FunctionalInterface
public interface Function<T, R> {
    
    //唯一抽象方法，自定义方法逻辑，根据传入类型T，返回类型R
    R apply(T t);
    
    //传入一个Function参数，先执行传入参数apply逻辑，在执行当前apply逻辑
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }
    
    //传入一个Function参数，先执行当前apply逻辑，在执行传入参数的逻辑
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

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

常见用法演示

 /**
     * 自定义类型方法
     * @param c
     */
    public  Integer  test(Function<Integer,Integer> c,Integer x){
        Integer apply = c.apply(x);
        return apply;
    }

    public static void main(String[] args) {
        Test04Function  test04  = new Test04Function();

        Integer wan = test04.test(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer a) {
                return a - 2;
            }
        }, 2);
        //两种写法一样，结果都是：0
        Integer wan2 = test04.test(a -> a - 2, 2);
        System.out.println(wan == wan2);

        Function<Integer,Integer>  f1 = i -> i + 2;
        Function<Integer,Integer>  f2 = i -> i * 2;

        System.out.println(f1.andThen(f2).apply(5));
        System.out.println(f1.compose(f2).apply(5));

    }

结果为：

true
14
12

2. Supplier

未完待续

3. Consumer

4. Predicate