lambda表达式是JDK8引入的新功能（语法糖），类似JS中的闭包；通过一个匿名的方法（函数化的语法）简化编写代码的方式。
- 基本结构 (arguments) -> body
- 参数类型可推导时，不需指定类型： (a,b) -> a + b
- 当仅有一个参数且类型可推导时，不强制写 () ： a -> a + 1
- 参数指定类型，必须有括号： (Integer i) -> i + 1
- 参数可为空： () -> "hello, lambda"
- body需要用 {} 包含语句，当仅有一条语句时可省略
- lambda表达式与匿名内部类的区别
|
- |
lambda表达式 |
匿名内部类 |
|
类型不同 |
只支持单抽象方法的接口 |
接口、抽象类、具体类 |
|
是否需要实例化 |
否 |
需要 |
|
内存分配 |
只需分配一次内存，存储在堆的永久区中 |
类被新建时，需要给对象分配内存 |
|
实现原理 |
编译后，无单独的字节码文件，对应字节码在运行时动态生成 |
编译后，生成单独的字节码文件 |
一、函数式接口
函数式接口：只有一个抽象方法的接口，目的是为了某一个单一的操作
函数式接口声明，在接口上添加注解 @FunctionalInterface
- JDK8之前已存在被标注为函数式接口的接口
- java.lang.Runnable
- java.util.Comparator
- java.util.concurrent.Callable
- java.io.FileFilter
- java.security.PrivilegedAction
- java.beans.PropertyChangeListener
- JDK8新增的函数式接口（基于java.util.function包下）
- Function：函数，T -> R
- BiFunction：函数，(T,U) ->R
- Predicate：断言/判断，T -> boolean
- BiPredicate：断言/判断，(T,U) -> boolean
- Supplier：生产者，() -> T
- Consumer：消费者，(T) -> ;
- BiConsumer：消费者，(T,U) ->;
- UnaryOperator：单元运算，(T) -> T
- BinaryOperator：二元运算，(T,T) -> T
- BooleanSupplier, DoubleBinaryOperator, DoubleConsumer, DoubleFunction, DoublePredicate, DoubleSupplier, DoubleToIntFunction, DoubleToLongFunction, DoubleUnaryOperator, IntBinaryOperator, IntConsumer, IntFunction, IntPredicate, IntSupplier, IntToDoubleFunction, IntToLongFunction, IntUnaryOperator, LongBinaryOperator, LongConsumer, LongFunction, LongPredicate, LongSupplier, LongToDoubleFunction, LongToIntFunction, LongUnaryOperator, ToDoubleBiFunction, ToDoubleFunction, ToIntBiFunction, ToIntFunction, ToLongBiFunction, ToLongFunction等
0、总结
-
如无参数，请使用Supplier（Use Supplier if it takes nothing）
-
如无返回，请使用Consumer（Use Consumer if it returns nothing）
-
如两者都无，请使用Runnable（Use Runnable if it does neither）
-
如两者都有，请使用Function（Use Function if it does both）
-
如返回布尔值，请使用Predicate（Use Predicate if it returns a boolean）
-
如以上皆不可以，请使用自定义@FunctionalInteface（Use @FunctionalInteface if none of above works）
1、快速使用
1）简化匿名函数式接口实现
函数式接口：只包含一个抽象方法声明的接口
List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
Collections.sort(names, new Comparator<String>() {
@Override
public int compare(String a, String b) {
return b.compareTo(a);
}
});
- 写法
// 写法1：简化匿名类写法 Collections.sort(names, (String a, String b) -> { return b.compareTo(a) }); // 写法2：在1的基础上，省略方法参数类型 Collections.sort(names, (a, b) -> { return b.compareTo(a) }); // 写法3：在2的基础上，单行方法省略return和{} Collections.sort(names, (a, b) -> b.compareTo(a));
2）方法和构造函数引用
- Converter接口
@FunctionalInterface interface Converter<F, T> { T convert(F from); }
- 写法
//原始写法 Converter<String, Integer> converter0 = new Converter<String, Integer>() { @Override public Integer convert(String from) { return Integer.valueOf(from); } }; //lamada表达式写法：(from) -> Integer.valueOf(from)返回一个接口实现类 Converter<String, Integer> converter1 = (from) -> Integer.valueOf(from); Integer converted1 = converter1.convert("123"); // 更进一步的简化写法 Converter<String, Integer> converter2 = Integer::valueOf; Integer converted2 = converter2.convert("123");
- 实现Person类构造函数的引用
class Person { String firstName; String lastName; Person() {} Person(String firstName, String lastName) { this.firstName = firstName; this.lastName = lastName; } } interface PersonFactory<P extends Person> { P create(String firstName, String lastName); } PersonFactory<Person> personFactory = Person::new; Person person = personFactory.create("Peter", "Parker");
3) lambda访问范围
- 局部变量
- 外部变量在lambda内部使用时，会在编译时隐式声明final修饰
int num = 1; // 等同于final int num = 1; Converter<Interge, String> converter = (from) String.valueOf(from + num);
- 成员变量与静态成员变量
- 支持在lambda内部读写操作
public class VarTest { int num; static staticNum; @Test public void test() { Converter<Integer, String> converter = (from) -> { num = 1; return String.valueOf(from + num); }; Converter<Integer, String> staticConverter = (from) -> { staticNum = 2; return String.valueOf(from + staticNum); }; } }
- default接口方法
- 编译不支持
2、内置函数式接口
1. Predicate<T>
- 布尔类型函数，处理复杂逻辑判断，test方法为执行方法
-
- and(Predicate p)：与其他Predicate对象组成全满足关系
- or(Predicate p)：与其他Predicate对象组成满足任一即可关系
- negate()：结果取反
// 判断整数是否在[60,100]区间内 Predicate<Integer> predicate = i -> i >= 60 && i <= 100; // test方法最终执行逻辑判断 predicate.test(10); // false predicate.test(100); // true
2. Function<T, R>
- 接收单一参数返回单一结果，apply方法为执行方法
-
- andThen(Function f)：下一个执行Function
- compose(Function f)：在此之前执行Function
Function<Integer, Integer> add = x -> x + 10; Function<Integer, Integer> mul = x -> x * 2; add.andThen(mul).apply(3); // (3 + 10) * 2 = 26
3. Supplier<T>
- 获得一个给定类型的结果，无入参
Supplier<Integer> supplier = () -> 1; supplier.get(); // 1
4. Consumer<T>
- 接收单一入参无返回结果
-
- andThen(Consumer c)：链式追加
Consumer<Person> consumer = p -> { p.setAge(p.getAge() + 1); } consumer.accept(new Person("Test", 1));
5. Comparators
- 接收两个同类型参数，比较大小
List<Person> list = ListUtils.list(new Person("a", 33), new Person("d", 15), new Person("b", 22), new Person("e", 15)); // 按age降序,再按name倒序 list.sort(Comparator.comparing(Person::getAge) .thenComparing(Person::getName).reversed());
6. Optionals
- 存储一个对象值，解决NPE问题
// 传统写法 if (user == null) { doSomething(); } // 优雅写法 Optional.ofNullable(user).ifPresent(u -> doSomething()); // orEles-不论Optional对象是否含空值，都会执行调用 // orElseGet-则只会在Optional对象含空值时调用 Optional.ofNullable(null).orElse(createNewUser()); Optional.ofNullable(null).orElseGet(createNewUser()); // filter 结果为true则返回对象，否则返回含空值的Optional Optional.ofNullable(new User("a")) .filter(u -> StringUtils.equals("a", user.getName())); // orElseThrow 存在值则返回，否则抛出异常 Optional.ofNullable(null) .orElseThrow(() -> { // do something return new RuntimeException("NPE"); }); // map：对实例值操作，并封装为Optional返回 // flatMap：对实例值操作，不封装Optional返回 Optional.ofNullable("jack") .map((s) -> s.toUpperCase()) .orElse("NPE"); Optional.ofNullable("jack") .map((s) -> Optional.ofNullable(s.toUpperCase())) .orElse("NPE");
二、方法引用
1、快速使用
- 语法
-
- 构造方法引用： Type::new
- 数组构造方法引用：Type[]::new
- 静态方法引用：Type::methodName
- 实例对象的实例方法引用：instanceName::methodName
- 实例类型的实例方法引用：Type::methodName
// 方法引用写法 Function<String, Integer> function = Integer::new; // lambda写法 function = str -> new Integer(str); // 传统写法 function = new Function<String, Integer>() { public Integer apply(String str) { return new Integer(str); } } // 数组构造方法引用 Function<Integer, String[]> function = String[]::new; // lambda写法 function = length -> new String[length]; // 传统写法 function = new Function<Integer, String[]>() { public String[] apply(Integer length) { return new String[length]; } } // 静态方法引用 Function<Integer, String[]> function = String[]::new; // lambda写法 function = length -> new String[length]; // 传统写法 function = new Function<Integer, String[]>() { public String[] apply(Integer length) { return new String[length]; } } // 实例对象的实例方法引用 List list = Arrays.asList("bikaqiu", "bikabika", "bika"); Predicate<String> predicate = list::contains; // 实例类型的实例方法引用 Function<String, Integer> function = String::length;
2、方法引用
语法： Type::methodName 或 instanceName::methodName ，后者methodName为new
1. 构造方法引用
语法： Type::new
// 整数String转换为Integer // 方法引用写法 Function<String, Integer> f = Integer::new; // lambda写法 f = s -> new Interger(s); // 传统写法 f = new Function() { public Integer apply(String s) { return new Integer(s); } }
2. 数组构造方法引用
语法： Type[]::new
// 构造指定长度的String数组 // 方法引用写法 Function<Integer, String[]> f = String[]::new; // lambada f = length -> new String[length];
3. 静态方法引用
// lambda写法 Function<String,Integer> f = s -> Integer.parseInt(s); // 方法引用写法 Function<String,Integer> f = Integer::parseInt;
4. 实例方法引用
// 判断List中是否存在指定String List<String> names = Arrays.asList(new String[]{"Tom", "summery"}); Predicate check = names::contains; check.test("Tom"); // true
5. 类型方法引用
// 输出String的长度 Function<String, Integer> f = String::length; System.out.println(f.apply("TomCat")); // 输出List中每个String元素的长度 List<String> names = Arrays.asList(new String[]{"Tom", "summery"}); names.stream().map(String::length).forEach(System.out::println); // 切割字符串 BiFunction<String, String, String[]> sp = String::split; String[] apply = sp.apply("this.is.Test,sdjsk.sdfav", "\\.");
三、Stream
JDK8引入的新特性， java.util.stream 包中，是一组支持串行并行聚合操作的元素，即集合/迭代器的增强版
- stream()：串行执行流对象操作
- paralleStream()：并行执行流对象操作
- Arrays.stream(T array)：将数组转换为流对象操作
- 特性
- 单次处理，即一次处理完毕后，当前Stream关闭
- 支持并行操作
- 流的基本步骤
- 获取数据源
- 数据转换：每次转换原有Stream对象不改变，会返回新Stream对象
- 执行操作获取结果
1、方法
1. forEach
- 流中止操作，遍历每个元素
List<String> list = Arrays.asList("B", "C", "H", "A");
// 简写list.stream().forEach(System.out::println);
list.stream().forEach(e -> System.out.println(e));
2. filter
- 流中间操作，接收一个Predicate对象，对每一个元素进行过滤，常用配合collect或其他操作
// 过滤过于大于50和小于0的元素，取最大值 List<Integer> list = Arrays.asList(40, 2, 33, 55, 32, 14, 5, 10, -10, -33); Integer max = list.stream().filter(i -> i <= 50 && i >= 0).max(Integer::compareTo).get();
3. sorted
- 流中间操作，对集合进行排序并返回流对象；该操作不改变原集合对象顺序，仅返回一个排序过的流对象视图
List<String> list = Arrays.asList("B", "C", "H", "A");
// 默认自然排序
list.stream().sorted().forEach(System.out::println);
// 降序
list.stream().sorted(Comparator.reverseOrder()).forEach(System.out::println);
// 自定义排序
list.stream().sorted(Comparator.comparing(String::toString)).forEach(System.out::println);
4. map
- 流中间操作，将流中的每个元素对应到另一个对象中
List<String> list = Arrays.asList("Bob", "Car", "Height", "ALICE");
# 将字符串变为全小写输出
list.stream().map(s -> s.toLowerCase(Locale.CHINA)).forEach(System.out::println);
5. match
- 流中止操作，判断某一种规则是否与流对象中的元素匹配，返回Boolean值
List<String> list = Arrays.asList("Bob", "Car", "Height", "ALICE");
// 判断元素中是否任一满足首字符为B
list.stream().anyMatch(s -> s.startsWith("B")); // true
// 判断元素中是否都满足首字符为B
list.stream().allMatch(s -> s.startsWith("B")); // false
// 判断元素中是否都不满足首字符为B
list.stream().noneMatch(s -> s.startsWith("B")); // false
6. count
- 流中止操作，返回当前流对象中元素数目
List<String> list = Arrays.asList("Bob", "Car", "Height", "ALICE");
// 满足开头首字符为B或A的元素数目
list.stream().filter(s -> s.startsWith("B") || s.startsWith("A")).count(); // 2
7. reduce
- 规约，可作为累加器、累乘器
// Optional<T> reduce(BinaryOperator<T> accumulator); Arrays.asList(1, 2, 3).stream().reduce((a, b) -> a + b).get()); // 6 // T reduce(T identity, BinaryOperator<T> accumulator); 相对上一个使用多了一个初始值设置 Arrays.asList(1, 2, 3).stream().reduce(0， (a, b) -> a + b)); // 6
8. concat
- 流连接
// 连接两个流并打印 Stream.concat(Stream.of(1, 2), Stream.of(3)).forEach(System.out::print); // 123
9. peek
- 生成包含原Stream流所有元素的新Stream流，且新Stream流每个元素被消费前执行peek给定的消费函数
// 打印元素前先打印元素-1的值 Stream.of(2, 4).peek(x -> System.out.print(x - 1)).forEach(System.out::print); // 1234
10. max/min
- 获取最大或最小元素
- 存在多个最值相同的元素，则返回首个最值元素
List<Integer> list = Arrays.asList(40, 2, 33, 55, 32, 14, 5, 10); Integer max = list.stream().max(Integer::compareTo).get();
11. limit
- 截取前N个元素
// 截取前四位取最小值 List<Integer> list = Arrays.asList(40, 2, 33, 55, 32, 14, 5, 10, -10, -33); list.stream().limit(4).forEach(System.out::println);
12. collect
将处理后的Stream流组装成集合
// 过滤负数元素 List<Integer> list = Arrays.asList(33, -10, 60 ,-4, 6, 80 , -33); List<Integer> collect = list.stream().filter(i -> i >= 0).collect(Collectors.toList()); // User[id,name,age] // 将List<User>转换为Map<id, name> userList.stream().collect(Collectors.toMap(User::getId, User::getName)); // 将List<User>转换为Map<id, User> userList.stream().collect(Collectors.toMap(User::getId, User -> User)); userList.stream().collect(Collectors.toMap(User::getId, Function.identity())); // List<User>存在key冲突问题转换 userList.stream().collect(Collectors.toMap(User::getId, Function.identity(), (k1, k2) -> k2));
注意点（踩坑）
- 使用Collectors.toMap(key, value)时，要注意key不能重复，否则默认的合并策略会抛出异常提示重复KEY：Duplicate key
- 源码
public static <T, K, U> Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper) { return toMap(keyMapper, valueMapper, throwingMerger(), HashMap::new); } private static <T> BinaryOperator<T> throwingMerger() { return (u,v) -> { throw new IllegalStateException(String.format("Duplicate key %s", u)); }; }
- 解决办法：手动指定合并策略，走重载方法
List<JSONObject> list = new ArrayList<>(10); list.add(buildJSONObject("1", "n1")); list.add(buildJSONObject("1", "n2")); list.add(buildJSONObject("2", "n3")); list.stream .collect(Collectors.toMap(d -> d.getString("id"), d -> d, (oldValue, newValue) -> newValue));
- 使用该方法返回Map时，要避免Value为NULL值，否则在合并时会抛出NPE异常
- 源码
public static <T, K, U, M extends Map<K, U>> Collector<T, ?, M> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier) { BiConsumer<M, T> accumulator = (map, element) -> map.merge(keyMapper.apply(element), valueMapper.apply(element), mergeFunction); return new CollectorImpl<>(mapSupplier, accumulator, mapMerger(mergeFunction), CH_ID); } // Map.merge() default V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction) { Objects.requireNonNull(remappingFunction); Objects.requireNonNull(value); // 此处就是Value为NULL时抛出NPE的地方 V oldValue = get(key); V newValue = (oldValue == null) ? value : remappingFunction.apply(oldValue, value); if(newValue == null) { remove(key); } else { put(key, newValue); } return newValue; }
- 解决方式：在collect调用前使用filter过滤Value为NULL的情况；或者Value回写Map时做判断NULL初始化
list.stream
.filter(Objects::nonNull)
.collect(Collectors.toMap(d -> d.getString("id"), d -> d, (oldValue, newValue) -> newValue));
mapToInt/mapToLong/mapToDouble
- 汇总数据对象：IntSummaryStatistics, DoubleSummaryStatistics, LongSummaryStatistics
- 对应方法：getCount（总数）、getMax（最大值）、getMin（最小值）、getAverage（平均值）
List<Integer> list = Arrays.asList(33, -10, 60 ,-4, 6, 80 , -33);
IntSummaryStatistics summary = list.stream().mapToInt(Integer::intValue).summaryStatistics();
2、用法
- 遍历索引
List<String> list = Arrays.asList("a", "b", "c", "d");
Stream.iterate(0, i -> i + 1).limit(list.size()).forEach(i -> {
System.out.println(i + ":"+ list.get(i));
});
- 分组统计
/* [Person{c='A', d=10, e=75}, Person{c='B', d=24, e=61}, Person{c='D', d=16, e=20}, * Person{c='A', d=17, e=99}, Person{c='C', d=20, e=67}, Person{c='D', d=10, e=14}, Person{c='B', d=4, e=41}, Person{c='A', d=29, e=35}, Person{c='A', d=6, e=61}, Person{c='D', d=4, e=42}] */ // 按C进行分组，并对D汇总 Map<String, Integer> d = list.stream() .collect(Collectors.groupingBy(Person::getC, Collectors.summingInt(Person::getD))); // {A=62, B=28, C=20, D=30} // 按C进行分组，并对E汇总（不支持BigDecimal，使用reducing解决） Map<String, BigDecimal> e = list.stream().collect(Collectors.groupingBy(Person::getC, Collectors.reducing(BigDecimal.ZERO, Person::getE ,BigDecimal::add))); // {A=270, B=102, C=67, D=76} // 一次返回以分组统计好的通类型对象 List<Person> collect = group.entrySet().stream().map(entry -> { Person p = new Person(); p.setC(entry.getKey()); p.setD(entry.getValue().stream().map(Person::getD).reduce(Integer::sum).orElse(0)); p.setE(entry.getValue().stream().map(Person::getE).reduce(BigDecimal.ZERO, BigDecimal::add)); return p; }).collect(Collectors.toList()); // [Person{c='A', d=75, e=304}, Person{c='B', d=4, e=17}, Person{c='D', d=36, e=255}]