为什么要使用lambda表达式？原来如此，涨知识了

　　为什么要使用Lambda表达式
　　先看几段Java8以前经常会遇到的代码：
　　创建线程并启动创建线程publicclassWorkerimplementsRunnable｛Overridepublicvoidrun（）｛for（inti0；i100；i）｛doWork（）；｝｝｝启动线程WorkerwnewWorker（）；newThread（w）。start（）；
　　比较数组定义一个比较器publicclassLengthComparatorimplementsComparatorString｛Overridepublicintcompare（Stringfirst，Stringsecond）｛returnInteger。compare（first。length（），second。length（））；｝｝对字符数组进行比较Arrays。sort（words，newLengthComparator（））；
　　给按钮添加单击事件publicvoidonClick（Buttonbutton）｛button。addActionListener（newActionListener（）｛OverridepublicvoidactionPerformed（ActionEvente）｛System。out。println（buttonclicked。）；｝｝）；｝
　　对于这三段代码，我们已经司空见惯了。
　　但他们的问题也很突出：就是噪声太多！想实现一个数组的比较功能，至少要写5行代码，但其中只有一行代码才是我们真正关注的！
　　Java复杂冗余的代码实现一直被程序员所诟病，好在随着JVM平台语言Scala的兴起以及函数式编程风格的风靡，让Oracle在Java的第8个系列版本中进行了革命性的变化，推出了一系列函数式编程风格的语法特性，比如Lambda表达式以及Stream。
　　如果采用Lambda表达式，上面三段代码的实现将会变得极为简洁。
　　创建线程并启动（采用Lambda版本）newThread（（）｛for（inti0；i100；i）｛doWork（）；｝｝）。start（）；
　　比较数组（采用Lambda版本）Arrays。sort（words，（first，second）Integer。compare（first。length（），second。length（））
　　给按钮添加单击事件（采用Lambda版本）button。addActionListener（（event）System。out。println（buttonclicked。））；
　　怎么样？通过Lambda表达式，代码已经变得足够简洁，让你把关注点全部都放在业务代码上。Lambda表达式的语法
　　格式：（参数）表达式
　　其中：参数可以为0n个。如果有多个参数，以逗号（，）分割。如果有一个参数，括号（）可以省去；如果没有参数，括号（）也不能省去。〔这就有点不够纯粹了，比scala还是差了点！〕，参数前可以加类型名，但由于自动类型推导功能，可以省去。表达式可以是一行表达式，也可以是多条语句。如果是多条语句，需要包裹在大括号｛｝中。表达式不需要显示执行返回结果，它会从上下文中自动推导。以下是一些例子：
　　一个参数eventSystem。out。println（buttonclicked。）
　　多个参数（first，second）Integer。compare（first。length（），second。length（）复制代码
　　0个参数（）System。out。println（whatareyounongshalei？）
　　表达式块（）｛for（inti0；i100；i）｛doWork（）；｝｝函数式接口
　　在Java8中新增加了一个注解：〔FunctionalInterface〕，函数式接口。
　　什么是函数式接口呢？它包含了以下特征：接口中仅有一个抽象方法，但允许存在默认方法和静态方法。〔FunctionalInterface〕注解不是必须的，但建议最好加上，这样可以通过编译器来检查接口中是否仅存在一个抽象方法。
　　Lambda表达式的本质就是函数式接口的匿名实现。只是把原有的接口实现方式用一种更像函数式编程的语法表示出来。
　　Java8的java。util。function包已经内置了大量的函数式接口，如下所示：
　　函数式接口
　　参数类型
　　返回类型
　　方法名
　　描述
　　Supplier
　　无
　　T
　　get
　　产生一个类型为T的数据
　　Consumer
　　T
　　void
　　accept
　　消费一个类型为T的数据
　　BiConsumerT，U
　　T，U
　　void
　　accept
　　消费类型为T和类型为U的数据
　　FunctionT，R
　　T
　　R
　　apply
　　把参数类型为T的数据经过函数处理转换成类型为R的数据
　　BiFunctionT，U，R
　　T，U
　　R
　　apply
　　把参数类型为T和U的数据经过函数处理转换成类型为R的数据
　　UnaryOperator
　　T
　　T
　　apply
　　对类型T进行了一元操作，仍返回类型T
　　BinaryOperator
　　T，T
　　T
　　apply
　　对类型T进行了二元操作，仍返回类型T
　　Predicate
　　T
　　void
　　test
　　对类型T进行函数处理，返回布尔值
　　BiPredicateT，U
　　T，U
　　void
　　test
　　对类型T和U进行函数处理，返回布尔值
　　从中可以看出：内置的函数式接口主要分四类：Supplier，Consumer，Function，Predicate。Operator是Function的一种特例。除了Supplier没有提供二元参数以外（这和java不支持多个返回值有关），其他三类都提供了二元入参。
　　以下是一个综合的例子：publicclassFunctionalCase｛publicstaticvoidmain（String〔〕args）｛StringwordsHello，World；StringlowerWordschangeWords（words，String：：toLowerCase）；System。out。println（lowerWords）；StringupperWordschangeWords（words，String：：toUpperCase）；System。out。println（upperWords）；intcountwordsToInt（words，String：：length）；System。out。println（count）；isSatisfy（words，ww。contains（hello））；StringotherWordsappendWords（words，（）｛ListStringallWordsArrays。asList（abc，efg）；returnallWords。get（newRandom（）。nextInt（2））；｝）；System。out。println（otherWords）；consumeWords（words，wSystem。out。println（w。split（，）〔0〕））；｝publicstaticStringchangeWords（Stringwords，UnaryOperatorStringfunc）｛returnfunc。apply（words）；｝publicstaticintwordsToInt（Stringwords，FunctionString，Integerfunc）｛returnfunc。apply（words）；｝publicstaticvoidisSatisfy（Stringwords，PredicateStringfunc）｛if（func。test（words））｛System。out。println（testpass）；｝else｛System。out。println（testfailed。）；｝｝publicstaticStringappendWords（Stringwords，SupplierStringfunc）｛returnwordsfunc。get（）；｝publicstaticvoidconsumeWords（Stringwords，ConsumerStringfunc）｛func。accept（words）；｝｝
　　如果觉得这些内置函数式接口还不够用的话，还可以自定义自己的函数式接口，以满足更多的需求。方法引用
　　如果Lambda表达式已经有实现的方法了，则可以用方法引用进行简化。方法引用的语法如下：对象：：实例方法类：：静态方法类：：实例方法
　　这样前面提到的Lambda表达式：eventSystem。out。println（event）
　　则可以替换为：System。out：：println
　　另一个例子：（x，y）x。compareToIgnoreCase（y）
　　可以替换为：String：：compareToIgnoreCase
　　注意：方法名后面是不能带参数的！可以写成System。out：：println，但不能写成System。out：：println（hello）
　　如果能获取到本实例的this参数，则可以直接用this：：实例方法进行访问，对于父类指定方法，用super：：实例方法进行访问。
　　下面是一个例子：publicclassGreeter｛publicvoidgreet（）｛StringlowcaseStrchangeWords（Hello，World，this：：lowercase）；System。out。println（lowcaseStr）；｝publicStringlowercase（Stringword）｛returnword。toLowerCase（）；｝publicStringchangeWords（Stringwords，UnaryOperatorStringfunc）｛returnfunc。apply（words）；｝｝classConcurrentGreeterextendsGreeter｛publicvoidgreet（）｛ThreadthreadnewThread（super：：greet）；thread。start（）；｝publicstaticvoidmain（String〔〕args）｛newConcurrentGreeter（）。greet（）；｝｝构造器引用
　　构造器引用和方法引用类似，只不过函数接口返回实例对象或者数组。构造器引用的语法如下：类：：new数组：：new
　　举个例子：ListStringlabelsArrays。asList（button1，button2）；StreamButtonstreamlabels。stream（）。map（Button：：new）；ListButtonbuttonsstream。collect（Collectors。toList（））；
　　其中的labels。stream（）。map（Button：：new）相当于labels。stream（）。map（labelnewButton（label））
　　再看个数组类型的构造器引用的例子：Button〔〕buttonsstream。toArray（Button〔〕：：new）；
　　把Stream直接转成了数组类型，这里用Button〔〕：：new来标示数组类型。变量作用域
　　先看一段代码：publicvoidrepeatMsg（Stringtext，intcount）｛Runnabler（）｛for（inti0；icount；i）｛System。out。println（text）；Thread。yield（）；｝｝；｝
　　一个lambda表达式一般由以下三部分组成：参数表达式自由变量
　　参数和表达式好理解。那自由变量是什么呢？它就是在lambda表达式中引用的外部变量，比如上例中的text和count变量。
　　如果熟悉函数式编程的同学会发现，Lambda表达式其实就是闭包（closure）。只是Java8并未叫这个名字。对于自由变量，如果Lambda表达式需要引用，是不允许发生修改的。
　　其实在Java的匿名内部类中，如果要引用外部变量，变量是需要声明为final的，虽然Lambda表达式的自由变量不用强制声明成final，但同样也是不允许修改的。
　　比如下面的代码：publicvoidrepeatMsg（Stringtext，intcount）｛Runnabler（）｛while（count0）｛count；错误，不能修改外部变量的值System。out。println（text）；｝｝；｝
　　另外，Lambda表达式中不允许声明一个和局部变量同名的参数或者局部变量。比如下面的代码：PathfirstPaths。get（usrbin）；ComparatorStringcomp（first，second）Integer。compare（first。length（），second。length（））；错误，变量first已经被定义接口中的默认方法
　　先说说为什么要在Java8接口中新增默认方法吧。
　　比如Collection接口的设计人员针对集合的遍历新增加了一个forEach（）方法，用它可以更简洁的遍历集合。比如：list。forEach（System。out：：println（））；
　　但如果在接口中新增方法，按照传统的方法，Collection接口的自定义实现类都要实现forEach（）方法，这对广大已有实现来说是无法接受的。
　　于是Java8的设计人员就想出了这个办法：在接口中新增加一个方法类型，叫默认方法，可以提供默认的方法实现，这样实现类如果不实现方法的话，可以默认使用默认方法中的实现。
　　一个使用例子：publicinterfacePerson｛longgetId（）；defaultStringgetName（）｛returnjack；｝｝
　　默认方法的加入，可以替代之前经典的接口和抽象类的设计方式，统一把抽象方法和默认实现都放在一个接口中定义。这估计也是从Scala的Trait偷师来的技能吧。接口中的静态方法
　　除了默认方法，Java8还支持在接口中定义静态方法以及实现。
　　比如Java8之前，对于Path接口，一般都会定义一个Paths的工具类，通过静态方法实现接口的辅助方法。
　　接口中有了静态方法就好办了，统一在一个接口中搞定！虽然这看上去破坏了接口原有的设计思想。publicinterfacePath｛publicstaticPathget（Stringfirst，String。。。more）｛returnFileSystem。getDefault（）。getPath（first，more）；｝｝
　　这样Paths类就没什么意义了小结
　　使用Lambda表达式后可以大幅减少冗余的模板式代码，使把更多注意力放在业务逻辑上，而不是复制一堆重复代码，除非你在一个用代码行数来衡量工作量的公司，你觉得呢？