简介
说明
本文用示例展示Lambda表达式的用法。同时也会介绍Lambda的相关知识。
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写不写都可以。此注解主要用于编译级错误检查：当接口不符合函数式接口定义的时候，编译器会报错。
正确例子，没有报错：
|
1 2 3 4 |
@FunctionalInterface public 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体中有多条语句，语法体中需要用{}
|
1 2 3 4 |
Comparator<Integer> comparator = (o1, o2) -> { System.out.println( "Test" ); return Integer测试数据pare(o1, o2); }; |
语法格式五：Lambda体中只用一条语句，return和{}可以省略不写
Comparator comparator = (o1, o2)->Integer测试数据pare(o1, o2);
语法格式六：表达式的参数列表的数据类型可以省略不写，JVM编译器通过上下文推断出数据类型
(x ,y ) ->Integer测试数据pare(x ,y)
实例
函数式接口
无参数无返回值
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
package org.example.a;
@FunctionalInterface interface 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:
有参数无返回值
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
package org.example.a;
@FunctionalInterface interface 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
有参数有返回值
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
package org.example.a;
@FunctionalInterface interface 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作为参数
传递一个函数
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 |
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函数
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
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
遍历集合
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
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
创建线程
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
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 !
排序
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
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测试数据pareTo(o2)); } });
// Comparator<String> sortByName = (String s1, String s2) -> (s1测试数据pareTo(s2)); // Arrays.sort(players, sortByName);
// Arrays.sort(players, (String s1, String s2) -> (s1测试数据pareTo(s2)));
for (String string:players){ System.out.println(string); } } } |
执行结果（换成注释掉的两种任意一种都是一样的）
Novak Djokovic
Rafael Nadal
Stanislas Wawrinka
以上就是Java中Lambda表达式的使用详细教程的详细内容，更多关于Java Lambda表达式的资料请关注其它相关文章！
原文链接：https://knife.blog.csdn.net/article/details/121004983
查看更多关于Java中Lambda表达式的使用详细教程的详细内容...