一:函数式编程思想概述:
面向对象的思想:
做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情。
函数式编程思想:
只要能获取到结果,谁去做的,怎么做的都不重要,重视的是结果,不重视过程。
在2014年3月Oracle所发布的Java8(JDK1.8)中,加入了Lambda表达式的重量级新特性。
Lambda更优写法
package Demo01.ONE;
public class Demo1 {
public static void main(String[] args) {
//使用匿名内部类的方式,实现多线程。
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"新线程被创建了");
}
}).start();
//使用Lambda表达式,实现多线程。
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"新线程被创建了");
}).start();
}
}
二:Lambda标准格式:
Lambda省去面向对象的条条框框,格式由3部分组成:
.一些参数
.一个箭头
.一段代码
Lambda表达式的标准格式为:
(参数类型 参数名称) -> {代码语句}
格式说明:
.小括号内的语法与传统方法参数列表一致:无参数则流空;多个参数则用逗号分隔。
.-.>是新引入的语法格式,代表执行动作。。
.大括号内的语法与传统方法要求基本一致。
三:Lambda表达式的无参数无返回值的
题目:
给定一个厨子cook接口,内含唯一的抽象方法makeFood,且无参数,无返回值,如下:
public interface cook{
void makeFood();
}
在下面的代码下,请使用Lambda的标准格式调用invokeCook方法,打印输出“吃饭啦1”字样;
public class Demo05InvokeCook{
public static void main(String[] args){
//TODO 请在此使用Lambda。[标准格式】调用invokeCook方法
}
private static void invokeCook(Cook cook){
cook.makeFood()
}
}
解答:
Cook接口
package Demo01.ONE;
/*
定义一个厨子Cook接口,内含唯一的抽象方法makeFood
*/
public interface Cook {
//定义无参数无返回值的方法makeFood
public abstract void makeFood();
}
Demo01Cook类
package Demo01.ONE;
/*
在下面的代码下,请使用Lambda的标准格式调用invokeCook方法,打印输出“吃饭啦1”字样;
*/
public class Demo01Cook {
public static void main(String[] args) {
//调用incokeCook方法,参数是Cook接口,传递Cook接口的匿名内部类对象。、
invokeCook(new Cook() {
@Override
public void makeFood() {
System.out.println("吃饭了");
}
});
//使用Lambda表达式,简化匿名内部类的书写
invokeCook(() ->{
System.out.println("吃饭了");
});
}
//定义一个方法,参数传递Cook接口,方法内部调用Cook接口中的方法makeFood
public static void invokeCook(Cook ccok){
ccok.makeFood();
}
}
四:Lambda表达式有参数有返回值的
需求:
使用数组存储多个Person对象
对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序
package Demo2;
import java.util.Arrays;
import java.util.Comparator;
/*
Lambda表达式有参数有返回值的练习:
需求:
使用数组存储多个Person对象
对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序
*/
public class Demo01Arrays {
public static void main(String[] args) {
//使用数组存储多个Person对象
Person[] arr={
new Person("一",2),
new Person("二",3),
new Person("三",4)
};
// 对数组中的Person对象使用Arrays的sort方法通过年龄进行升序{前面-后面)排序
/* Arrays.sort(arr, new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return o1.getAge()-o2.getAge();
}
});*/
//使用Lambda表达式,简化匿名内部类
Arrays.sort(arr,(Person o1,Person o2) ->{
return o1.getAge()-o2.getAge();
});
//遍历数组
for (Person p:arr){
System.out.println(p);
}
}
}
五:练习:使用Lambda标准格式(有参数有返回值)
给定一个计算器Calculator接口,内含抽象方法calc可以将两个int数字相加得到和值。
public interface Calculator{
int calc(int a,int b);
}
在下面的代码中,请使用Lambda的标准格式调用invokeCalc方法,完成120和130的相加计算
public class Demo08IncokeCalc{
public static void main(String[] args){
//TODO 请在此使用Lambda[标准格式]调用invokeCalc方法计算120+130的结果
}
private static void invokeCalc(int a,int b,Calculator calcuator){
int result =calculator.calc(a,b);
System.out.println("结果是:"+result);
}
解答:
package Demo2;
import java.util.Calendar;
/*
Lambda表达式有参数有返回值的练习
需求:
给定一个计算器Calculator接口,内含抽象方法calc将两个int数字相加得到和
使用Lambda的标准格式调用invokeCalc方法,完成120和130相加计算。
*/
public class Demo01Calculator {
public static void main(String[] args) {
//调用invokeCalc方法,方法的参数是一个接口,可以使用匿名内部类
invokeCalc(10, 20, new Calculator(){
@Override
public int calc(int a,int b){
return a+b;
}
});
//使用Lambda表达式简化匿名内部类的书写
invokeCalc(10, 20,(int a,int b) ->{
return a+b;
});
}
/*
定义一个方法
参数传递两个int类型的整数
参数传递Calculator接口
方法内部调用Calculator中方法calc计算两个整数的和
*/
public static void invokeCalc(int a, int b, Calculator c){
int sum =c.calc(a,b);
System.out.println(sum);
}
}
六:Lambda省略格式&Lambda使用前
package Demo03;
import java.util.ArrayList;
/*
Lambda表达式,是可以推导的,可以省略
凡是根据上下文推导出来的内容,都可以省略书写
可以省略的内容:
1:(参数列表);括号中参数列表的数据类型,可以省略不写
2:(参数列表);括号中的参数如果只有一个,那么类型和()都可以省略
3:(一些代码):如果()中的代码只有一行,无论是否有返回值,都可以省略({},return,分号}
注意:要省略{},return,分号必须一起省略,
*/
public class Demo01ArrayList {
public static void main(String[] args) {
//JDK1.7版主之前,创建集合对象必须把前后的泛型都写上。
ArrayList<String> list01 =new ArrayList<String>();
//JDK1.7版本之后,=号后边的泛型可以省略,后面的泛型可以根据前边的泛型推导出来。
ArrayList<String> list02 = new ArrayList<>();
}
}
七:Lambda的使用前提
Lambda的语法非常简洁,完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意:
1:使用Lambda必须具有接口,且要求“接口中有且仅有一个抽象方法”。
无论是JDK内置的Runnable,Compartor接口还是自定义的接口,只有当接口中的抽象方法存在且唯一时,才能使用Lambda。
2:使用Lambda必须具有上下文推断。
也就是方法的参数或局部变量类型必须为Lambda对应的接口类型,才能使用Lambda作为该接口的实例。
备注:有且仅有一个抽象方法的接口,称为“函数式接口"