@
public interface Command {
//接口里定义的方法相当于处理封装行为
int progress(int[] target);
}
public class ProgressArray {
public ProgressArray() {
}
public void progress(int[] target,Command cmd) {
cmd.progress(target);
}
}
public class CommandInnerTest {
public CommandInnerTest() {
}
public static void main(String[] args) {
ProgressArray progressArray=new ProgressArray();
int[] array= new int[] {3, -4, 6, 4} ;
//处理数组，具体处理行为取决于匿名内部类
progressArray.progress(array, new Command() {
@Override
public void progress(int[] target) {
int sum=0;
int[] a=target;
for(int j=0;j<a.length;j++ ) {
int temp=a[j];
sum+=temp;
}
System.out.println("数组元素的总和："+sum);
}
});
}
}
Lambda 表达式可用于简化创建匿名内部类对象：
public class CommandLambdaTest {
public static void main(String[] args) {
ProgressArray progressArray = new ProgressArray();
int[] array = { 3, -4, 6, 4 };
// 处理数组，具体行为取决于匿名内部类
progressArray.progress(array, (int[] target) -> {
int sum = 0;
for (int temp : array) {
sum += temp;
}
System.out.println("数组元素总和为" + sum);
});
}
}
当使用 Lambda 表达式代替匿名内部类创建对象时， Lambda 表达式的代码
块将会代替实现抽象方法的方法体， Lambda 表达式就相当一个匿名方法。
从上面语法格式可以看出， Lambda 表达式的主要作用就是代替匿名内部类的烦琐语法。它分三部分组成。
public class LambdaTest {
public static void main(String[] args) {
LambdaTest tester=new LambdaTest();
// 类型声明
MathOperation addition = (int a, int b) -> a + b;
// 不用类型声明
MathOperation subtraction = (a, b) -> a - b;
// 大括号中的返回语句
MathOperation multiplication = (int a, int b) -> {
return a * b;
};
// 没有大括号及返回语句
MathOperation division = (int a, int b) -> a / b;
System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
System.out.println("10 / 5 = " + tester.operate(10, 5, division));
// 不用括号
GreetingService greetService1 = message -> System.out.println("Hello " + message);
// 用括号
GreetingService greetService2 = (message) -> System.out.println("Hello " + message);
greetService1.sayMessage("Runoob");
greetService2.sayMessage("Google");
}
interface MathOperation {
int operation(int a, int b);
}
interface GreetingService {
void sayMessage(String message);
}
private int operate(int a, int b, MathOperation mathOperation) {
return mathOperation.operation(a, b);
}
}
Lambda 表达式的类型，也被称为"目标类型( target type) ", Lambda 表达式的目标类型必须是"函数式接口( functional interface ) "。 函数式接口代表只包含一个抽象方法的接口 。 函数式接口可以包含多个默认方法、类方法，但只能声明一个抽象方法 。
如果采用匿名内部类语法来创建函数式接口的实例，则只需要实现一个抽象方法，在这种情况下即可采用 Lambda 表达式来创建对象，该表达式创建出来的对象的目标类型就是这个函数式接口 。 查询 Java 8的 API 文档，可以发现大量的函数式接口，例如: Runnable、 ActionListener 等接口都是函数式接口 。
Java 8专门为函数式接口提供了 @FunctionalInterface 注解，该注解通常放在接口定义前面，该注解对程序功能没有任何作用，它用于告诉编译器执行更严格检查一一检查该接口必须是函数式接口 ，否则编译器就会报错。
由于 Lambda 表达式的结果就是被当成对象 ， 因此程序中完全可以使用 Lambda 表达式进行赋值，
例如如下代码 ：
// Runnable 接口中只包含一个无参数的方法
// Lambda 表达式代表的匿名方法实现了 Runnable 接口中唯一的、无参数的方法
// 因此下面的 Lambda 表达式创建了 一个 Runnable 对象
Runnable r = () -> {
for(int i = 0 ; i < 100 ; i ++){
System.out.println() ;
}
}
Lambda 表达式实现的是匿名方法，因此它只能实现特定函数式接口中的唯一方法 。 这意味着 Lambda 表达式有如下两个限制 ：
为了保证 Lambda 表达式的目标类型是一个明确的函数式接口，可以有如下三种常见方式 。
Object obj1 = (Runnable) () - > {
for(int i = 0 ; i < 100 ; i ++{
System.out.println(i);
}
如果 Lambda 表达式的代码块只有一条代码，程序就可以省略Lambda 表达式中
代码块的花括号 。 不仅如此，如果 Lambda 表达式的代码块只有一条代码，还可以在代码块中使用方法引用和构造器引用 。
方法引用和构造器引用可以让 Lambda 表达式的代码块更加简洁 。 方法引用和构造器引用都需要使用两个英文冒号。
//函数式接口
@FunctionalInterface
interface Converter{
//将 String 参数转换为Integer
Integer convert(String from);
}
// 下面代码使用 Larnbda 表达式创建 Converter 对象
Converter converterl = from -> Integer.valueOf(from);
//调用 converterl 对象的 convertO方法将字符串转换为整数
Integer val = converterl.convert( " 99 " );
System.out.println (val); // 输出整数 99
可以如下替换：
//方法引用代替 Larnbda 表达式:引用类方法
//函数式接口中被实现方法的全部参数传给该类方法作为参数
Converter converterl = Integer::valueOf;
// 下面代码使用 Larnbda 表达式创建 Converter 对象
Converter converter2 = from - > " fkit.org ".indexOf (from) ;
//调用 converterl 对象的 convertO方法将字符串转换为整数
Integer value = converter2.convert( "it "};
System.out.println(value} ; //输出 2
可以如下替换：
// 方法引用代替 Lambda 表达式 : 引用特定对象 的实例方法
// 函数式接口中被实现方法的全部参数传给该方法作为参数
Converter converter2 = "fkit.org": :indexOf ;
//定义函数式接口
@Functionallnterface
interface MyTest{
//根据 String 、 int 、 int 三个参数生成一个 String返回值
String test(String a , int b , int c);
}
// 下面代码使用 Lambda 表达式创建 MyTest 对象
MyTest mt = (a , b , c) - > a.substring(b , c};
//调用mt的test()方法
String str = mt.test( "Java 1 Love you" , 2 , 9) ;
System.out.println(str} ; // 输出 : va 1 Lo
可以如下替换：
// 方法引用代替 Lambda 表达式: 引 用某类对象 的实例方法
// 函数式接口中被实现方法的第一个参数作为调用者
// 后面的参数全部传给该方法作为参数
MyTest mt = String ::substring;
@Funct ionallnterface
interface YourTest{
//根据 String 参数生成一个 JFrame 返回值
JFrame win(String title);
// 下面代码使用 Lambda 表达式创建 YourTest 对象
YourTest yt = (String a) - > new JFrame(a);
JFrame jf = yt.win( "我的窗口 ") ;
System.out.println(jf) ;
可以如下替换：
// 构造器引用代替 Lambda 表达式
//函数式接口中被实现方法的全部参数传给该构造器作为参数
YourTest yt = JFrame ::new;
从前面介绍可以看出， Lambda 表达式是匿名内部类的一种简化 ， 因此它可以部分取代匿名内部类的作用。
Lambda 表达式与匿名内部类存在如下相同点 :
Lambda 表达式与匿名内部类主要存在如下区别:
参考：
【1】：《疯狂Java讲义》
【2】：https://www.jb51.net/article/171183.htm
【3】：https://www.runoob.com/java/java8-lambda-expressions.html
【4】：《Java核心技术 卷一》
Java Review (十六、面向对象----Lambda 表达式)
原文：https://www.cnblogs.com/three-fighter/p/13052767.html