Lambda 表达式
参考文档：
Lambda
使用场景 Lambda 只能使用在函数式接口，
什么是函数式接口： 就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。函数式接口可以被隐式转换为Lambda表达式。Lambda表达式和方法引用（实际上也可以认为是Lambda表达式）
interface MyInterface { // 函数式接口： 一个接口里面只有一个方法（并且这个方法是抽象的）
int show(int i, int k);
}
旧的接口实现
MyInterface m = new MyInterface() {
@Override
public int show(int i, int k) {
return 0;
}
};
m.show(1, 1);
Lambda接口实现
MyInterface m = (k, v) -> {
return k + v;
};
m.show(1, 1);
“::”方法引用
方法引用：方法引用可以理解为Lambda表达式的另外一种表现形式。
案例准备
public class Person {
private String name;
private String age;
public Person() {
}
public Person(String name, String age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age='" + age + '\'' +
'}';
}
public static int compare(Person a, Person b) {
int i = a.getAge().compareTo(b.getAge());
if (i != 0) {
return i;
} else {
return a.getName().compareTo(b.getName());
}
}
public static int compare(Person a, Person b, Person c) {
return 0;
}
// static 属于 class 不属于 对象
public Person concat(Person b) {
this.setName(this.getName() + "," + b.getName());
System.out.println(this);
return this;
}
}
五种实现方式
实现一：方法引用写法，调用 static 静态方法，参数类型动态推断
@Test
public void test() {
List<Person> list = new ArrayList<>();
list.add(new Person("liu", "1"));
list.add(new Person("zong", "2"));
list.add(new Person("lin", "3"));
// 传统写法
list.sort(new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return 0;
}
});
// lambda
list.sort((a, b) -> Person.compare(a, b));
// 方法引用写法，调用 static 静态方法，参数类型动态推断
list.sort(Person::compare);
System.out.println(list);
}
实现二：stream 留处理
@Test
public void test1() {
List<Person> list = new ArrayList<>();
list.add(new Person("liu", "1"));
list.add(new Person("zong", "2"));
list.add(new Person("lin", "3"));
list.stream().sorted(Person::compare).forEach(person -> System.out.println(person));
list.stream().sorted(Person::compare).forEach(System.out::println);
}
实现三：调用对象方法
@Test
public void test2() {
List<Person> list = new ArrayList<>();
list.add(new Person("liu", "1"));
list.add(new Person("zong", "2"));
list.add(new Person("lin", "3"));
Person a = new Person("liuzonglin", "1");
list.stream().sorted(Person::compare).forEach(a::concat);
}
实现四：:: new 实例化对象
@Test
public void test3() {
// stream 留处理
List<Person> list = new ArrayList<>();
list.add(new Person("liu", "1"));
list.add(new Person("zong", "2"));
list.add(new Person("lin", "3"));
Person a = new Person("liuzonglin", "1");
list.stream().sorted(Person::compare).collect(Collectors.toList());
list.stream().sorted(Person::compare).collect(Collectors.toCollection(ArrayList::new));
}
实现五：代特定实例
@Test
public void test4() {
String[] strings = {
"liu", "zong", "lin"
};
// 传统写法
Arrays.sort(strings, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return 0;
}
});
// lambda
Arrays.sort(strings, (a, b) -> a.compareToIgnoreCase(b));
// :: 写法 String指代a
Arrays.sort(strings, String::compareToIgnoreCase);
}