Java8专题三《Lambda表达式》

本章内容
1、Lambda是什么？
2、为什么要用？
3、在哪里以及如何使用Lambda？
4、 函数式接口
5、方法引用
6、Lambda复合

前文

本章我会展示如何构建Lambda，它的使用场合，以及如何利用它使代码更简洁。我们还会介绍一些新的东西，如类型推断和Java8 API中重要的新接口。最后，我们将介绍方法引用，这是一个常常和Lambda表达式联用的有用的新功能。这一章很重要，可以教会你如何使用Lambda

1、Lambda是什么？
可以把Lambda表达式理解为简洁的表示可传递的匿名函数的一种方式：它没有名称，但有参数列表、函数主体、返回类型，可能还有一个可以抛出的异常列表
Lambda表达式可以作为参数传递给方法或者存储在变量中

Lambda表达式由参数、箭头和主体组成

例如：
Lambda基本语法：
(parameters) -> expression
或
(parameters) -> { statements; }

例子：
1、(String s) -> s.length() 注解1
2、(Apple a) -> a.getWeight() > 150 注解2
3、() -> 42 注解3
4、 (int x, int y) -> { System.out.println("Result:"); System.out.println(x+y); } 注解4

2、为什么要用？
比如，利用Lambda表达式，你可以更为简洁的自定义一个Comparator对象。
先前：

Comparator<Apple> byWeight = new Comparator<Apple>() { 
  public int compare(Apple a1, Apple a2){ 
  return a1.getWeight().compareTo(a2.getWeight()); 
  } 
}; 

用了Lambda表达式之后：

Comparator<Apple> byWeight = 
  (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight()); 

3、在哪里以及如何使用Lambda
你可以在函数式接口上使用Lambda表达式。

1）函数式接口
函数式接口的定义：函数式接口就是只定义一个抽象方法的接口你已经知道了Java API中的其他函数式接口，如我们在专题二中谈到的Comparator和֖Runnable。

//java.util.Comparator
public interface Comparator<T> { 
 int compare(T o1, T o2); 
} 
//java.lang.Runnable
public interface Runnable{
 void run(); 
} 

2）函数描述符
函数式接口的抽象方法的签名基本就是Lambda表达式的签名。我们将这种抽象方法叫做函数描述符。

例如 ，Runnable接口可以看作是一个什么也不接受什么也不返回（void）的函数的签名，因为它只有一个叫做run的抽象方法，这个方法什么也不接受，什么也不返回。

我们从专题二使用Lambda表达式的例子中，知道如何利用函数式接口来传递Lambda，但你还要定义你自己的接口。所以在这一节中，我们会探讨Java8中加入的新接口，你可以重用它来传递多个不同的Lambda。

3）使用函数式接口
Java8的库设计师帮你在java.util.function包中引入了几个新的函数式接口。我们接下来回来介绍Predicate、Consumer、Function。

Predicate

java.util.function.Predicate接口定义了一个名叫test的抽象方法，它接收泛型T对象，并返回一个boolean。这就和你在专题二中创建的一样，现在可以直接使用了。

// code清单
    @FunctionalInterface
    public interface Predicate<T> {
        boolean test(T t);
    }

    public static <T> List<T> filter(List<T> list, Predicate<T> p) {
        List<T> results = new ArrayList<>();
        for (T s : list) {
            if (p.test(s)) {
                results.add(s);
            }
        }
        return results;
    }

    Predicate<String> nonEmptyStringPredicate = (String s) -> !s.isEmpty();
    List<String> nonEmpty = filter(listOfStrings, nonEmptyStringPredicate);

Consumer
java.util.function.Consumer定义了一个名叫accept的抽象方法，它接受泛型T
的对象，没有返回（void）。你如果需要访问类型T的对象，并对其执行某些操作，就可以使用
这个接口。比如，你可以用它来创建一个forEach方法，接受一个Integers的列表，并对其中
每个元素执行操作。在下面的代码中，你就可以使用这个forEach方法，并配合Lambda来打印
列表中的所有元素。

