+ Q7 r' S& i7 B8 F0 m% k# `4 \我总觉得这行代码不如换成老式的语法(Java 7 之前)来写,就像下面这样: 0 u' p. \6 h) ?% l/ e 0 J* o% m* B kfor (int i = 1; i < 5; i++) { 2 p6 [$ Y3 X' F; W4 B% _ System.out.println("Happy Birthday " + (i == 3 ? "dear NAME" : "to you"));& T9 |6 @: {# c
} 6 W8 p, Z5 o4 ~1 u1 F7 j/ G15 P! Z% D' R0 J) N2 r0 n' b
2* v) y/ V1 V2 B
3 ' [/ W2 m% _0 T+ z, ^! m哇,beautiful code,简洁又明了!不仅我能看得懂,就连刚入门的 Java 小白都能看得懂。要知道,代码是写给人看的,假如只有自己看得懂,只有自己觉得很 6,而其他人看起来云里雾里的,就不一定是好代码,尽管好像是行走在技术的前沿。' n# ~4 S# |& Q% F: Q9 E
1 H' A5 Q5 b! i5 `, M% \俗话说得好,“能力越大,责任越大”。Java 8 为我们提供了强大的能力,它的新特性是划时代的(Java 8 之后的版本中新特性都不够亮眼),包括 Lambda 表达式和 Stream 流,我们通过它们可以写出简洁又高效的代码。打个不恰当的比喻,Java 8 之前,开发者驾驶的是桑塔纳,Java 8 之后,开发者驾驶的是法拉利。4 j' H9 M; r" Q* _2 T- L
" ?) e& ~; k& x* Y# A, h6 m
) l, b; | b2 m
2 B( W# b" L, Y3 L( ~
但如果驾驶技术不好的话,法拉利也能变成桑塔纳,甚至还不如。拿之前那段看起来似乎很 6 的代码来说吧,它并不是一段好的代码——尽管使用了新颖的技术,但难以理解。- i. M# ^* k. K0 r$ S9 x9 u
! S9 F% P1 }- Z8 S& v) o+ O6 J在 Java 8 之前,如果你想编写函数式代码的话,应该会使用 Google 的 Guava 类库,它是一个很棒的开源类库(不陌生吧),可以在一定程度上弥补 Java 原生类库的不足。我在它的 wiki 上看到下面这样一条建议,说得很富有远见: 6 t9 M+ K |- B. e- G. T/ w$ o7 K$ w2 b7 o
Excessive use of Guava’s functional programming idioms can lead to verbose, confusing, unreadable and inefficient code. … when you go to preposterous lengths to make your code “a one-line”, the Guava team weeps.9 O5 J! g* V0 ~3 p5 P
应该能看得懂吧?大致的意思就是说,如果过度使用 Guava 的函数式编程的话,会导致代码冗长、混乱、不可读,甚至低效;如果有些开发者为了减少代码的长度,刻意把多行代码“优化”成一行代码时,Guava 甚至会被玩哭。! q- b% s4 p; |2 a$ m* o
% e+ n! J2 d' ^9 C
我只能说,优秀的人真可怕,他不仅知道自己的长处,更了解自己的不足——说的就是你,Guava 的开发者。至于开头提到的那位大牛,他写的代码我就不敢恭维,只能说炫技炫到盲目自信吧。根据我的经验,只有很少一部分的大牛能够保持理智,在追求技术创新的同时意识到炫技的问题。 * h( u: P% `, s x- |) [" _2 w1 ~ 1 G, b- \; N" P5 Q, H A我认为,Guava wiki 上的建议同样适用于 Java 8,好技术要妥善的利用,而不是滥用。众所周知,Java 8 的新特性可以用来减少冗余代码,当我们把一个复杂的匿名内部类变成一个简洁的 Lambda 表达式就是一个很好的例子。( N, H# }4 {! X6 ~" Y! _) W* e
" Z) @: q5 ^3 f' TThread t1 = new Thread(new Runnable() {) G& t3 ~5 B$ U2 s
@Override4 f7 ^8 d% ?& B1 ]) ~
public void run() {( |' ~9 Z l5 B5 _
System.out.println("匿名内部类,搞起来"); ' a9 Z3 x+ M, {8 @% q% I; k } ; z3 C, B+ @; o# y8 c. _});) \- m& I, U% C* W) `
t1.start(); 2 q3 }0 G' F+ t% E8 b 4 C% A8 Z" V" ]9 J- W// 优化后! b8 r) f* r6 W# x
7 R( e, l( V3 \" n. T
Thread t2 = new Thread(() -> {5 @( @$ V8 t* ?4 m, b6 |( i) I6 b5 x
System.out.println("Lambda 表达式,搞起来"); 7 ?# o P8 D! Z0 M- A, i}); ( B3 B8 T: O* C7 F% gt2.start(); : D' J. o' Z3 A( o1 ' ^ L6 A2 Q6 u, P' m2 2 F( C9 g$ u, M+ ^& {2 Y3" x$ U; P% p2 p+ R* \# X: P
4 ' m" F, z g/ v0 A5 [* q5# r# R* H# h7 J: _
6! H/ b) Y/ _+ c" [9 f, ]
70 R( Z/ U4 h, X* \! Q
8 % g5 f6 Y D- S2 q5 B9" E% N* ~& U) j) n
10- E- g5 s' U5 _) r ]
11' q' X0 K9 {" o% W) _# h
12 . T1 u5 Q/ J2 E7 }1 I139 _' r* z @, c- g
14 / `- s/ H; d. P+ X: S你看,优化后的代码量更少,并且一目了然,任谁也不会搞到看不懂的地步。函数式编程出现的目的可不仅仅是为了减少冗余代码,它是为了解放生产力——言外之意就是说,代码复杂点没关系,只要可用可靠。编程的目标不是产生尽可能少的代码,而是产生易于维护的、高性能的系统。3 i, |. _- J, o {7 A$ L. W1 N