Java 8里面lambda的最佳实践

开发 后端 开发工具
聊聊Lambda的应用场景,性能,也会提及下不好的一面。

Java 8已经推出一段时间了,越来越多开发人员选择升级JDK,这条热门动弹里面看出,JDK7最多,其次是6和8,这是好事!

在8 里面Lambda是最火的主题,不仅仅是因为语法的改变,更重要的是带来了函数式编程的思想,我觉得优秀的程序员,有必要学习一下函数式编程的思想以开阔思路。所以这篇文章聊聊Lambda的应用场景,性能,也会提及下不好的一面。
Java为何需要Lambda

1996年1月,Java 1.0发布了,此后计算机编程领域发生了翻天覆地的变化。商业发展需要更复杂的应用,大多数程序都跑在更强大的装备多核CPU的机器上。带有高效运行期编 译器的Java虚拟机(JVM)的出现,使得程序员将精力更多放在编写干净、易于维护的代码上,而不是思考如何将每一个CPU时钟、每一字节内存物尽其 用。

多核CPU的出现成了“房间里的大象”,无法忽视却没人愿意正视。算法中引入锁不但容易出错,而且消耗时间。人们开发了 java.util.concurrent包和很多第三方类库,试图将并发抽象化,用以帮助程序员写出在多核CPU上运行良好的程序。不幸的是,到目前为 止,我们走得还不够远。

那些类库的开发者使用Java时,发现抽象的级别还不够。处理大数据就是个很好的例子,面对大数据,Java还欠缺高效的并行操作。Java 8允许开发者编写复杂的集合处理算法,只需要简单修改一个方法,就能让代码在多核CPU上高效运行。为了编写并行处理这些大数据的类库,需要在语言层面上 修改现有的Java:增加lambda表达式。

当然,这样做是有代价的,程序员必须学习如何编写和阅读包含lambda表达式的代码,但是,这不是一桩赔本的买卖。与手写一大段复杂的、线程安全 的代码相比,学习一点新语法和一些新习惯容易很多。开发企业级应用时,好的类库和框架极大地降低了开发时间和成本,也扫清了开发易用且高效的类库的障碍。

如果你还未接触过Lambda的语法,可以看这里。
Lambda的应用场景

你有必要学习下函数式编程的概念,比如函数式编程初探,但下面我将重点放在函数式编程的实用性上,包括那些可以被大多数程序员理解和使用的技术,我们关心的如何写出好代码,而不是符合函数编程风格的代码。

1.使用() -> {} 替代匿名类

