lambda表达式类似匿名函数，简单地说，它是没有声明的方法，也即没有访问修饰符、返回值声明和方法名。
lambda允许把函数作为一个方法的参数（函数作为参数传递进方法中）。
lambda表达式的语法(parameters) -> expression或(parameters) -> { statements; }
参数说明：
可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指明表达式返回了一个数值。
举例说明：
// 1. 不需要参数,返回值为5() -> 5// 2. 接收一个参数(数字类型),返回其2倍的值x -> 2 * x// 3. 接受2个参数(数字),并返回他们的差值(x, y) -> x – y// 4. 接收2个int型整数,返回他们的和(int x, int y) -> x + y// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)(string s) -> system.out.print(s)
lambda表达式作用域lambda表达式中可以引用任何外部的变量或者常量。但是对这些外部的变量是有要求的：它们必须是effectively final的。
局部内部类和匿名内部类访问的局部变量必须由final修饰，java8开始，可以不加final修饰符，由系统默认添加。java将这个功能称为：effectively final功能。
方法引用指向静态方法的方法引用function<string, integer> function1 = integer::parseint; // 等价于下面function<string, integer> function2 = (string i) -> integer.parseint(i);
指向任意类型实例方法的方法引用function<string, string> function3 = string::tolowercase; // 等价于下面function<string, string> function4 = (string i) -> i.tolowercase();bifunction<string, integer, string> bifunction = (string s, integer i) -> s.substring(i);bifunction<string, integer, string> bifunction2 = string::substring;
指向现有对象的实例方法的方法引用string str = "hello";supplier<integer> supplier = () -> str.length();supplier<integer> supplier2 = str::length;function<integer, string> function5 = (integer i) -> str.substring(i);function<integer, string> function6 = str::substring;
构造方法引用package com.morris.java8.lamdba;import java.util.function.bifunction;import java.util.function.function;import java.util.function.supplier;public class methodreferenceexample { public static void main(string[] args) { // 构造函数引用 supplier<string> stringsupplier = () -> new string(); supplier<string> stringsupplier2 = string::new; function<string, string> stringfunction = (string s)->new string(s); function<string, string> stringfunction2 = string::new; bifunction<runnable, string, thread> stringbifunction = (runnable r, string b)-> new thread(r, b); bifunction<runnable, string, thread> stringbifunction2 = thread::new; threefunction<threadgroup, runnable, string, thread> threefunction = (threadgroup g, runnable r, string b)-> new thread(g, r, b); threefunction<threadgroup, runnable, string, thread> threefunction2 = thread::new; } interface threefunction<a, b, c, d> { d triple(a a, b b, c c); }}
lambda与匿名内部类从表面上看到lambda表达式似乎只是为了简化匿名内部类书写，这看起来仅仅通过语法糖在编译阶段把所有的lambda表达式替换成匿名内部类就可以了。但实际并非如此。在jvm层面，lambda表达式和匿名内部类有着明显的差别。
匿名内部类匿名内部类仍然是一个类，只是不需要程序员显示指定类名，编译器会自动为该类取名。
public class anonymousclassdemo { public static void main(string[] args) { new thread(new runnable() { @override public void run() { system.out.println("this is an anonymous class demo"); } }); }}
因此上面的代码，编译之后将会产生两个class文件：
anonymousclassdemo.classanonymousclassdemo$1.class
进一步分析主类anonymousclassdemo.class的字节码，可发现其创建了匿名内部类的对象：
$ javap -v -p anonymousclassdemo.class... public static void main(java.lang.string[]); descriptor: ([ljava/lang/string;)v flags: acc_public, acc_static code: stack=4, locals=1, args_size=1 0: new #2 // class java/lang/thread 3: dup 4: new #3 // class anonymousclassdemo$1 创建匿名内部类 7: dup 8: invokespecial #4 // method anonymousclassdemo$1."<init>":()v 11: invokespecial #5 // method java/lang/thread."<init>":(ljava/lang/runnable;)v 14: pop 15: return linenumbertable: line 5: 0 line 11: 15}sourcefile: "anonymousclassdemo.java"innerclasses: static #3; //class anonymousclassdemo$1
lambda表达式
lambda表达式通过invokedynamic指令实现，不会产生新的类。
public class lambdademo { public static void main(string[] args) { new thread(()-> system.out.println("this is a lambda demo")); }}
上面的代码编译之后只有一个class文件:
lambdademo.class
通过javap查看lambdademo.class的字节码，我们更能看出lambda表达式内部表示的不同。
$ javap -v -p lambdademo.class... public static void main(java.lang.string[]); descriptor: ([ljava/lang/string;)v flags: acc_public, acc_static code: stack=3, locals=1, args_size=1 0: new #2 // class java/lang/thread 3: dup 4: invokedynamic #3, 0 // invokedynamic #0:run:()ljava/lang/runnable; 使用invokedynamic指令调用 9: invokespecial #4 // method java/lang/thread."<init>":(ljava/lang/runnable;)v 12: pop 13: return linenumbertable: line 4: 0 line 5: 13 private static void lambda$main$0(); // lambda表达式被封装成主类的私有方法 descriptor: ()v flags: acc_private, acc_static, acc_synthetic code: stack=2, locals=0, args_size=0 0: getstatic #5 // field java/lang/system.out:ljava/io/printstream; 3: ldc #6 // string this is a lambda demo 5: invokevirtual #7 // method java/io/printstream.println:(ljava/lang/string;)v 8: return linenumbertable: line 4: 0}sourcefile: "lambdademo.java"innerclasses: public static final #51= #50 of #54; //lookup=class java/lang/invoke/methodhandles$lookup of class java/lang/invoke/methodhandlesbootstrapmethods: 0: #22 invokestatic java/lang/invoke/lambdametafactory.metafactory:(ljava/lang/invoke/methodhandles$lookup;ljava/lang/string;ljava/lang/invoke/methodtype;ljava/lang/invoke/methodtype;ljava/lang/invoke/methodhandle;ljava/lang/invoke/methodtype;)ljava/lang/invoke/callsite; method arguments: #23 ()v #24 invokestatic lambdademo.lambda$main$0:()v #23 ()v
反编译之后我们发现lambda表达式被封装成了主类的一个私有方法，并通过invokedynamic指令进行调用。
既然lambda表达式不是内部类的简写，那么lambda内部的this引用也就跟内部类对象没什么关系了。在lambda表达式中this的意义跟在表达式外部完全一样。
以上就是java8 lambda表达式的语法是什么？的详细内容。