Lambda表达式

Lambda表达式

• Lambda表达式是自jdk8版本提出的新特性，主要是“语法糖”一般的存在。
• Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。 Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。 使用 Lambda 表达式可以使代码变的更加简洁紧凑。

格式

+它的语法格式为

(parameters) -> expression
或
(parameters) ->{ statements; }

+通常使用Lambda表达式的地方是在为新线程创建一个新的Runnable接口时，我们就可以使用这个语法糖来简化代码。

Thread thread = new Thread(()->{
        System.out.println("我是一个Runnable接口");
        });

我们平时写Thread类的Runable接口时都是创建一个新的类来去实现其中的run()方法:

public class RunnableTest implements Runnable{
    @Override
    public void run() {
        System.out.println("我是一个Runnable接口");
    }
}

或者更为巧妙的方法就是去使用匿名内部类来去创建Runnable接口:

 Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("我是一个Runnable接口");
            }
        });

但是我们将以上的三种方式进行对比就会发现后两者的代码都没有第一种使用Lambda表达式的简洁，这也恰恰说明的Lambda表达式的优势。对于只有一个方法的接口，Lambda表达式能够使得代码的层次更加清晰。

使用Lambda表达式的条件

使用 Lambda 表达式需要注意以下两点：

• Lambda 表达式主要用来定义行内执行的方法类型接口，例如，一个简单方法接口。在上面例子中，我们使用各种类型的Lambda表达式来定义MathOperation接口的方法。然后我们定义了sayMessage的执行。
• Lambda 表达式免去了使用匿名方法的麻烦，并且给予Java简单但是强大的函数化的编程能力。

上述的语句中，简单方法接口对应的就是上述代码例子中的Runnable接口，这类接口中一般只有一个方法，是为了实现特定的功能而去创建使用的，Runnable接口的作用就是为了使Thread的执行更加的多元话，有些类似与策略模式的思想。

Lambda表达式的使用

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

public class Lambda {
    public static void main(String[] args) {
        //不声明类型
        MathOperation addtion = (x,y)->x+y;
        System.out.println(addtion);
        //声明类型
        MathOperation comparenum = (int x,int y)->x-y;
        System.out.println(comparenum);
        //方法体的返回语句
        MathOperation MUL = (int x,int y)->{return x*y;};
        System.out.println(MUL);
        //没有大括号和返回语句
        MathOperation comper = (int x,int y)->x/y;
        System.out.println(comper);

/**
 * 以上的方式并不能直接使用其值，因为以上所有对象都是MathOperation接口的实现类，并不能当作返回值打印
 * --------------------------------------------
 * 我们在以上做出调整:
 */
        System.out.println(opertions(5,4,addtion));
        System.out.println(opertions(5,4,comparenum));
        System.out.println(opertions(5,4,MUL));
        System.out.println(opertions(5,4,comper));
    }
    public static int opertions(int x,int y,MathOperation m){
        return m.opertion(x,y);
    }
    interface MathOperation{
        int opertion(int x,int y);
    }
}

正如我们上述代码注释的一样，Lambda表达式只是简化了部分的方法体的书写，若要调用对象还需要进行对接口实现类方法的调用。

• 按照上述的思想，我们也可以对上一部分的Runnable接口的实现来进行简化，来实现多个Runnable接口，却有着相对较少的代码量。

public class ThreadText {
    public static void main(String[] args) {
        //由于Runable接口的run()方法是没有参数的，所以我们这里也可以不用写
        Runnable runnable1 = ()-> System.out.println("Runnable1");
        Runnable runnable2 = ()-> System.out.println("Runnable2");
        Runnable runnable3 = ()-> System.out.println("Runnable3");

        new Thread(runnable1).start();
        new Thread(runnable2).start();
        new Thread(runnable3).start();
    }
}

上文提到过，Lambda表达式只能简化代码的书写，至于Thread如何执行Runnable中的方法，就要去剖析Thread中的start方法了。

• Lambda表达式的作用域
  lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。

  这句话的想表达的意思会在下一段提到。

  • 比较重要的一句话就是：lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义）
    主要表示的就是，被Lambda表达式使用的变量不能够被Lambda表达式外的语句修改。

  public class LambdaText {
  public static void main(String[] args) {
    int num = 1;
    Runnable runnable = () -> System.out.println(String.valueOf(num));
    num = 5;
  }
}

• 总结：Lambda表达式能够用外部的变量，但必须为final修饰，因为无法保证之后的语句不会对变量进行赋值。

文章到此就结束啦啦，觉得不错就点个赞吧！