简介
- Lambda 表达式,也可称为闭包(闭包就是能够将一个方法作为一个变量去存储,这个方法有能力去访问所在类的自由变量),它是推动 Java 8 发布的最重要新特性。
- Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中)。
- 使用 Lambda 表达式可以使代码变的更加简洁紧凑。
- lambda表达式并不可以对所有的接口进行简单实现,只有函数式接口可以使用lambda表达式
什么是函数式接口?
语法
()参数列表,{}方法体,-> lambda运算符(goes to)
lambda 表达式的语法格式如下:
(参数列表) -> 表达式
或
(参数列表) ->{ 语句; }
示例
先声明一个函数式接口
package com.cp.test;
/*函数式接口*/
@FunctionalInterface
public interface Add {
int addNum(int a, int b);
/*java1.8开始可以写default修饰的方法*/
default void add(int a, int b){
System.out.println(a+b);
}
}
有3种方法可以实现接口中的方法
package com.cp.test;
public class Test {
public static void main(String[] args) {
int a = 1;
int b = 2;
//第一种方法:写一个实现类实现接口中的方法,然后创建实现类对象调用该方法
//第二种方法:匿名内部类实现的方法
Add x = new Add() {
@Override
public int addNum(int a, int b) {
return a + b;
}
};
System.out.println("原始实现:"+x.addNum(a, b));
//第三种方法:使用lambda表达式
Add y = (int c, int d) -> {
return c + d;
};
System.out.println("lambda简化前"+y.addNum(a,b));
/*
* 语法简化
* 1.可以不写参数类型(要么都写类型,要么都不写)
* 2.如果只有一个参数,可以不写小括号
* 3.如果只有一条需要执行的语句可以不写大括号
* 4.如果只有一条语句,并且是return,可以省略return和大括号
* */
/*简化后*/
Add s = (m, n) -> m + n;
System.out.println("lambda简化后"+s.addNum(a, b));
}
}
在集合中的应用
对list和set集合进行排序(集合中存放的是对象)
先创建一个对象重写toString方法
package com.cp.lambda;
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", 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;
}
}
下面分别使用list和set集合存储6个不同的对象,然后按年龄排序输出
package com.cp.lambda;
import java.util.*;
public class ConnectionSort {
public static void main(String[] args) {
//创建对象
Person p1 = new Person("t1",15);
Person p2 = new Person("t2",19);
Person p3 = new Person("t3",5);
Person p4 = new Person("t4",11);
Person p5 = new Person("t5",25);
Person p6 = new Person("t6",15);
//集合中添加对象
List<Person> list = new ArrayList<>();
list.add(p1);
list.add(p2);
list.add(p3);
list.add(p4);
list.add(p5);
list.add(p6);
/*使用Collections工具类排序法*/
/*Collections.sort(list, new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return o2.getAge() - o1.getAge();
}
});*/
/*升序*/
list.sort(Comparator.comparingInt(Person::getAge));
/*使用lambda表达式降序输出*/
list.sort((q1,q2) -> q2.getAge()-q1.getAge());
System.out.println(list);
System.out.println("=====================================================");
/*
*@chenPing
* set排序
* 注意set集合有去重功能,所以用lambda表达式时需要注意,不能return0
* */
TreeSet<Person> set = new TreeSet<>((o1,o2) -> {
int age = o2.getAge() - o1.getAge();
if (age >= 0){
return 1;
} else {
return -1;
}
});
set.add(p1);
set.add(p2);
set.add(p3);
set.add(p4);
set.add(p5);
set.add(p6);
System.out.println(set);
}
}