Java8新特性之Lambda表达式的使用

1. lambda表达式介绍

lambda表达式是java8提供的新特性之一，也可以称之为闭包；它支持java能够进行简单的函数式编程，也就是说可以把一个匿名函数作为一个方法的参数进行传递；其格式分为三部分，第一部分为入参列表，第二部由->固定组成，第三部分为方法体；

public class lambdatest {

    public static void main(string[] args) {
        // 使用lambda表达式创建线程
        thread thread = new thread(() -> {
            system.out.println("thread running");
        });
        thread.start();
    }
}

// 运行结果
thread running

2. lambda表达式的重要特征

可选的参数类型声明：不需要声明参数的类型，编译器可以统一识别参数值；

public class lambdatest {

    private integer a;

    public lambdatest(integer a) {
        this.a = a;
    }

    public void print(lambdainterface lambdainterface) {
        lambdainterface.print(this.a);
    }

    public static void main(string[] args) {
        lambdatest lambdatest = new lambdatest(123);
        // 声明参数类型
        system.out.println("声明参数类型");
        lambdatest.print((integer a) -> {
            system.out.println("a: " + a);
        });
        // 不声明参数类型
        system.out.println("不声明参数类型");
        lambdatest.print((a) -> {
            system.out.println("a: " + a);
        });
    }
}

interface lambdainterface {
    void print(integer a);
}

// 运行结果
声明参数类型
a: 123
不声明参数类型
a: 123

可选的参数圆括号：一个参数时不需要定义圆括号，但没有参数或者多个参数时则必须要定义；

public class lambdatest {

    private integer a;

    public lambdatest(integer a) {
        this.a = a;
    }

    public void print(lambdainterface lambdainterface) {
        lambdainterface.print(this.a);
    }

    public static void main(string[] args) {
        lambdatest lambdatest = new lambdatest(123);
        // 定义参数圆括号
        system.out.println("定义参数圆括号");
        lambdatest.print((a) -> {
            system.out.println("a: " + a);
        });
        // 一个参数可不定义参数圆括号
        system.out.println("一个参数可不定义参数圆括号");
        lambdatest.print(a -> {
            system.out.println("a: " + a);
        });
    }
}

interface lambdainterface {
    void print(integer a);
}

// 运行结果
定义参数圆括号
a: 123
一个参数可不定义参数圆括号
a: 123

可选的大括号：如果方法体仅有一个语句，可不需要使用大括号；

public class lambdatest {

    private integer a;

    public lambdatest(integer a) {
        this.a = a;
    }

    public void print(lambdainterface lambdainterface) {
        lambdainterface.print(this.a);
    }

    public static void main(string[] args) {
        lambdatest lambdatest = new lambdatest(123);
        // 使用方法体大括号
        system.out.println("使用方法体大括号");
        lambdatest.print(a -> {
            system.out.println("a: " + a);
        });
        // 一个语句可不使用方法体大括号
        system.out.println("一个语句可不使用方法体大括号");
        lambdatest.print(a -> system.out.println("a: " + a));
    }
}

interface lambdainterface {
    void print(integer a);
}

// 运行结果
使用方法体大括号
a: 123
一个语句可不使用方法体大括号
a: 123

可选的返回关键字：如果方法体仅有一个表达式返回值语句，可不需要声明返回关键字，但存在大括号时则必须声明；

public class lambdatest {

    private integer a;
    private integer b;

    public lambdatest(integer a, integer b) {
        this.a = a;
        this.b = b;
    }

    public integer sum(lambdainterface lambdainterface) {
        return lambdainterface.calculate(this.a, this.b);
    }

    public static void main(string[] args) {
        lambdatest lambdatest = new lambdatest(123, 456);
        // 声明返回关键字
        system.out.println("声明返回关键字");
        integer s1 = lambdatest.sum((integer a, integer b) -> {
            return a + b;
        });
        system.out.println(s1);
        // 一个表达式返回值语句可不声明返回关键字
        system.out.println("一个表达式返回值语句可不声明返回关键字");
        integer s2 = lambdatest.sum((a, b) -> a + b);
        system.out.println(s2);
    }
}

interface lambdainterface {
    integer calculate(integer a, integer b);
}

// 运行结果
声明返回关键字
579
一个表达式返回值语句可不声明返回关键字
579

3. lambda表达式对域外变量的限制

lambda表达式对域外的局部变量具有隐性final语义的限制，但对成员变量没有该限制；

public class lambdatest {

    private integer a;
    private integer b;

    public lambdatest(integer a, integer b) {
        this.a = a;
        this.b = b;
    }

    public integer sum(lambdainterface lambdainterface) {
        return lambdainterface.calculate(this.a, this.b);
    }

    public static void main(string[] args) {
        lambdatest lambdatest = new lambdatest(123, 456);
        int c = 111;
        integer s1 = lambdatest.sum((a, b) -> {
            // 修改域外局部变量将出现编译错误
            c = 222;
            return a + b;
        });
        system.out.println(s1);

        int d = 333;
        integer s2 = lambdatest.sum((a, b) -> {
            // 域外修改lambda表达式内部使用过的域外局部变量也将导致编译错误
            return a + b + d;
        });
        d = 444;
        system.out.println(s2);
    }
}

interface lambdainterface {
    integer calculate(integer a, integer b);
}

public class lambdatest {

    private integer a;
    private integer b;
    private integer c;

    public lambdatest(integer a, integer b, integer c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }

    public integer sum(lambdainterface lambdainterface) {
        return lambdainterface.calculate(this.a, this.b);
    }

    public static void main(string[] args) {
        lambdatest lambdatest = new lambdatest(123, 456, 789);
        integer s1 = lambdatest.sum((a, b) -> {
            // 没有出现编译错误
            lambdatest.c = 999;
            return a + b + lambdatest.c;
        });
        system.out.println(s1);
    }
}

interface lambdainterface {
    integer calculate(integer a, integer b);
}

// 运行结果
1578

4. lambda表达式的优缺点

优点：

1.使代码更加简洁；

2.减少匿名内部类的创建，节省资源；

缺点：

1.可维护性差，必须熟悉抽象方法的参数列表；

2.可读性差，必须对lambda表达式有一定深入；

5. lambda表达式的使用场景

在声明方法时，方法的形参列表包含一个或者多个函数式接口就可以使用lambda表达式；如：

使用实现runnable接口创建线程

使用实现callable接口创建futuretask

使用四大函数式接口消费者接口consumer、提供者接口supplier、断言型接口predicate、函数型接口function

6. lambda表达式的实现原理

lambda表达式是通过特定的语法，让编译器对java文件进行编译时，针对每一个lambda表达式会编译成一个对应的静态方法，由此也可证明lambda表达式并不是一种语法糖；

// 对上面的lambdatest.java编译后的lambdatest.class文件使用javap -p进行查看将会得到如下结果
javap -p lambdatest.class
compiled from "lambdatest.java"
public class cn.jackiegu.java8.study.lambda.lambdatest {
  private java.lang.integer a;
  private java.lang.integer b;
  private java.lang.integer c;
  public cn.jackiegu.java8.study.lambda.lambdatest(java.lang.integer, java.lang.integer, java.lang.integer);
  public java.lang.integer sum(cn.jackiegu.java8.study.lambda.lambdainterface);
  public static void main(java.lang.string[]);
  private static java.lang.integer lambda$main$0(cn.jackiegu.java8.study.lambda.lambdatest, java.lang.integer, java.lang.integer);
}

到此这篇关于java8新特性之lambda表达式的使用的文章就介绍到这了,更多相关java的lambda表达式内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！