//code清单
@FunctionalInterface 
public interface Consumer<T>{ 
  void accept(T t); 
} 
public static <T> void forEach(List<T> list, Consumer<T> c){
 for(T i: list){ 
  c.accept(i); 
  } 
} 
forEach( 
  Arrays.asList(1,2,3,4,5), 
  (Integer i) -> System.out.println(i)
  ); 

Function
java.util.function.Function<T, R>接口定义了一个叫作apply的方法，它接受一个
泛型T的对象，并返回一个泛型R的对象。如果你需要定义一个Lambda，将输入对象的信息映射
到输出，就可以使用这个接口（比如提取苹果的重量，或把字符串映射为它的长度）。在下面的
代码中，我们向你展示如何利用它来创建一个map方法，以将一个String列表映射到包含每个
String长度的Integer列表。

//code清单
@FunctionalInterface 
public interface Function<T, R>{ 
 R apply(T t); 
} 
public static <T, R> List<R> map(List<T> list, 
 Function<T, R> f) { 
 List<R> result = new ArrayList<>(); 
 for(T s: list){ 
 result.add(f.apply(s)); 
 } 
 return result; 
} 
// [7, 2, 6] 
List<Integer> l = map( 
 Arrays.asList("lambdas","in","action"), 
 (String s) -> s.length() 
 );

原始类型特化
我们介绍了三个泛型函数式接口：Predicate、Consumer、和Function<T,R>。还有些函数式接口专为某些类型而设计。
回顾一下：泛型只能绑定到引用类型，因此，在Java里有一个将原始类型转换为对应的引用类型的机制（自动装箱机制）。这个机制叫做装箱，相反的操作就是拆箱。

//一个int被装箱成为Integer
 List<Integer> list = new ArrayList<>();
        for (int i = 300; i < 400; i++) {
            list.add(i);
        }

但这在性能方能是要付出代价的。
Java8为我们前面所说的函数式接口带来了一个专门的版本，以便在输入和输出都是原始类型是避免自动装箱的操作。

public interface IntPredicate{ 
  boolean test(int t); 
} 
IntPredicate evenNumbers = (int i) -> i % 2 == 0; 
//true(无装箱)
evenNumbers.test(1000); 
Predicate<Integer> oddNumbers = (Integer i) -> i % 2 == 1;
//false(装箱)
oddNumbers.test(1000); 

IntPredicate就避免了对值1000进行装箱操作。
Java8中还提供了一下函数式接口

5、方法引用
方法引用让你可以重复使用现有的方法定义，并像Lambda一样 传递它们。在一些情况下，比起用Lambda表达式，它们似乎更易读，感觉也更自然。下面我们借助更新的Java8 API，用方法引用写的一个排序的例子：
先前：

inventory.sort((Apple a1, Apple a2) 
 -> a1.getWeight().compareTo(a2.getWeight())); 

使用方法引用之后：

//֖java.util.Comparator.comparing
inventory.sort(comparing(Apple::getWeight)); 

6、复合Lambda表达式的有用方法
Java8的好几个函数式接口都有为方便而设计的方法。比如用于传递Lambda表达式Comparator、Function和Predicate都提供了允许你进行复合的方法。比如，你可以让两个谓词之间做个or操作，组合成一个更大的谓词，你还可以让一个函数的结果成为另一个函数的输入。

你可能会想，函数式接口中怎么可能有更多方法呢？（毕竟，这违背了函数式接口的定义啊！）窍门在于，我们即将介绍的方法都是默认方法，也就是说它们不是抽象方法。我会在后面的专题给大家详细介绍。

1）比较器复合
我们前面看到，你可以使用静态方法Comparator.comparing，根据提取用于比较的键值的Function来返回一个Comparator，如下所示：

Comparator<Apple> c = Comparator.comparing(Apple::getWeight); 

a.逆序

inventory.sort(comparing(Apple::getWeight).reversed()); 

