内容简介:Java8回忆录 - Lambda
本文主要介绍 Java8
的 Lambda
表达式
基本语法
(parameters) -> expression (parameters) -> {statements;}
Apple
相关代码托管在 java8_demo
@Data @AllArgsConstructor @NoArgsConstructor public class Apple{ public static enum COLOR { GREEN, RED } public static final int HEAVY_WEIGHT = 200; private COLOR color; private Integer weight; }
实例
(String s) -> s.length() // 等价于 int f(String s){ return s.length(); } (Apple a) -> a.getWeight() > Apple.HEAVY_WEIGHT // 等价于 boolean f(Apple a){ return a.getWeight() > Apple.HEAVY_WEIGHT; } (int x, int y) -> { System.out.println("Result:"); Syetem.out.println(x+y; } // 等价于 void f(intx,inty){ System.out.println("Result:"); Syetem.out.println(x+y; } () -> 42 // 等价于 int f(){ return 42; } (Apple a1 , Apple a2) -> a1.getWeight() > a2.getWeight // 等价于 boolean f(Apple a1 , Apple a2){ return a1.getWeight() > a2.getWeight;}
函数式接口 + 函数描述符
函数式接口
-
定义:只定义了
一个抽象方法
(排除default
方法)的接口 -
用途:
Lambda
表达式允许直接以内联
的形式,为函数式接口的抽象方法提供实现
,并把整个表达式作为函数式接口的实例
函数描述符
-
定义:
函数式接口的抽象方法的签名
-
函数描述符
=函数式接口的抽象方法的签名
=Lambda表达式的签名
Lambda 出现的地方
-
赋值给一个变量(类型为
函数式接口
) -
传递给一个接受
函数式接口为参数的方法
自定义函数式接口
函数式接口
@FunctionalInterface public interface Change{ // 只有一个抽象方法 Integeraction(Integer param); }
函数描述符: Integer -> Integer
单元测试
private int localChange(intparam, Change change){ return change.action(param); } @Test public void multipyTest(){ // Lambda 能够赋值给一个函数式接口的变量(前提是函数式接口的抽象方法的签名 = Lambda 表达式的签名) Change multiply = param -> param * 3; assertEquals(15, localChange(5, multiply)); // Lambda 能够传递给一个接受函数式接口为参数的方法(前提是函数式接口的抽象方法的签名 = Lambda 表达式的签名) assertEquals(4, localChange(3, param -> param + 1)); }
常用内置函数式接口
函数式接口 | 函数描述符 |
---|---|
Predicate<T>
|
T -> boolean |
Consumer<T>
|
T -> void |
Supplier<T>
|
() -> T |
Function<T,R>
|
T -> R |
BiFunction<T,U,R>
|
(T,U) -> R |
BiPredicate<T,U>
|
(T,U) -> boolean |
BinaryOperator<T> extends BiFunction<T,T,T>
|
(T,T) -> T |
BiConsumer<T,U>
|
(T,U) -> void |
UnaryOperator<T> extends Function<T,T>
|
T -> T |
Predicate
定义
@FunctionalInterface public interface Predicate<T>{ boolean test(T t); }
函数描述符: T -> boolean
实例
private <T> List<T>predicate(List<T> list, Predicate<T> predicate){ List<T> result = new ArrayList<>(); for (T t : list) { if (predicate.test(t)) { result.add(t); } } return result; } @Test public void predicateTest(){ assertEquals(2, predicate(Arrays.asList("zhongmingmao", "", null), s -> null == s || s.isEmpty()).size()); }
Consumer
定义
@FunctionalInterface public interface Consumer<T>{ void accept(T t); }
函数描述符: T -> void
实例
private <T> void consume(List<T> list, Consumer<T> consumer){ for (T t : list) { consumer.accept(t); } } @Test public void consumerTest(){ consume(Arrays.asList(1, 2, 3), integer -> System.out.println(integer)); }
Supplier
定义
@FunctionalInterface public interface Supplier<T>{ Tget(); }
函数描述符: () -> T
实例
private <T> Tsupply(Supplier<T> supplier){ return supplier.get(); } @Test public void supplierTest(){ assertEquals(LocalDate.now(), supply(() -> LocalDate.now())); }
Function
定义
@FunctionalInterface public interface Function<T,R>{ Rapply(T t); }
函数描述符: T -> R
实例
private <T, R> Rfunction(T t, Function<T, R> func){ return func.apply(t); } @Test public void functionTest(){ assertEquals(Integer.valueOf(12), function(Integer.valueOf(4), integer -> integer * 3)); }
BiFunction
定义
@FunctionalInterface public interface BiFunction<T,U,R>{ Rapply(T t, U u); }
函数描述符: (T,U) -> R
实例
private <T, U, R> RbiFunction(T t, U u, BiFunction<T, U, R> biFunc){ return biFunc.apply(t, u); } @Test public void biFunctionTest(){ assertEquals("40", biFunction(4, "0", (integer, s) -> integer + s)); }
BiPredicate
定义
@FunctionalInterface public interface BiPredicate<T,U>{ boolean test(T t, U u); }
函数描述符: (T,U) -> boolean
实例
private <T, U> boolean biPredicate(T t, U u, BiPredicate<T, U> biPred){ return biPred.test(t, u); } @Test public void biPredicateTest(){ assertTrue(biPredicate(4, "zhognmingmao", (integer, s) -> null != s && s.length() > integer)); }
BinaryOperator
定义
@FunctionalInterface public interface BinaryOperator<T>extends BiFunction<T,T,T>{ }
函数描述符: (T,T) -> T
实例
private <T> TbinaryOperator(T t, BinaryOperator<T> bOp){ return bOp.apply(t, t); } @Test public void binaryOperatorTest(){ assertEquals(Integer.valueOf(16), binaryOperator(4, (integer, integer2) -> integer * integer2)); }
BiConsumer
定义
@FunctionalInterface public interface BiConsumer<T,U>{ void accept(T t, U u); }
函数描述符: (T,U) -> void
实例
private <T, U> void biConsumer(T t, U u, BiConsumer<T, U> bCon){ bCon.accept(t, u); } @Test public void biConsumerTest(){ biConsumer(4, "zhongmingmao", (integer, s) -> System.out.println(integer + s.length())); }
UnaryOperator
定义
@FunctionalInterface public interface UnaryOperator<T>extends Function<T,T>{ }
函数描述符: T -> T
实例
private <T> TunaryOperator(T t, UnaryOperator<T> uOp){ return uOp.apply(t); } @Test public void unaryOperatorTest(){ assertEquals("zhongmingmao" , unaryOperator("zhongming" , s -> s + "mao")); }
IntPredicate
-
IntPredicate
是Predicate<Integer>
的原始类型特化
,节省了自动装箱
和自动拆箱
的开销 -
类似函数式接口的还有
LongPredicate
、IntFunction<R>
等
定义
@FunctionalInterface public interface IntPredicate{ boolean test(intvalue); }
实例
@Test public void intPredicateTest(){ IntPredicate intPredicate = value -> value % 2 == 0; Predicate<Integer> integerPredicate = integer -> integer % 2 == 0; int max = 1 << 30; long p1 = System.currentTimeMillis(); for (int i = 0; i < max; i++) { intPredicate.test(i); } long p2 = System.currentTimeMillis(); for (int i = 0; i < max; i++) { integerPredicate.test(i); } long p3 = System.currentTimeMillis(); System.out.println((p3 - p2) / (p2 - p1 + 0.0)); // 本地结果在100~220之间 assertTrue((p3 - p2) > (p2 - p1)); }
类型检查
引用上面的例子进行分析
// 函数定义 private <T> List<T>predicate(List<T> list, Predicate<T> predicate){...} // 函数调用 predicate(Arrays.asList("zhongmingmao", "", null), s -> null == s || s.isEmpty()).size());
-
函数定义中形参为
Predicate<T> predicate
-
Predicate<T>
中的抽象函数的签名为boolean test(T t)
,因此Predicate<T>
的函数描述符
为T -> boolean
-
函数调用中
Lambda
的签名
为String -> boolean
与Predicate<T>
的函数描述符
匹配,类型检查通过
方法引用
方法引用
是 Lambda
的一种 快捷写法
(
语法糖
)
静态方法
-
Lambda:
(args) -> ClassName.staticMethod(args)
-
方法引用:
ClassName::staticMethod
Function<String, Integer> str2Integer = s -> Integer.parseInt(s); str2Integer = Integer::parseInt;
任意类型的实例方法
-
Lambda:
(arg0,rest) -> arg0.instanceMethod(rest)
(arg0
是ClassName
类型) -
方法引用:
ClassName::instanceMethod
BiPredicate<List<String>, String> contains = (strings, s) -> strings.contains(s); contains = List::contains;
现有对象的实例方法
-
Lambda:
(args) -> expr.instanceMethod(args)
-
方法引用:
expr::instanceMethod
List<String> list = Arrays.asList("a", "b", "A", "B"); Predicate<String> contain = s -> list.contains(s); contain = list::contains;
构造函数
Supplier<Apple> c1 = () -> new Apple(); c1 = Apple::new;// 默认构造函数 Apple apple = c1.get(); BiFunction<Apple.COLOR, Integer, Apple> c2 = (color, integer) -> new Apple(color, integer); c2 = Apple::new;// 2个参数构造函数 apple = c2.apply(Apple.COLOR.GREEN, Integer.valueOf(200));
复合Lambda
Comparator复合
@FunctionalInterface public interface Comparator<T>{ int compare(T o1, T o2); } // <T, U extends Comparable<? super U>> Comparator<T> comparing( // Function<? super T, ? extends U> keyExtractor) Comparator<Apple> comparator = Comparator.comparing(Apple::getWeight); // Apple -> Integer Comparator<Apple> reversedComparetor = comparator.reversed(); Comparator<Apple> linkedComparator = Comparator.comparing(Apple::getWeight).reversed() .thenComparing(Apple::getColor).reversed();
Predicate复合
Predicate<Apple> greenApple = apple -> Apple.COLOR.GREEN.equals(apple.getColor()); Predicate<Apple> notGreenApple = greenApple.negate(); Predicate<Apple> heavyApple = apple -> apple.getWeight() > Apple.HEAVY_WEIGHT; Predicate<Apple> greenAndHeavyApple = greenApple.and(heavyApple); Predicate<Apple> redApple = apple -> Apple.COLOR.RED.equals(apple.getColor()); Predicate<Apple> greenAndHeavyOrRedApple = greenAndHeavyApple.or(redApple); // 优先级从左至右,(red or green) and heavy Predicate<Apple> redOrGreenAndHeavyApple = redApple.or(greenApple).and(heavyApple);
以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持 码农网
猜你喜欢:- 低成本“全栈”回忆录
- 一个 Java 对象的回忆录:垃圾回收
- 我的本科回忆录:从迷茫自卑到保送华科
- CSS :visited伪类选择器隐秘往事回忆录
- HBase 抗战总结:阿里巴巴 HBase 高可用 8 年抗战回忆录
本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们。
Google将带来什么?
杰夫·贾维斯 / 陈庆新、赵艳峰、胡延平 / 中华工商联合出版社 / 2009-8 / 39.00元
《Google将带来什么?》是一本大胆探索、至关重要的书籍,追寻当今世界最紧迫问题的答案:Google将带来什么?在兼具预言、宣言、思想探险和生存手册性质的这样一《Google将带来什么?》里,互联网监督和博客先锋杰夫·贾维斯对Google这个历史上发展速度最快的公司进行了逆向工程研究,发现了40种直截了当、清晰易懂的管理与生存原则。与此同时,他还向我们阐明了互联网一代的新世界观:尽管它具有挑战性......一起来看看 《Google将带来什么?》 这本书的介绍吧!