Lambda表达式总结
Lambda作为Java8的新特性，本篇文章主要想总结一下常用的一下用法和api
1.接口内默认方法实现
public interface Formula {
double calculate(int a);
// 默认方法
default double sqrt(int a) {
return Math.sqrt(a);
}
}
public static void main(String[] args) {
Formula formula = new Formula() {
@Override
public double calculate(int a) {
return sqrt(a * 100);
}
};
double a1 = formula.calculate(100);
double b1 = formula.sqrt(16);
System.out.println(a1); // 100.0
System.out.println(b1); // 4.0
}
2.lambda表达式
List<String> names = Arrays.asList("peter", "anna", "xenia", "mike");
// 老版本
Collections.sort(names, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o2.compareTo(o1);
}
});
// lambda写法
Collections.sort(names, (o1, o2) -> o2.compareTo(o1));
// 更简易的写法
names.sort((a,b) -> b.compareTo(a));
System.out.println(names);
3.函数式接口(Funcation Interface)
java8中:: 关键字引用构造方法，对象方法和静态方法
// 定义： 仅仅包含一个抽象方法的接口, @FunctionalInterface只是一个标识,有没有都可以
// 只有函数式接口才能写成lambda表达式
@FunctionalInterface
public interface Convert<T, R> {
R convert(T from);
}
// :: 使用关键字来引用类的方法或者构造器
Convert<String, Integer> convert = Integer::valueOf; // 引用静态方法
Integer convert1 = convert.convert("123");
System.out.println(convert1);
String s = "hello";
Convert<Integer, String> convert2 = s::substring; // 引用构造方法
String convert3 = convert2.convert(1);
System.out.println(convert3);
Convert<String, String> convert5 = String::new; // 引用构造方法
System.out.println(convert5);
// 定义了一个函数式接口PersonFactory
public interface PersonFactory<P extends Person> {
P create(String firstName, String lastName);
}
class Person {
String firstName;
String lastName;
Person() {}
Person(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
@Override
public String toString() {
return "Person{" +
"firstName='" + firstName + '\'' +
", lastName='" + lastName + '\'' +
'}';
}
}
// 将Person的构造函数作为函数式接口的实现
PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("peter", "parker");
System.out.println(person);
4.lambda访问外部变量及接口默认方法
// 定义一个函数式接口
@FunctionalInterface
public interface Convert<T, R> {
R convert(T from);
}
// 由于Convert是函数式接口,所以可以写成lambda,也就是说可以作为lambda表达式的类型
int num = 1; // num被用在了lambda内,必须为final类型,这里没写是因为是隐式的final类型
Convert<Integer, String> convert4 = (from -> String.valueOf(from + num));
String result = convert4.convert(2);
System.out.println(result);
// 访问接口默认方法
@FunctionalInterface
public interface Formula {
double calculate(int a);
default double sqrt(int a) {
return Math.sqrt(a);
}
}
// 匿名内部类的访问方式
Formula formula = new Formula() {
@Override
public double calculate(int a) {
return sqrt(a * 100);
}
};
double a1 = formula.calculate(100);
double b1 = formula.sqrt(16);
System.out.println(a1);
System.out.println(b1);
// Formula formula = (a) -> sqrt(a * 100); 这个可不行,会编译报错
5.内置的函数式接口
5.1 Predicate断言
Predicate<String> isEmpty = String::isEmpty;
System.out.println(isEmpty.test("")); // true
Predicate<String> predicate = (s) -> s.length() > 0;
System.out.println(predicate.test("foo")); // true
// 返回test()取反的结果
System.out.println(predicate.negate().test("foo")); // false
5.2 Funcation
Function<String, Integer> function = Integer::valueOf;
// 将两个function组合起来， 先执行function在将function的输出作为输入计算x + 3最终输出结果
Function<String, Integer> function1 = function.andThen(x -> x + 3);
System.out.println(function1.apply("123"));
// compose, 从右往左执行
Function<Integer, Integer> addFunction = x -> x + 1;
Function<Integer, Integer> multiplyByTwo = x -> x * 2;
Function<Integer, Integer> square = x -> x * x;
Function<Integer, Integer> compose = addFunction.compose(multiplyByTwo).compose(square);
Integer apply = compose.apply(1);
System.out.println(apply); // 3
5.3 Supplier 生产者
// 不接收任何参数,直接返回一个指定的结果
Supplier<String> supplier = String::new;
String s1 = supplier.get(); // new String();
// 直接返回一个Person对象
Supplier<Person> supplier1 = Person::new;
Person person1 = supplier1.get();
System.out.println(person1);
5.4 Consumer消费者
// 提供入参 以供消费
Consumer<String> consumer = (p) -> System.out.println(p + " hello world!");
consumer.accept("123"); // 123 hello world!
5.5 Comparator
Comparator<Integer> comparator = (x1, x2) -> x1.compareTo(x2);
int compare = comparator.compare(1, 2);
System.out.println(compare); // 相等返0, 第一个参数 > 第二个参数返回1, 否则返回-1
6 Stream流
List<String> stringCollection = new ArrayList<>();
stringCollection.add("ddd2");
stringCollection.add("aaa2");
stringCollection.add("bbb1");
stringCollection.add("aaa1");
stringCollection.add("bbb3");
stringCollection.add("ccc");
stringCollection.add("bbb2");
stringCollection.add("ddd1");
6.1 Filter过滤
// filter（）
stringCollection.stream().filter((s3) -> s3.startsWith("a"))
.forEach(System.out::println);
6.2 Sorted 排序
// sorted()
stringCollection.stream().sorted().filter((s3) -> s3.startsWith("a"))
.forEach(System.out::println);
6.3 Map转换
// map()
stringCollection.stream().map(String::toUpperCase).sorted(String::compareTo).forEach(System.out::println);
6.4 Match匹配
// match()
boolean match = stringCollection.stream().anyMatch(s3 -> s3.startsWith("a"));
// 验证stringCollection中是否都不是以a开头
boolean match2 = stringCollection.stream().noneMatch(s3 -> s3.startsWith("a"));
boolean match3 = stringCollection.stream().allMatch(s3 -> s3.startsWith("a"));
System.out.println(match); // true
System.out.println(match2); // false
System.out.println(match3); // false
6.5 Count计数
// count()
long count = stringCollection.stream().filter(s3 -> s3.startsWith("a")).count();
System.out.println(count); // 2
6.6 Reduce
// reduce, 将多个元素归约成一个值
stringCollection.stream().sorted().reduce((s4, s5) -> s4 + "#" + s5).ifPresent(System.out::println);