lambda表达式介绍
lambda表达式的本质只是一个语法糖，由编译器推断并帮你转换包装为常规的代码，因此你可以使用更少的代码来实现同样的功能。
lambda表达式是java se 8中一个重要的新特性。
lambda与匿名内部类
lamda表达式指的是应用在sam(singleabstractmethod,含有一个抽象方法的接口）环境下的一种简化定义形式。
lambda比匿名内部类的优点
简洁（详见下边“函数式接口”）
lamda相对于匿名内部类的缺点
lamda对应的接口只能有一个方法。
匿名内部类对应的接口可以有多个方法
对接口的要求
1.lambda 规定接口中只能有一个需要被实现的方法（即抽象方法）。
在一个接口中，后边几个可同时存在：一个抽象方法（只能有一个）、多个default方法、多个static方法。
// jdk 8 中有另一个新特性：default， 被 default 修饰的方法会有默认实现，不是必须被实现的方法，所以不影响 lambda 表达式的使用。
2.@functionalinterface：用来修饰函数式接口。
@functionalinterface写不写都可以。此注解主要用于编译级错误检查：当接口不符合函数式接口定义的时候，编译器会报错。
正确例子，没有报错：
@functionalinterfacepublic interface helloworldservice { void sayhello(string msg);}
错误例子，报错：
接口中包含了两个抽象方法，违反了函数式接口的定义，提示在接口中找到多个非重写的抽象方法。
注意： 加不加 @functionalinterface对于接口是不是函数式接口没有影响，该注解只是提醒编译器去检查该接口是否仅包含一个抽象方法。
变量和作用域
lambda 表达式只能引用标记了 final 的外层局部变量。即不能在 lambda 内部修改定义在域外的局部变量，否则编译报错
lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义）
lambda 表达式中不允许声明一个与局部变量同名的参数或者局部变量。
格式lambda表达式的重要特征
可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
可选的大括号：若主体包含了一个语句，就不需要使用大括号。例： () -> sysout.out.println("test");
可选的返回关键字：若主体只有一个表达式返回值则编译器会自动返回值，大括号需指定明表达式返回了一个数值。
lambda 表达式的简单例子
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)
语法格式
格式：
(parameters) -> statement 或(parameters) ->{ statements; }
左侧：lambda 表达式的参数列表
右侧：lambda 表达式中所需要执行的功能 （lambda体）
语法格式一：无参数，无返回值
() -> sysout.out.println("test");
语法格式二：有一个参数，并且无返回值
(x)-> sysout.out.println(x);
语法格式三：如果有一个参数括号可以不写
x-> sysout.out.println(x);
语法格式四：有两个以上的参数，有返回值，并且lambda体中有多条语句，语法体中需要用{}
comparator<integer> comparator = (o1, o2) -> { system.out.println("test"); return integer.compare(o1, o2); };
语法格式五：lambda体中只用一条语句，return和{}可以省略不写
comparator comparator = (o1, o2)->integer.compare(o1, o2);
语法格式六：表达式的参数列表的数据类型可以省略不写，jvm编译器通过上下文推断出数据类型
(x ,y ) ->integer.compare(x ,y)
实例无参数无返回值
package org.example.a; @functionalinterfaceinterface interface { void run();} public class demo{ public static void main(string[] args) { interface params = new interface() { @override public void run() { system.out.println("anonymous internal class: "); } }; interface params1 = () -> system.out.println("lambda: "); params.run(); params1.run(); }}
执行结果
anonymous internal class:
lambda:
有参数无返回值
package org.example.a; @functionalinterfaceinterface interface { void run(string s);} public class demo{ public static void main(string[] args) { interface params = new interface() { @override public void run(string s) { system.out.println("anonymous internal class: " + s); } }; interface params1 = (s) -> system.out.println("lambda: " + s); params.run("hello"); params1.run("hi"); }}
执行结果
anonymous internal class: hello
lambda: hi
有参数有返回值
package org.example.a; @functionalinterfaceinterface interface { string run(string s);} public class demo{ public static void main(string[] args) { interface params = new interface() { @override public string run(string s) { system.out.println("anonymous internal class: " + s); return "abc"; } }; interface params1 = (s) -> { system.out.println("lambda: " + s); return "def"; }; system.out.println(params.run("hello")); system.out.println(params1.run("hi")); }}
执行结果
anonymous internal class: hello
abc
lambda: hi
def
lambda作为参数传递一个函数
package org.example.a; interface irun { string welcome(string string);} class util { public static long executiontime1(irun irun, string string) { long starttime = system.currenttimemillis(); system.out.println(irun.welcome(string)); //本处刻意添加这一无意义延时，防止执行太快返回0 try { thread.sleep(10); } catch (exception e) { system.out.println(e); } long endtime = system.currenttimemillis(); return endtime - starttime; } public long executiontime2(irun irun, string string) { long starttime = system.currenttimemillis(); system.out.println(irun.welcome(string)); //本处刻意添加这一无意义延时，防止执行太快返回0 try { thread.sleep(10); } catch (exception e) { system.out.println(e); } long endtime = system.currenttimemillis(); return endtime - starttime; } public static string hello(string string){ string tmp; tmp = "hello: " + string; return tmp; } public string hi(string string){ string tmp; tmp = "hi: " + string; return tmp; }} public class demo { public static void main(string[] args) { long time1 = util.executiontime1(util::hello, "tony"); long time2 = new util().executiontime2(new util()::hi, "pepper"); system.out.println("time1: " + time1 + "ms"); system.out.println("time2: " + time2 + "ms"); }}
执行结果
hello: tony
hi: pepper
time1: 11ms
time2: 11ms
直接传递lambda函数
package org.example.a; interface irun { string welcome(string string);} class util { public static long executiontime(irun irun, string string) { long starttime = system.currenttimemillis(); system.out.println(irun.welcome(string)); //本处刻意添加这一无意义延时，防止执行太快返回0 try { thread.sleep(10); } catch (exception e) { system.out.println(e); } long endtime = system.currenttimemillis(); return endtime - starttime; }} public class demo { public static void main(string[] args) { long time = util.executiontime((string -> { string tmp; tmp = "hello: " + string; return tmp; }) , "tony"); system.out.println("time: " + time + "ms"); }}
执行结果
hello: tony
time: 11ms
遍历集合package org.example.a; import java.util.arraylist;import java.util.list; public class demo{ public static void main(string[] args) { list<string> list = new arraylist<>(); list.add("aaa"); list.add("bbb"); //以前的循环方式 for (string string : list) { system.out.println(string); } //使用lambda表达式输出list中的每个值 list.foreach(c->{ system.out.println(c); }); // 在 java 8 中使用双冒号操作符(double colon operator）。也属于lamda表达式 list.foreach(system.out::println); }}
执行结果
aaa
bbb
aaa
bbb
aaa
bbb
创建线程package org.example.a; public class demo{ public static void main(string[] args) { new thread(new runnable() { @override public void run() { system.out.println("anonymous internal class !"); } }).start(); new thread(() -> system.out.println("lambda !")).start(); }}
执行结果
anonymous internal class !
lambda !
排序package org.example.a; import java.util.arrays;import java.util.comparator; public class demo{ public static void main(string[] args) { string[] players = {"rafael nadal", "novak djokovic", "stanislas wawrinka"}; arrays.sort(players, new comparator<string>() { @override public int compare(string o1, string o2) { return (o1.compareto(o2)); } }); // comparator<string> sortbyname = (string s1, string s2) -> (s1.compareto(s2));// arrays.sort(players, sortbyname); // arrays.sort(players, (string s1, string s2) -> (s1.compareto(s2))); for(string string:players){ system.out.println(string); } }}
执行结果（换成注释掉的两种任意一种都是一样的）
novak djokovic
rafael nadal
stanislas wawrinka
以上就是java中lambda表达式的使用方法是什么？的详细内容。