El uso de Lambda en las colecciones
recorriendo la lista
Cuando se trata de recorrer una colección, me temo que el siguiente método ya es una mentalidad:
final List < String > friends = Arrays . asList ( "Brian" , "Nate" , "Neal" , "Raju" , "Sara" , "Scott" );
for ( int i = 0 ; i < friends . size (); i ++) {
System . out . println ( friends . get ( i ));
}
复制代码Pero piénselo, el código anterior parece tener demasiados detalles, como la aparición de la variable de bucle i. Cuando se realizan operaciones transversales simples, las variables de bucle son realmente innecesarias y su uso solo tiene sentido cuando se realiza alguna operación especial en un elemento en una posición específica. Entonces, se introdujo un bucle for mejorado en Java, en el que las variables de bucle son innecesarias:
for ( String name : friends ) {
System . out . println ( name );
}
复制代码De esta forma, la interfaz del iterador y sus métodos hasNext(), next() se utilizan para los detalles de implementación.
No importa qué ciclo for se use, todavía usan el iterador externo. Es decir, en un bucle for, siempre tiene una forma de controlar el proceso de recorrido por medios como romper, continuar, etc.
El opuesto del iterador externo es el iterador interno. En Java 8, la interfaz Iterable se mejoró y ahora tiene un método forEach que implementa el iterador interno. El método forEach acepta como parámetro un tipo de interfaz Consumer, que es una interfaz funcional (Functional Interface), que es la implementación del atravesador interno. Para interfaces funcionales, consulte el artículo anterior.
friends . forEach ( new Consumer < String >() {
public void accept ( final String name ) {
System . out . println ( name );
}
});
复制代码Obviamente, la clase anónima utilizada en el código anterior no es la mejor solución en Java 8 y las expresiones Lambda son una mejor opción en este escenario:
friends . forEach (( final String name ) -> System . out . println ( name ));
复制代码El método forEach en sí mismo es una función de orden superior porque acepta una expresión lambda como su parámetro, y una expresión lambda es esencialmente una función. En el lado izquierdo de la expresión lambda, se declara un nombre de variable de tipo String, que representa los elementos de la colección. El código a la derecha de la flecha expresa qué acción se debe realizar en el elemento. La razón por la que cada uno se llama transversal interno es que una vez que comienza a ejecutarse, la operación transversal no se puede interrumpir fácilmente.
Al mismo tiempo, con la ayuda de la función de inferencia de tipos del compilador de Java, las expresiones Lambda se pueden simplificar aún más de la siguiente manera:
friends . forEach (( name ) -> System . out . println ( name ));
复制代码En este punto, el compilador puede saber que el tipo de la variable de nombre es String a través del contexto de tiempo de ejecución.
另外，当Lambda表达式左端只接受一个变量的时候，括号也是可以省略的：
friends . forEach ( name -> System . out . println ( name ));
复制代码但是用类型推导有一个不好的地方，就是参数不会自动被final修饰。因此，在Lambda表达式右端，是可以对参数进行修改的，然而这种行为是不被倡导的。
上面的代码已经足够简洁了，但是还有更简洁的方法，那就是使用方法引用：
friends . forEach ( System . out :: println );
复制代码使用这种方式甚至不需要写出Lambda表达式的左端参数部分。关于方法引用的详细情况，会在以后进行介绍。
与使用外部遍历不同，使用内部遍历的好处在于：
- 放弃使用显式的for循环，因其与生俱来的顺序执行的特性会阻碍并行化。换言之，使用内部遍历时，程序的并行程度能够很容易地被提高。
- 声明式的代码比命令式的代码更简洁，更具有可读性，更优雅。
列表的变换
将一个集合通过某种计算得到另一个集合是一种常用的操作，也是Lambda表达式的用武之地。 比如，以将一个名字集合转换为首字母大写了的名字集合为例。
为了不改变原集合，最“自然”的方式如下：
final List < String > uppercaseNames = new ArrayList < String >();
for ( String name : friends ) {
uppercaseNames . add ( name . toUpperCase ());
}
复制代码以上代码使用了外部遍历器，即for循环来完成集合操作。而将命令式代码转变为声明式代码(也就是函数式)的首要任务就是观察遍历的使用方式，尽可能地将外部遍历更改为内部遍历：
final List < String > uppercaseNames = new ArrayList < String >();
friends . forEach ( name -> uppercaseNames . add ( name . toUpperCase ()));
System . out . println ( uppercaseNames );
复制代码好了，现在我们使用了forEach来代替for循环。但是感觉代码并没有变的简洁多少。 我们可以使用其他的函数式接口(Functional Interface)来实现集合的转换。事实上，map方法比forEach方法更胜任这一类转换工作：
friends . stream ()
. map ( name -> name . toUpperCase ())
. forEach ( name -> System . out . print ( name + " " ));
System . out . println ();
复制代码这里使用了一个新的方法叫做stream()。在Java 8中，所有的集合类型都拥有这个方法。该方法的返回值是一个Stream类型的实例，该实例将集合本身包含在内(即上述的friends集合被包含在了stream实例中)。
可以将它理解成一个建立在集合上的iterator，它提供了除了forEach之外的更加高级的方法，如上述的map()。map方法的作用在于，它能够将接受的一个输入序列转换成一个输出序列(即完成转换工作)。这也意味着map方法是存在返回值的，所以后续的forEach方法操作的集合即是map方法返回的集合。
集合的转换操作可以是任意的，比如需要得到每个名字的长度：
friends . stream ()
. map ( name -> name . length ())
. forEach ( count -> System . out . print ( count + " " ));
// 5 4 4 4 4 5
复制代码使用方法引用
使用方法引用能够对上面的代码进行简化：
friends . stream ()
. map ( String: : toUpperCase )
. forEach ( name -> System . out . println ( name ));
复制代码回顾之前我们提到过的，当一个方法接受函数式接口作为参数时，可以传入Lambda表达式或者方法/构造器的引用进行调用。而以上的String::toUpperCase就是一个方法应用。
注意到对该方法进行引用时，省略了其参数信息。这是因为Java编译器在为该方法引用生成实例时，会进行类型推导自动地将集合中的元素作为参数传入到该方法中。
寻找元素
比如，当我们需要得到名字集合中所有以N开头的名字时，最“自然”的实现方式马上就会反映如下：
final List < String > startsWithN = new ArrayList < String >();
for ( String name : friends ) {
if ( name . startsWith ( "N" )) {
startsWithN . add ( name );
}
}
复制代码但是，我们可以让这一切变得更加简单和优雅：
final List < String > startsWithN = friends . stream ()
. filter ( name -> name . startsWith ( "N" ))
. collect ( Collectors . toList ());
复制代码对于filter方法，它期待的参数是一个返回boolean类型的Lambda表达式。对于被操作的集合中的每个元素而言，如果Lambda表达式返回的是true，那么就意味着filter后得到的stream实例中是包含该元素的，反之亦然。最后，可以通过调用stream实例的collect方法来将stream实例转换成一个List实例。
Lambda表达式的重用
比如，当需要对不止一个集合进行操作时：
final long countFriendsStartN = friends . stream (). filter ( name -> name . startsWith ( "N" )). count ();
final long countComradesStartN = comrades . stream (). filter ( name -> name . startsWith ( "N" )). count ();
final long countEditorsStartN = editors . stream (). filter ( name -> name . startsWith ( "N" )). count ();
复制代码显而易见，Lambda表达式需要被重用。我们可以将Lambda表达式给保存到一个变量中，就像Java处理其他任何类型的变量一样。问题来了？Lambda表达式的类型是什么呢，在Java这种静态类型语言中，我们不能单单使用诸如var，val就来代表一个Lambda表达式。
对于filter方法接受的Lambda表达式，它是符合Predicate接口类型的，因此可以声明如下：
final Predicate < String > startsWithN = name -> name . startsWith ( "N" );
final long countFriendsStartN = friends . stream (). filter ( startsWithN ). count ();
final long countComradesStartN = comrades . stream (). filter ( startsWithN ). count ();
final long countEditorsStartN = editors . stream (). filter ( startsWithN ). count ();
复制代码但是，问题又来了！如果在某些情况下需要检测的不是以N开头，而是以别的字母如B开头呢？ 那么，就需要再创建一个Lambda表达式并保存到变量中：
final Predicate < String > startsWithN = name -> name . startsWith ( "N" );
final Predicate < String > startsWithB = name -> name . startsWith ( "B" );
final long countFriendsStartN = friends . stream (). filter ( startsWithN ). count ();
final long countFriendsStartB = friends . stream (). filter ( startsWithB ). count ();
复制代码显然，这并不是长久之计。不能因为需要检测的首字母不同，就创建额外的Lambda表达式。我们需要它进行进一步的抽象。
第一种方法：
public static Predicate < String > checkIfStartsWith ( final String letter ) {
return name -> name . startsWith ( letter );
}
复制代码通过一个带参数的方法来得到需要的Lambda表达式。这个方法就是传说中的高阶函数，因为它返回了一个Lambda表达式作为返回值，而Lambda表达式本质上是一个函数。
另外，这里也体现了Java 8中关于Lambda表达式的另外一个特性：闭包和作用域。在以上返回的Lambda表达式中引用了一个letter变量，而这个letter变量则是checkIfStartsWith方法接受的参数，就像JavaScript等拥有闭包特性的语言那样，Java也具有这种特性了。
但是，在Java中利用闭包对变量进行访问时，有需要注意的问题。我们只能访问被final修饰的变量或者本质上是final的变量。正如上面checkIfStartsWith声明的参数被final修饰那样。
这是因为，Lambda表达式可能在任何时候被执行，也可能被任何其他线程执行。所以为了保证不出现竞态条件(Race Condition)，需要保证Lambda表达式中引用到的变量不会被改变。
final long countFriendsStartN = friends . stream (). filter ( checkIfStartsWith ( "N" )). count ();
final long countFriendsStartB = friends . stream (). filter ( checkIfStartsWith ( "B" )). count ();
复制代码利用上述可以根据要求动态生成Lambda表达式的高阶函数，就可以按照上面这个样子来进行代码重用了。
缩小作用域
实际上，使用static来实现以上的高阶函数并不是一个好主意。可以将作用域缩小一些：
final Function < String , Predicate < String >> startsWithLetter =
( String letter ) -> {
Predicate < String > checkStartsWith = ( String name ) -> name . startsWith ( letter );
return checkStartsWith ;
};
复制代码startsWithLetter变量代表的是一个Lambda表达式，该表达式接受一个String作为参数，返回另外一个Lambda表达式。这也就是它的类型Function>所代表的意义。
目前来看，使用这种方式让代码更加复杂了，但是将它简化之后就成了下面这个样子：
final Function < String , Predicate < String >> startsWithLetter = ( String letter ) -> ( String name ) -> name . startsWith ( letter );
复制代码还可以通过省略参数类型进行进一步的简化：
final Function < String , Predicate < String >> startsWithLetter = letter -> name -> name . startsWith ( letter );
复制代码乍一看也许觉得上面的形式太复杂，其实不然，你只是需要时间来适应这种简练的表达方式。
那么，我们需要实现的代码就可以这样写了：
final long countFriendsStartN = friends . stream (). filter ( startsWithLetter . apply ( "N" )). count ();
final long countFriendsStartB = friends . stream (). filter ( startsWithLetter . apply ( "B" )). count ();
复制代码使用startsWithLetter.apply("N")的结果是得到了Lambda表达式，它作为参数被传入到了filter方法中。剩下的事情，就和之前的代码一样了。
Predicate和Function
目前，已经出现了两种类型的函数式接口(Functional Interface)。它们分别是filter方法使用的Predicate和map方法使用的Function。其实从Java 8的源代码来看，它们的概念实际上是相当简单的：
@FunctionalInterface
public interface Predicate < T > {
boolean test ( T t );
// others...
}
@FunctionalInterface
public interface Function < T , R > {
R apply ( T t );
// others...
}
复制代码Predicate可以看做是Function的一个特例，即Function代表的就是Predicate。
挑选元素
比如，当我们需要打印出集合中第一个以某字母开头的元素时，最“自然”的实现如下：
public static void pickName (
final List < String > names , final String startingLetter ) {
String foundName = null ;
for ( String name : names ) {
if ( name . startsWith ( startingLetter )) {
foundName = name ;
break ;
}
}
System . out . print ( String . format ( "A name starting with %s: " , startingLetter ));
if ( foundName != null ) {
System . out . println ( foundName );
} else {
System . out . println ( "No name found" );
}
}
复制代码虽然是最“自然”的实现方式，但是它太太太丑陋了。从将foundName设置成null开始，这段代码充斥着一些代码的“坏味道”。正因为变量被设置成了null，为了避免臭名昭著的NullPointerException，我们必须在使用它之前进行空检查。除此之外，声明了可变变量，使用了冗长的外部遍历，没有尽量实现不可变性也是这段代码具有的问题。
然而，任务本身是很简单的。我们只是想打印集合中第一个符合某种条件的元素而已。
这次，使用Lambda表达式来实现：
public static void pickName (
final List < String > names , final String startingLetter ) {
final Optional < String > foundName = names . stream ()
. filter ( name -> name . startsWith ( startingLetter ))
. findFirst ();
System . out . println ( String . format ( "A name starting with %s: %s" , startingLetter , foundName . orElse ( "No name found" )));
}
复制代码以上代码出现了几个新概念： 在调用filter后，调用了findFirst方法，这个方法返回的对象类型时Optional。关于这个Optional，可以将它理解成一个可能存在，也可能不存在的结果。这样的话，就可以避免对返回结果进行空检查了。对于结果是否真的存在，可以使用isPresent()方法进行判断，而get()方法用于尝试对结果的获取。当结果不存在时，我们也可以使用orElse()来指定一个替代结果，正如上面使用的那样。
另外，当结果存在时，通过使用ifPresent方法也可以运行某一段代码，运行的代码可以通过Lambda表达式声明：
foundName . ifPresent ( name -> System . out . println ( "Hello " + name ));
复制代码但是，对于使用Lambda表达式实现的pickName方法，它做的工作是否会比命令式的实现方式更多呢？因为可以发现，在命令式实现中，当我们发现了第一个符号条件的元素之后，for循环会被立即终止。而findFirst是否也会执行类型的操作，当发现第一个符号条件的元素后，及时中断剩下的操作呢？答案是肯定的，关于这一点会在后面的文章中会进行介绍。
集合归约
和前面的种种操作不同，对于集合的归约(Collection Reduction)，元素与元素不再是独立的，它们会通过某种归约操作联系在一起。
比如得到名字集合的总字符数，就是一种典型的求和归约。可以实现如下：
System . out . println ( "Total number of characters in all names: " +
friends . stream ()
. mapToInt ( name -> name . length ())
. sum ());
复制代码通过stream实例的mapToInt方法，我们可以很方便地将一个字符串集合转换成一个整型数集合。然后调用sum方法得到整型数集合的和值。这里有一些实现细节，比如mapToInt方法得到的是一个Stream类型的子类型IntStream的实例，sum方法就是定义在IntStream类型之上。与IntStream类似，还有LongStream和DoubleStream类型，这些类型的存在是为了提供一些类型相关的操作，让代码调用更简洁。
比如，和sum()方法类似地，还有max()，min()，average()等一系列方法用来实现常用的归约。
但是归根到底，这些方法最终使用到的是一个叫做reduce()的方法。reduce方法的工作原理，可以这样概括：在对一个集合中的元素按照顺序进行两两操作时，根据某种策略来得到一个结果，得到的结果将作为一个元素参与到下一次操作中，最终这个集合会被归约成为一个结果。这个结果也就是reduce方法的返回值。
因此，当我们需要寻找并打印一个集合中最长的名字时(长度相同时，打印第一个)，可以如下实现：
final Optional < String > aLongName = friends . stream ()
. reduce (( name1 , name2 ) ->
name1 . length () >= name2 . length () ? name1 : name2 );
aLongName . ifPresent ( name -> System . out . println ( String . format ( "A longest name: %s" , name )));
复制代码我们来分析一下Lambda表达式：
( name1 , name2 ) -> name1 . length () >= name2 . length () ? name1 : name2 )
复制代码是不是符合我们概括的关于reduce方法的工作原理。
第一次执行两两操作时，name1和name2代表的是集合中的第一个和第二个元素，当第一个元素的长度大于等于第二个元素时，将第一个元素保留下来，否则保留第二个元素。 第二次执行两两操作时，name1代表的是上一次操作中被保留下来的拥有较长长度的元素，name2代表的是第三个元素。 以此类推...最后得到的结果就是集合中第一个拥有最长长度的元素了。
实际上，reduce方法接受的Lambda表达式的行为被抽象成了BinaryOperator接口：
@FunctionalInterface
public interface BinaryOperator < T > extends BiFunction < T , T , T > {
// others...
}
@FunctionalInterface
public interface BiFunction < T , U , R > {
/**
* Applies this function to the given arguments.
*
* @param t the first function argument
* @param u the second function argument
* @return the function result
*/
R apply ( T t , U u );
// others...
}
复制代码源码也反映了BinaryOperator和另一个函数式接口BiFunction之间的关系，当BiFunction接口中接受的三个参数类型一致时，也就成为了一个BinaryOperator接口。因此，前者实际上是后者的一个特例。
另外需要注意的几点：
- reduce方法返回的对象类型时Optional，这是因为待操作的集合可能是空的。
- 当集合只有一个元素时，reduce会立即将该元素作为实际结果以Optional类型返回，不会调用传入的Lambda表达式。
- reduce方法是会按照集合的顺序对其元素进行两两操作的，可以额外传入一个值作为“基础值”或者“默认值”，那么在第一次进行两两操作时，第一个操作对象就是这个额外传入的值，第二个操作对象是集合中的第一个元素。
比如，以下代码为reduce方法传入了默认值：
final String steveOrLonger =
friends . stream ()
. reduce ( "Steve" , ( name1 , name2 ) ->
name1 . length () >= name2 . length () ? name1 : name2 );
复制代码元素连接
在过去，我们使用for循环来连接一个集合中的所有元素：
for ( String name : friends ) {
System . out . print ( name + ", " );
}
System . out . println ();
复制代码上述代码的问题是，在最后一个名字后面也出现了讨人厌的逗号！为了修复这个问题：
for ( int i = 0 ; i < friends . size () - 1 ; i ++) {
System . out . print ( friends . get ( i ) + ", " );
}
if ( friends . size () > 0 )
System . out . println ( friends . get ( friends . size () - 1 ));
复制代码嗯，结果是正确了，但是你能忍受如此丑陋的代码吗？
为了解决这个非常非常常见的问题，Java 8中终于引入了一个StringJoiner类。 可以通过调用String类型的join方法完成这个操作：
System . out . println ( String . join ( ", " , friends ));
复制代码StringJoiner其实还能够对元素的连接操作进行更多的控制。比如为每个元素添加前缀，后缀然后再进行连接。具体的使用方法可以去参考API文档。
当然，使用reduce方法也能够完成对于集合元素的连接操作，毕竟集合元素的连接也是一种归约。只不过，正如前面看到的那样，reduce方法太过于底层了。针对这个问题，Stream类型还定义了一个collect方法用来完成一些常见的归约操作：
System . out . println ( friends . stream (). map ( String: : toUpperCase ). collect ( Collectors . joining ( ", " )));
复制代码可见collect方法并不自己完成归约操作，它会将归约操作委托给一个具体的Collector，而Collectors类型则是一个工具类，其中定义了许多常见的归约操作，比如上述的joining Collector。