理解函数式接口以及 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
55
56
57
58
59
|
/**
* lambdab表达式的发展
*/
public class TestLambda1 {
//3.静态内部类
static class Like2 implements ILike{
@Override
public void lambda() {
System.out.println("i like lambda2");
}
}
public static void main(String[] args) {
ILike like=new Like();
like.lambda();
like=new Like2();
like.lambda();
//4.局部内部类
class Like3 implements ILike{
@Override
public void lambda() {
System.out.println("i like lambda3");
}
}
like=new Like3();
like.lambda();
//5.匿名内部类
like=new ILike() {
@Override
public void lambda() {
System.out.println("i like lambda4");
}
};
like.lambda();
//6.用lambda简化
like=()->{
System.out.println("i like lambda5");
};
like.lambda();
}
}
//1.定义一个函数式接口
interface ILike{
void lambda();
}
//2.实现类
class Like implements ILike{
@Override
public void lambda() {
System.out.println("i like lambda");
}
}
|
Lambda表达式及语法
Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
// 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)
|
也就是说，不需要事先声明参数的类型，圆括号可以没有，大括号可以没有，返回值可以没有
一起来看看具体的使用
|
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
|
public class java8_Lambda_Test {
public static final void main(String[] args) {
Operator addOper = (a, b) -> a + b;
Operator reduceOper = (a, b) -> a - b;
Operator multiplyOper = (a, b) -> a * b;
Operator DivideOper = (a, b) -> a / b;
java8_Lambda_Test test = new java8_Lambda_Test();
System.out.println(test.getResult(3, 3, addOper));//6
System.out.println(test.getResult(3, 3, reduceOper));//0
System.out.println(test.getResult(3, 3, multiplyOper));//9
System.out.println(test.getResult(3, 3, DivideOper));//1
}
public int getResult(int a, int b, Operator operator) {
return operator.convert(a, b);
}
public interface Operator {
int convert(int a, int b);
default int get(int a) {
return a;
}
}
}
|
你需要注意什么
1.lambda 表达式只能引用标记了 final 的外层局部变量
2.可以直接在 lambda 表达式中访问外层的局部变量
Lambda的实际运用
1.对集合排序
问题描述：在一个存放了Student对象的list中，按年龄进行排序，输出排序后的list
Student类
|
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
|
public class Student implements Comparable<Student>{
private String name;
private int 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 int compareTo(Student student2) {
int result =this.age - student2.age;
return result;
}
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
|
List<Student> list=new ArrayList<>();
Student s1=new Student();
s1.setName("张三");
s1.setAge(28);
list.add(s1);
Student s=new Student();
s.setName("李四");
s.setAge(22);
list.add(s);
sortUsingJava8(list);
list.forEach((student) -> System.out.println(student.getName() + ":"+student.getAge()));
|
|
1
2
3
4
|
// 使用 java 8 排序
static void sortUsingJava8(List<Student> list){
Collections.sort(list, (student1, student2) -> student1.compareTo(student2));
}
|
来康康使用Java7进行排序是这样的：
|
1
2
3
4
5
6
7
8
9
|
// 使用 java 7 排序
private void sortUsingJava7(List<String> list){
Collections.sort(list, new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return s1.compareTo(s2);
}
});
}
|
2.遍历集合
|
1
2
3
4
5
6
7
8
9
10
11
12
|
//先准备一个集合
List<Student> list=new ArrayList<>();
Student s1=new Student();
s1.setName("张三");
s1.setAge(28);
list.add(s1);
Student s=new Student();
s.setName("李四");
s.setAge(22);
list.add(s);
//使用 lambda 表达式以及函数操作(functional operation)
list.forEach((student) -> System.out.println(student.getName() + ":"+student.getAge()));
|
3.遍历集合（带条件）
|
1
2
3
4
5
|
//带条件 打印年龄大于等于20的学生的姓名
list.forEach((student)->{
if (student.getAge()>=20)
System.out.println(student.getName());
});
|
4.代替 Runnable，开启一个线程
|
1
2
3
4
5
6
7
8
|
Runnable r = new Runnable() {
@Override
public void run() {
//to do something
}
};
Thread t = new Thread(r);
t.start();
|
现在这样写：
|
1
2
3
4
5
|
Runnable r = () -> {
//to do something
};
Thread t = new Thread(r);
t.start();
|
你还可以这样写：
|
1
2
3
4
5
6
7
8
|
Thread t = new Thread(() -> {
//to do something
// such as for
for(int i = 0; i < 100; i++){
System.out.println(i);
}
});
t.start;
|
到此这篇关于Java中Lambda表达式的使用详解的文章就介绍到这了,更多相关Java Lambda内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://blog.csdn.net/sxh06/article/details/120126810