b.比较器链
但如果发现有两个苹果一样重怎么办？哪个苹果应该排在前面呢？你可能想要按产国排序。thenComparing方法就是做这个用的。

 inventory.sort(comparing(Apple::getWeight)
                .reversed()
                .thenComparing(Apple::getCountry));

2）谓词复合
谓词接口包括三个方法：：negate（非）、and和or，让你可以重用Predicate来创建更复杂的谓词。
比如苹果不是红色的：

//产生现有Predicate对象redApple的非
Predicate<Apple> notRedApple = redApple.negate(); 

你可能想要把两个Lambda用and方法组合起来，比如一个苹果既是红色有比较重：

//链接Predicate两个谓词来生成另一个Predicate对象
   Predicate<Apple> redAndHeavyApple =
                redApple.and(a -> a.getWeight() > 150);

比如要表达要么是重（150g以上）的红苹果，要么是绿苹果：

//链接Predicate的方法来构造更复杂Predicate对象
Predicate<Apple> redAndHeavyAppleOrGreen =
                redApple.and(a -> a.getWeight() > 150)
                        .or(a -> "green".equals(a.getColor()));

请注意，and和or方法是按照在表达式链中的位置，从左向右确定优先级的。因此a.or(b).and©可以看作(a || b) && c

2）函数复合
最后，你还可以把Function接口所代表的Lambda表达式复合起来。Function接口为此配了andThen和compose两个默认方法，它们都会返回Function的一个实例。

例子：假如一个函数f=x+1,g=x*2，你可以将他们组合成一个函数h
当h=g(f(x));即h=(x+1)*2

Function<Integer, Integer> f = x -> x + 1; 
Function<Integer, Integer> g = x -> x * 2; 
Function<Integer, Integer> h = f.andThen(g); 
int result = h.apply(1);

当h=f(g(x));即h=(x*2)+1

Function<Integer, Integer> f = x -> x + 1; 
Function<Integer, Integer> g = x -> x * 2; 
Function<Integer, Integer> h = f.compose(g);
int result = h.apply(1);

以上两个例子说明了andThen和compose之间的区别。

那在实际中有什么用呢？比如你有一系列工具方法，对用String表示的一封信做文本转换：

public class Letter {
        public static String addHeader(String text) {
            return "From Raoul, Mario and Alan: " + text;
        }

        public static String addFooter(String text) {
            return text + " Kind regards";
        }

        public static String checkSpelling(String text) {
            return text.replaceAll("labda", "lambda");
        }
    }

那我们就可以通过复合这些工具方法来创建各种转型流水线了，比如创建一个流水线：先加上抬头，然后进行拼写检查，最后加上一个落款。

 Function<String, String> addHeader = Letter::addHeader;
    Function<String, String> transformationPipeline
            = addHeader.andThen(Letter::checkSpelling)
            .andThen(Letter::addFooter);

第二个流水线可能只加抬头、落款而不做拼写检查：

Function<String, String> addHeader = Letter::addHeader; 
Function<String, String> transformationPipeline 
 = addHeader.andThen(Letter::addFooter); 

小结

1、 Lambda表达式可以理解为一种匿名函数：它没有名称、但有参数列表、函数主体、返回类型、可能还有一个可以抛出的异常的列表。
2、Lambda表达式可以让你简洁地传递代码。
3、函数式接口就是仅仅声明了一个抽象方法的接口
4、只有在接收函数式接口的地方才可以使用Lambda表达式。
5、Lambda表达式允许你直接内联，为函数式接口的抽象方法提供实现，并且将整个表达式作为函数式接口的一个实例。
6、Java8自带一些常用的函数式接口，放在java.util.function包里，包括Predicate 、Function<T,R>、Consumer。还有Supplier …
7、为了避免装箱操作，对Predicate和Function<T,R>等通用函数式接口的原始类型特化：IntPredicate、IntToLongFunction等。
8、方法引用让你重复使用现有的方法实现并直接传递它们。
9、Comparator、Predicate和Function等函数式接口都有几个可以用来结合Lambda表达式的默认方法。