现在Runnable线程,Swing,JavaFX的事件监听器代码等,在java 8中你可以使用Lambda表达式替代丑陋的匿名类。

  1. //Before Java 8: 
  2. new Thread(new Runnable() { 
  3. @Override 
  4. public void run() { 
  5. System.out.println("Before Java8 "); 
  6. }).start(); 
  7.  
  8. //Java 8 way: 
  9. new Thread(() -> System.out.println("In Java8!")); 
  10.  
  11. // Before Java 8: 
  12. JButton show = new JButton("Show"); 
  13. show.addActionListener(new ActionListener() { 
  14. @Override 
  15. public void actionPerformed(ActionEvent e) { 
  16. System.out.println("without lambda expression is boring"); 
  17. }); 
  18.  
  19.  
  20. // Java 8 way: 
  21. show.addActionListener((e) -> { 
  22. System.out.println("Action !! Lambda expressions Rocks"); 
  23. }); 


2.使用内循环替代外循环

外循环:描述怎么干,代码里嵌套2个以上的for循环的都比较难读懂;只能顺序处理List中的元素;

内循环:描述要干什么,而不是怎么干;不一定需要顺序处理List中的元素

  1. //Prior Java 8 : 
  2. List features = Arrays.asList("Lambdas""Default Method"
  3. "Stream API""Date and Time API"); 
  4. for (String feature : features) { 
  5. System.out.println(feature); 
  6.  
  7. //In Java 8: 
  8. List features = Arrays.asList("Lambdas""Default Method""Stream API"
  9. "Date and Time API"); 
  10. features.forEach(n -> System.out.println(n)); 
  11.  
  12. // Even better use Method reference feature of Java 8 
  13. // method reference is denoted by :: (double colon) operator 
  14. // looks similar to score resolution operator of C++ 
  15. features.forEach(System.out::println); 
  16.  
  17. Output: 
  18. Lambdas 
  19. Default Method 
  20. Stream API 
  21. Date and Time API 


3.支持函数编程

为了支持函数编程,Java 8加入了一个新的包java.util.function,其中有一个接口java.util.function.Predicate是支持Lambda函数编程:

  1. public static void main(args[]){ 
  2. List languages = Arrays.asList("Java""Scala""C++""Haskell""Lisp"); 
  3.  
  4. System.out.println("Languages which starts with J :"); 
  5. filter(languages, (str)->str.startsWith("J")); 
  6.  
  7. System.out.println("Languages which ends with a "); 
  8. filter(languages, (str)->str.endsWith("a")); 
  9.  
  10. System.out.println("Print all languages :"); 
  11. filter(languages, (str)->true); 
  12.  
  13. System.out.println("Print no language : "); 
  14. filter(languages, (str)->false); 
  15.  
  16. System.out.println("Print language whose length greater than 4:"); 
  17. filter(languages, (str)->str.length() > 4); 
  18.  
  19. public static void filter(List names, Predicate condition) { 
  20. names.stream().filter((name) -> (condition.test(name))) 
  21. .forEach((name) -> {System.out.println(name + " "); 
  22. }); 
  23.  
  24. Output: 
  25. Languages which starts with J : 
  26. Java 
  27. Languages which ends with a 
  28. Java 
  29. Scala 
  30. Print all languages : 
  31. Java 
  32. Scala 
  33. C++ 
  34. Haskell 
  35. Lisp 
  36. Print no language : 
  37. Print language whose length greater than 4
  38. Scala 
  39. Haskell 


4.处理数据?用管道的方式更加简洁

Java 8里面新增的Stream API ,让集合中的数据处理起来更加方便,性能更高,可读性更好

假设一个业务场景:对于20元以上的商品,进行9折处理,最后得到这些商品的折后价格。

  1. final BigDecimal totalOfDiscountedPrices = prices.stream() 
  2. .filter(price -> price.compareTo(BigDecimal.valueOf(20)) > 0
  3. .map(price -> price.multiply(BigDecimal.valueOf(0.9))) 
  4. .reduce(BigDecimal.ZERO,BigDecimal::add); 
  5.  
  6. System.out.println("Total of discounted prices: " + totalOfDiscountedPrices); 

想象一下:如果用面向对象处理这些数据,需要多少行?多少次循环?需要声明多少个中间变量?

关于Stream API的详细信息,可以查看我之前写的文章 。

#p#

Lambda的性能

Java 8里面lambda的最佳实践

Oracle公司的性能工程师Sergey Kuksenko有一篇很好的性能比较的文档: JDK 8: Lambda Performance study, 详细而全面的比较了lambda表达式和匿名函数之间的性能差别。这里是视频。 16页讲到最差(capture)也和inner class一样, non-capture好的情况是inner class的5倍。

lambda开发组也有一篇ppt, 其中也讲到了lambda的性能(包括capture和非capture的情况)。看起来lambda最差的情况性能内部类一样, 好的情况会更好。

Java 8 Lambdas - they are fast, very fast也有篇文章 (需要翻墙),表明lambda表达式也一样快。

Lambda的阴暗面

前面都是讲Lambda如何改变Java程序员的思维习惯,但Lambda确实也带来了困惑

JVM可以执行任何语言编写的代码,只要它们能编译成字节码,字节码自身是充分OO的,被设计成接近于Java语言,这意味着Java被编译成的字节码非常容易被重新组装。

但是如果不是Java语言,差距将越来越大,Scala源码和被编译成的字节码之间巨大差距是一个证明,编译器加入了大量合成类 方法和变量,以便让JVM按照语言自身特定语法和流程控制执行。

我们首先看看Java 6/7中的一个传统方法案例:

  1. // simple check against empty strings 
  2. public static int check(String s) { 
  3. if (s.equals("")) { 
  4. throw new IllegalArgumentException(); 
  5. return s.length(); 
  6.  
  7. //map names to lengths 
  8.  
  9. List lengths = new ArrayList(); 
  10.  
  11. for (String name : Arrays.asList(args)) { 
  12. lengths.add(check(name)); 
  13.  
  14. 如果一个空的字符串传入,这段代码将抛出错误,堆栈跟踪如下: 
  15. 1 
  16. 2 
  17.  
  18. at LmbdaMain.check(LmbdaMain.java:19
  19. at LmbdaMain.main(LmbdaMain.java:34

再看看Lambda的例子

  1. Stream lengths = names.stream().map(name -> check(name)); 
  2.  
  3. at LmbdaMain.check(LmbdaMain.java:19
  4. at LmbdaMain.lambda$0(LmbdaMain.java:37
  5. at LmbdaMain$$Lambda$1/821270929.apply(Unknown Source) 
  6. at java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:193
  7. at java.util.Spliterators$ArraySpliterator.forEachRemaining(Spliterators.java:948
  8. at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:512
  9. at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:502
  10. at java.util.stream.ReduceOps$ReduceOp.evaluateSequential(ReduceOps.java:708
  11. at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234
  12. at java.util.stream.LongPipeline.reduce(LongPipeline.java:438
  13. at java.util.stream.LongPipeline.sum(LongPipeline.java:396
  14. at java.util.stream.ReferencePipeline.count(ReferencePipeline.java:526
  15. at LmbdaMain.main(LmbdaMain.java:39


这非常类似Scala,出错栈信息太长,我们为代码的精简付出力代价,更精确的代码意味着更复杂的调试。

但这并不影响我们喜欢Lambda!

总结

在Java世界里面,面向对象还是主流思想,对于习惯了面向对象编程的开发者来说,抽象的概念并不陌生。面向对象编程是对数据进行抽象,而函数式编程是对行为进行抽象。现实世界中,数据和行为并存,程序也是如此,因此这两种编程方式我们都得学。

这种新的抽象方式还有其他好处。很多人不总是在编写性能优先的代码,对于这些人来说,函数式编程带来的好处尤为明显。程序员能编写出更容易阅读的代码——这种代码更多地表达了业务逻辑,而不是从机制上如何实现。易读的代码也易于维护、更可靠、更不容易出错。

在写回调函数和事件处理器时,程序员不必再纠缠于匿名内部类的冗繁和可读性,函数式编程让事件处理系统变得更加简单。能将函数方便地传递也让编写惰性代码变得容易,只有在真正需要的时候,才初始化变量的值。

总而言之,Java更趋于完美了。

责任编辑:王雪燕 来源: 开源中国社区
相关推荐

2018-05-02 13:59:01

大数据数据收集数据科学

2016-12-13 10:13:18

PHPUTF-8实践

2015-09-23 09:08:38

java反射

2012-06-26 10:03:58

JavaJava 8lambda

2009-07-29 17:52:29

ibmdwJava

2019-05-07 09:00:40

无服务器Lambda管理

2018-02-06 09:05:25

Java异常处理代码

2018-01-12 14:37:34

Java代码实践

2018-05-10 15:06:43

Java Web分层实践

2023-09-13 08:00:00

JavaScript循环语句

2016-09-23 20:20:10

2016-12-27 08:49:55

API设计策略

2015-09-15 16:01:40

混合IT私有云IT架构

2011-08-18 11:05:21

jQuery

2023-07-21 01:12:30

Reactfalse​变量

2013-04-01 09:39:06

JavaJava异常

2015-06-24 10:07:34

Java编码最佳实践

2013-10-17 09:36:34

2024-03-12 08:23:54

JavaLambda函数式编程

2012-02-17 16:41:38

云计算SaaS
点赞
收藏

51CTO技术栈公众号