目录
Lambda函数式编程详解
1.函数式编程思想概述
- 在数学中，函数就是有输入量，输出量的一套计算方案，也就是“拿什么东西做什么事情”。
- 相对而言，面向对象过分强调“必须通过对象的形式来做事情”，(找一个对象，调用对象的方法来完成事情)
- 而函数式思想则尽量忽略面向对象的复杂语法--强调做什么，而不是以什么形式做。
面向对象的思想:
- 做一件事情，找一个能解决这个事情的对象，调用对象的方法完成事情。比如获取随机数，可以找到Random对象，调用nextInt()方法获取随机数。存储一串数据，可以找数组和集合。
函数式的编程思想:
- 只要能获取到结果，谁去做的，怎么做的都不重要，重要的是做了什么，不重视过程。
2.冗余Runnable代码(传统写法)
当需要启动一个线程去完成任务时，通常会通过java.lang.Runnable接口来定义线程任务内容，并使用java.lang.Thread类来启动该线程。本着"一切皆对象"的思想，这种做法是无可厚非的：首先创建一个Runnable接口的匿名内部类对象
来指定任务内容，再将其交给一个线程来启动。
package Thread.demo18.Lambda;
//创建Runnable接口的实现类，重写run方法，设置线程任务
public class RunnableImpI implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"新线程创建了");
}
}
package Thread.demo18.Lambda;
/**
* 使用实现Runnable接口的方法创建多线程程序 (第1个线程)
*/
public class Demo1Runnable {
public static void main(String[] args) {
//创建Runnable接口实现类对象
RunnableImpI run=new RunnableImpI();
//创建Thread类对象，构造方法中传递Runnable接口的实现类
Thread t=new Thread(run);
//调用start方法开启新线程，执行run方法
t.start();
//简化代码，使用匿名内部类，实现多线程程序(第2个线程)
Runnable r=new Runnable(){ //使用Runnable接口接收对象(多态)
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"新线程创建了");
}
};
new Thread(r).start();
//再简化代码，不接收匿名内部类创建的对象 (第3个线程)
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"新线程创建了");
}
}).start();
}
}分析:
- 对于Runnable的匿名内部类用法，分析出几点内容:
- 1.Thread类需要Runnable接口作为参数，其中的抽象run方法是用来指定线程任务内容的核心。
- 2.为了指定run的方法体，不得不需要Runnable接口的实现类
- 3.为了省去定义一个Runnable接口的实现类，不得不使用匿名内部类
- 4.必须覆盖重写抽象run方法，所以方法名称、方法参数，方法返回值不得不再写一遍，且不能写错。
- 5.而实际上，似乎只有方法体才是关键所在。
3.编程思想转换
- 做什么，而不是怎么做
- 我们真的希望创建一个匿名内部类对象吗？不是的，我们只能为了做某件事情而不得不创建一个对象。我们真正希望做的事情是:将run方法体内的代码传递给Thread类知晓。
- 传递一段代码--这才是我们真正的目的。而创建对象只是受限于面向对象语法而不得不采取的一种手段方式。
- 那么，有没有更加简单的方法？如果将关注点从"怎么做"回归到"做什么"的本质上，就会发现只要能更好的达到目的，过程与形式其实并不重要。
- 2014年3月Oracle所发布的java8(JDK1.8)中，加入了Lambda表达式这个重量级新特新，为我们打开了新世界大门。
4.Lambda如何简化代码
- 要想使用接口中抽象方法，就需要实现这个接口并重写接口方法，为了避免创建接口实现类，采用匿名内部类方式虽然不再需要创建接口实现类，但还是需要每次重写接口中的抽象方法，为了更加简便，就采用Lambda方法，这样既不用创建接口实现类，也不用重写接口中抽象方法，只需要定义代码块(业务逻辑代码)。
- 从代码的语义中可以看出:我们启动了一个线程，而线程任务的内容以一种更加简洁的形式被指定。不再有"不得不创建接口对象"的束缚，不再有"抽象方法覆盖重写"的负担。
5.Lambda使用前提(条件)
Lambda语法非常简洁，完全没有面向对象复杂的束缚，但是使用时有几个注意:
- 1.使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。无论是JDK内置的Runnable、Comparator接口还是自定义接口，只有当接口中的抽象方法存在且唯一，才可以使用Lambda
- 2.使用Lambda必须有上下文推断。也就是说方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例
注意:
- 有且仅有一个抽象方法的接口，称为"函数式接口"
6.Lambda语法格式
- Lambda省去面向对象的条条框框，格式由3个部分组成:一些参数，一个箭头，一段代码
- Lambda表达式的标准格式为:(参数类型 参数名称)->{代码语句}
格式说明:
1.小括号代表接口中抽象方法(run)的参数列表，无参数则代表不需要任何条件；多个参数则逗号分离
2.箭头代表将前面的参数传递给后面的方法体
3.大括号内即为业务逻辑代码(重写接口中的抽象方法)
7.Lambda简化Runnable实现
从代码的语义中可以看出:
我们启动了一个线程，而线程任务的内容以一种更加简洁的形式被指定。
不再有"不得不创建接口对象"的束缚，不再有"抽象方法覆盖重写"的负担。
package Thread.demo18.Lambda;
/**
* 体验Lambda的更优写法：
*/
public class Demo2Lambda {
public static void main(String[] args) {
//1.使用匿名内部类方式，实现多线程
new Thread(new Runnable(){
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"新线程创建了");
}
}).start();
//2.使用Lambda表达式，实现多线程
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"新线程创建了");
}).start();
}
}8.Lambda无参无返回值写法
需求:
* 给定一个厨子(Cook)接口，内含唯一的抽象方法makeFood,且无参数，无返回值
* 使用Lambda标准格式调用invokeCook方法，打印输出"吃饭啦"
package Thread.demo19.Lambda;
public interface Cook {
//1.给定一个厨子(Cook)接口，内含唯一的抽象方法makeFood,且无参数，无返回值
public abstract void makeFood();
}
package Thread.demo19.Lambda;
public class Demo1Cook {
public static void main(String[] args) {
//3.调用invokeCook方法，参数是Cook接口，传递Cook接口的匿名内部类对象(传统写法)
invokeCook(new Cook(){ //Cook接口的匿名内部类中重写接口中抽象方法
@Override
public void makeFood() {
System.out.println("吃饭啦1");
}
});
//4.使用Lambda表达式简化匿名内部类书写
// 省去创建匿名内部类对象和重写接口中抽象方法,直接传递方法体
invokeCook(()->{System.out.println("吃饭啦2");});
}
//2.定义一个方法，参数传递Cook接口，方法内部调用Cook接口中的makeFood方法
public static void invokeCook(Cook cook){
cook.makeFood();
}
}9.Lambda有参有返回值写法
需求:
* 使用数组存储多个Person对象
* 对数组中的Person对象使用Arrays工具类中的sort方法通过年龄进行升序排序
package Thread.demo20.Lambda;
import java.util.Arrays;
import java.util.Comparator;
public class Demo1Lambda {
public static void main(String[] args) {
//1.使用数组存储多个Person对象，数组类型为Person，对象数组
Person[] arr={
new Person("牧尘",18),
new Person("洛璃",17),
new Person("笋儿",15),
};
/**
2.对数组中的Person对象使用Arrays的sort方法通过年龄进行升序(前边-后边)排序
sort方法中两个参数，一个是数组，一个是Comparator接口，
后者可以使用接口的匿名内部类对象作为参数，并重写接口中抽象方法compare
* Arrays.sort(arr, new Comparator<Person>() {
* @Override
* public int compare(Person o1, Person o2) {
* return o1.getAge()-o2.getAge();
* }
* });
*/
//3.使用Lambda表达式，来简化上述2中匿名内部类
Arrays.sort(arr,(Person o1, Person o2)->{return o1.getAge()-o2.getAge();});
//4.遍历数组
for (Person p:arr) {
//println底层是toString方法，已经在Person中被重写了，
System.out.println(p);
/**输出:
* Person{name='笋儿', age=15}
* Person{name='洛璃', age=17}
* Person{name='牧尘', age=18}
*/
}
}
}* 需求2:
* 1.定义一个计算器Calculator接口，内含抽象方法calc可以将两个数字相加求和
* 2.使用Lambda的标准格式调用invokeCalc方法，完成120和130求和
package Thread.demo21.Lambda;
/**
* 1.定义一个计算器Calculator接口，内含抽象方法Calc可以将两个数字相加求和
*/
public interface Calculator {
//定义一个计算两个Int整数和的方法并返回结果
public abstract int calc(int a,int b);
}
package Thread.demo21.Lambda;
public class Demo1Calculator {
public static void main(String[] args) {
/**
* 3.调用invokeCalc方法，方法的一个参数是接口，可使用匿名内部类对象:
* invokeCalc(120, 130, new Calculator() {
* @Override //匿名内部类中重写接口方法
* public int calc(int a, int b) {
* return a + b;
* }
* });
*/
//4.使用Lambda表达式简化上述3中匿名内部类的书写
invokeCalc(120,130,(int a,int b)->{return a+b;});
}
/**
* 2.定义一个方法invokeCalc
* 参数传递两个Int整数
* 参数传递Calculator接口(接口可以接收对象，属面向接口编程)
* 方法内部调用Calculator接口中抽象方法calc来求和
*/
public static void invokeCalc(int a, int b, Calculator c) {
int sum = c.calc(a, b);
System.out.println(sum);
}
}10.Lambda省略格式
- Lambda表达式:是可推导，可省略的
- 凡是根据上下文推到出来的内容，都可以省略书写
可以省略的内容:
- 1.(参数列表):括号中参数列表的数据类型，可以省略不写
- 2.(参数列表):括号中的参数如果只有一个，那么类型和()都可以省略
- 3.{代码块}:如果{}中的代码只有一行，无论是否有返回值，都可省略{},return,分号
- 注意:要省略{},return,分号，就必须同时省略。
package Thread.demo22.Lambda;
public class Demo1Person {
private String name;
private int age;
public Demo1Person() {}
public Demo1Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public int getAge() { return age; }
public void setAge(int age) { this.age = age; }
@Override
public String toString() {
return "Demo1Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package Thread.demo22.Lambda;
import Thread.demo20.Lambda.Person;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
public class Demo1ArrayList {
public static void main(String[] args) {
//JDK1.7版本之前，创建集合对象必须把前后泛型都写上
ArrayList<String> list01=new ArrayList<String>();
//JDK1.7之后，等号后边的泛型可以省略，后边的泛型可以根据前边的泛型推到出来
ArrayList<String>list02=new ArrayList<>();
//1.1.使用匿名内部类创建多线程1
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"新线程创建");
}
}).start();
//1.2.使用Lambda表达式创建多线程2 (优化匿名内部类书写)
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"新线程创建");}
).start();
//1.3.优化省略Lambda创建多线程3
new Thread(()->
System.out.println(Thread.currentThread().getName()+"新线程创建")
).start();
//2.1.使用匿名内部类对对象数组按年龄升序排序
Demo1Person[] p={
new Demo1Person("墨灵",22),
new Demo1Person("墨峰",23),
new Demo1Person("九幽",20),
new Demo1Person("牧尘",19),
};
Arrays.sort(p, new Comparator<Demo1Person>() {
@Override
public int compare(Demo1Person o1, Demo1Person o2) {
return o1.getAge()-o2.getAge();
}
});
for(Demo1Person arr:p){
System.out.println(arr);
}
/**
* 2.2.使用Lambda表达式替代匿名内部类
* Arrays.sort(p,(Demo1Person o1, Demo1Person o2)->{
* return o1.getAge()-o2.getAge();
* });
*/
/**
* 2.3.优化Lambda表达式
* Arrays.sort(p,(o1, o2) ->o1.getAge()-o2.getAge());
*/
}
}
794
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
