函数式编程定义
函数式编程是种编程方式，它将电脑运算视为函数的计算。函数编程语言最重要的基础是λ演算（lambda calculus），而且λ演算的函数可以接受函数当作输入（参数）和输出（返回值）。 和指令式编程相比，函数式编程强调函数的计算比指令的执行重要。和过程化编程相比，函数式编程里函数的计算可随时调用。——引自于百度百科函数式编程
Lambda表达式定义
Lambda表达式是一个匿名函数代码块，可作为表达式，方法参数和方法返回值。他所实现的匿名方法是在函数式接口中声明。
函数式接口
Lambda表达式实现的接口不是普通的接口，称为是函数式接口，这种接口只能有一个方法。为了防止在函数式接口中声明多个抽象方法，Java 8提供了一个声明函数式接口注释@FunctionalInterface代码如下：
package com.lambda_test1;
@FunctionalInterface
public interface Calculable {
int calcuateInt(int a,int b);
}
Lambda表达式的标准语法形式
(参数列表)->{
//Lambda表达式
}
Lambda简化形式
省略参数类型
(a,b)->{
//Lambda表达式
}
省略参数小括号
这种方法只适合当参数只有一个时
a->{
//Lambda表达式
}
省略return和大括号
这种方法只适合表达式体中只有一条语句
a->a*a*a;
栗子
设计一个通用方法，能够实现两个数值的加法和减法运算
未使用Lambda表达式
package com.lambda_test1;
public interface Calculable {
int calcuateInt(int a,int b);
}
package com.lambda_test1;
public class HelloWorld {
public static Calculable calculable( char opr){
Calculable result;
if(opr=='+'){
result= new Calculable() {
@Override
public int calcuateInt(int a, int b) {
return a + b;
}
};
}else result = new Calculable() {
@Override
public int calcuateInt(int a, int b) {
return a - b;
}
};
return result;
}
}
package com.lambda_test1;
public class main {
public static void main(String[] args) {
int n1=10;
int n2=5;
Calculable f1=HelloWorld.calculable('+');
Calculable f2=HelloWorld.calculable('-');
//调用calculateInt方法进行加法运算
System.out.printf("%d+%d=%d\n",n1,n2,f1.calcuateInt(n1,n2));
//调用calculateInt方法进行减法运算
System.out.printf("%d-%d=%d\n",n1,n2,f2.calcuateInt(n1,n2));
}
}
使用Lambda表达式进行重构
package com.lambda_test1;
public class HelloWorld {
public static Calculable calculable( char opr){
Calculable result;
if(opr=='+'){
result= (int a,int b)->{
return a+b;
};
}else result =(int a,int b)->{
return a-b;
};
return result;
}
}
Lambda表达式做参数使用
package com.lambda_test1;
@FunctionalInterface
public interface Calculable {
int calcuateInt(int a,int b);
}
package com.lambda.test2;
public class Main {
public static void main(String[] args) {
int n1 = 10;
int n2 = 5;
// 打印计算结果加法计算结果
display((a, b) -> {
return a + b;
}, n1, n2);
// 打印计算结果减法计算结果
display((a, b) -> a - b, n1, n2);
}
/**
* 打印计算结果
*
* @param calc Lambda表达式
* @param n1 操作数1
* @param n2 操作数2
*/
public static void display(Calculable calc, int n1, int n2) {
System.out.println(calc.calcuateInt(n1, n2));
}
}
访问成员变量
package com.lambda.test2;
public class Main {
// 实例成员变量
private int value = 10;
// 静态成员变量
private static int staticValue = 5;
// 静态方法，进行加法运算
public static Calculable add() {
Calculable result = (int a, int b) -> {
// 访问静态成员变量，不能访问实例成员变量
staticValue++;
int c = a + b + staticValue; // this.value;
return c;
};
return result;
}
// 实例方法，进行减法运算
public Calculable sub() {
Calculable result = (int a, int b) -> {
// 访问静态成员变量和实例成员变量
staticValue++;
this.value++;
int c = a - b - staticValue - this.value;
return c;
};
return result;
}
}
捕获局部变量
public class LambdaDemo {
// 实例成员变量
private int value = 10;
// 静态成员变量
private static int staticValue = 5;
// 静态方法，进行加法运算
public static Calculable add() {
//局部变量
int localValue = 20;
Calculable result = (int a, int b) -> {
// localValue++; //编译错误
int c = a + b + localValue;
return c;
};
return result;
}
// 实例方法，进行减法运算
public Calculable sub() {
//final局部变量
final int localValue = 20;
Calculable result = (int a, int b) -> {
int c = a - b - staticValue - this.value;
// localValue = c; //编译错误
return c;
};
return result;
}
}
使用Lambda创建线程
package com.it_51;
public class AnonymousClass {
static Thread t1=new Thread(new Runnable() {
@Override
public void run() {
System.out.println("线程的名字："+Thread.currentThread().getName());
}
},"匿名类创建的线程");
static Thread t2=new Thread(()->{
System.out.println("线程的名字："+Thread.currentThread().getName());
},"Lambda表达式创建的线程");
public static void main(String[] args) {
t1.start();
t2.start();
}
}
总结
Lambda表达式代替匿名内部类，使代码更加清晰！不显得那么臃肿。其中Lambda表达式作为参数传递也是一种常见的用法，它还可以访问所在外层定义域内的成员变量和局部变量。当他访问局部变量时，把变量作为final的，在表达式内部可以修改它们的值。
点击链接加入群聊【程序员技术交流群】：添加链接描述
