Upgrading to Java 8——第一章 Lambda表达式

第一章 Lambda表达式

　　Lamada 表达式是Java SE 8中最重要的新特性，长期以来被认为是在Java中缺失的特性，它的出现使整个java 语言变得完整。
至少到目前，在这节中你将学习到什么是lambda，为什么他是出色的一部分。同时也会介绍一些新的技术例如单一抽象方法和函数式接口。

　　为什么是lambda 表达式。

　　就像闭包一样， Lambda表达会使一些结构变得精简和良好的可读性，特别是在有处理内部类的时候。下面的例子是用内部类实现的代码块：

　　　　Runnable runnable = new Runnable() {     　　

　　　　　　@Override 

　　　　　　public void run() {        　　　　

　　　　　　　　System.out.println("Running...");     　　

　　　　　　}　　　　

　　　　}

　　 其实，这些代码可以用Lambda表达式替换成如下简短的代码：

　　　　 Runnable runnable = () -> System.out.println("Running...")

　　换句话说， 如果你需要传递一个 runnable 接口给java.util.concurrent.Executor类，需要

　　　　executor.execute(new Runnable() {

　　　　     @Override    

　　　　　　public void run() {        

　　　　　　　　System.out.println("Running...");    

　　　　　　 }

　　　　 });

　　但你可以用Lambda表达式实现同样的效果，用下面的代码；

　　　　 executor.execute(() -> System.out.println("Running..."));  

　　精短，优雅，干净，更富有表达性。  

　　修改接口。

　　在深入研究lambda之前，先介绍一下在java 8 中接口里可以包含defalut 和 static 方法。这部分解释static和defalut 方法是什么，
　　为什么这里需要大幅度的修改使lambda 融入到java 核心库中。

　　默认方法

　　将功能添加到接口是扩展接口一个安全的方式。不过，你最终会得到两个功能相似的接口。如果你只需要继承一个两个接口还是可以接受的，
　　但如果需要添加新特性到成百的接口中，这就变成很严重的问题。

　　这正是Java设计者们面对的问题，他们试图添加lambda 到java8 中去支持在集合框架中数十个接口。这些接口需要添加新的方法去支持Lambda，但是扩展所有的接口只会产出一倍的接口，其中一些接口可能会冠以List2或ExtendeSet这些丑陋的名字。

　　反而，他们通过添加default方法解决了这个问题。 默认方法是在接口中已经实现好的方法。一个接口实现类不用实现默认方法，
这就意味着你 添加新的方法在接口中同时没有打破向后兼容性问题。

　　在接口中定义默认方法，只需要在方法签名前加上“default”关键字即可。除此之外，添加大括号并在其中添加代码。

　　在以后能学到，在java8中很多接口都有默认方法。

　　当你实现带有默认方法的接口时，你有这些选择:
　　　　忽略默认方法，直接继承他们就生效。
　　　　重新声明默认方法，要改成抽象方法。
　　　　重载默认方法。 

　　记住一点，java支持默认方法主要是为了向后兼容性。你绝不应该写程序不用类。

　　静态方法。

　　一个静态方法供类的所有实例共享，在java8以后，你可以在接口中使用静态方法 这样与接口相关联的所有静态方法可以用接口,而不是一个帮助类.

　　静态方法的签名跟默认方法的签名很像，替代default关键字，使用static关键字，static在接口中默认是public的。

　　静态方法在接口中很少见，在java.util package包中将近30个接口，只有两个有静态方法。

　　函数式接口

　　　　除了默认方法和静态方法，还有一个先决条件在学lambda之前：函数式接口。函数式接口只有一个抽象方法并且没有重写Object类中的方法，也被称作单一抽象方法（SAM），

　　java.lang.Runnable就是一个函数式接口，它只有一个抽象方法 run（）,函数式接口可以有默认方法和静态方法，复写了Object类中的public的方法也算是函数式接口。

public interface Calculator {

    double calculate(int a, int b);
    
    public default int subtract(int a, int b) {
        return a - b;
    }

    public default int add(int a, int b) {
        return a * b;
    }
    
    @Override
    public String toString();
}

　　在Java核心库中常见的函数式接口有： java.lang.Runnable, java.lang.AutoCloseable, java.lang.Comparable，java.util.Comparator.此外，在java.util.function也有很多。

　　函数式接口可以用注解@FunctionalInterface标注。

　　为什么函数式接口这么重要？你可以使用函数式接口替代匿名内部类。如果不是，则不能这么用。

　　lambda 表达式语法

　　在上面的例子中calculate方法可以看作最基本的 lambda表达式语法。这个方法允许你定义任何的数学计算，使用两个整形参数返回一个double类型。下面有两个例子。

Calculator addition = (int a, int b) -> (a + b);
System.out.println(addition.calculate(5, 20)); // prints 25.0

Calculator division  = (int a, int b) -> (double) a / b;
System.out.println(division.calculate(5, 2)); // prints 2.5

Lambda表达式就是这么优雅，要是没有它你该多写多少代码？

Lambda表达式的标准定义有两种：

(parameter list) -> expression

或 

(parameter list) -> { 
    statements
}
参数的类型跟接口中抽象方法的参数是一致的。不过，参数类型是可选的。换句话说，下面的方法是有效的。
Calculator addition = (int a, int b) -> (a + b);
Calculator addition = (a, b) -> (a + b);
总结一下，Lambda表达式就是函数是接口实现的快捷方式，它相当于函数式接口实现的实例，因为在方法中可以使用Object作为参数，所以把Lambda表达式作为方法的参数也是可能的。

Java中预定义的函数式接口
java.util.function是java 8 中一个新包，里面包含了超过40个预定义函数式接口方便你去书写 Lambda 表达式风格的代码。下面是一些常用的接口。

函数式接口	描述
Function	传递一个参数返回一个结果。这个结果的类型可以与参数的类型不相同。
BiFunction	传递两个参数返回一个结果。这个结果的类型可以与任一参数的类型不相同。
UnaryOperator	代表一个操作符的操作，它的返回结果类型与操作符的类型一样。实际上它可以被看作是Function 它的返回结果跟参数一样，它是Function 的子接口。
BiOperator	代表两个操作符的操作，它的返回结果类型必须与操作符相同。
Predicate	传递一个参数，基于参数的值返回boolean值。
Supplier	代表一个供应者的结果。
Consumer	传递一个参数但没有返回值。

Function, BiFunction and Other Variants
Function接口通常用来创建一个参数的函数并返回一个结果。它是参数化的类型，定义如下：
public interface Function<T, R>
T是参数类型，R是返回的结果类型。
Function只有一个抽象方法，apply，它的签名如下：
R apply(T argument)
这个方法需要重写当使用Function的时候，下面的例子定义了一个Function用来实现英米与公里的转换。Function传递一个Integer类型作为参数，并返回Double类型。

public class FunctionDemo1 {
    public static void main(String[] args) {
        Function<Integer, Double> milesToKms =
                (input) -> 1.6 * input;
        int miles = 3;
        double kms = milesToKms.apply(miles);
        System.out.printf("%d miles = %3.2f kilometers ",
                miles, kms);
    }

}

执行此类，在控制台输出：3 miles = 4.80 kilometers

BiFunction是Function的一种变体，它传递两个参数并返回一个结果，下面的例子创建一个Function 根据给定的长和宽计算面积，
需要调用apply方法实现。

import java.util.function.BiFunction;

public class BiFunctionDemo1 {
    public static void main(String[] args) {
        BiFunction<Float, Float, Float> area =
                (width, length) -> width * length;
        float width = 7.0F;
        float length = 10.0F;
        float result = area.apply(width, length);
        System.out.println(result);
    }
}

控制台输出：70.0

除了BiFunction，还有一系列的Function变体，例如，IntFunction 只能传递int类型的参数。LongFunction and DoubleFunction 与IntFunction用法类似，只是传递的参数类型不同。

还有一些变体不要求传递参数化的参数，因为他们被设计成传递制定类型参数，并返回制定类型的结果。例如，IntToDoubleFunction 接受int类型参数并返回double类型结果，还有区别是，使用
applyAsDouble 替代apply方法，下面的例子实现摄氏温度转换成华氏温度。

import java.util.function.IntToDoubleFunction;

public class IntToDoubleFunctionDemo1 {
    public static void main(String[] args) {
        IntToDoubleFunction celciusToFahrenheit =
                (input) -> 1.8 * input + 32;
        int celcius = 100;
        double fahrenheit =
                celciusToFahrenheit.applyAsDouble(celcius);
        System.out.println(celcius + "u2103" + " = "
                + fahrenheit + "u2109 ");
    }
}

控制台输出：100℃ = 212.0℉

LongToDoubleFunction and LongToIntFunction 用法与IntToDoubleFunction类似。

UnaryOperator 是 Function 的另一种特殊实现，他的操作符类型与返回类型一样。它的定义如下：
　　public interfaceUnaryOperator<T> extends Function<T,T>
BinaryOperator 是 BiFunction 的一特殊实现，要求所有参数类型一样并与返回类型一样。

 Predicate

Predicate是根据传递参数的值返回boolean值。它有一个抽象方法test。

 举例，下面的PredicateDemo1 类 定义一个Predicate 来判断传递进去的字符串每一个字符是否全是数字。

import java.util.function.Predicate;

public class PredicateDemo1 {
    public static void main(String[] args) {
        Predicate<String> numbersOnly = (input) -> {
            for (int i = 0; i < input.length(); i++) {
                char c = input.charAt(i);
                if ("0123456789".indexOf(c) == -1) {
                    return false;
                }
            }
            return true;
        };
        
        System.out.println(numbersOnly.test("12345"));// true
        System.out.println(numbersOnly.test("100a")); // false
    }
}

Supplier

Supplier没有参数但返回一个值。要实现这个接口必须重写get抽象方法并返回参数化类型的实例。

下面的例子，Supplier定义了一个返回 数字随机数，并使用for循环打印5个随机数。

import java.security.SecureRandom;
import java.util.function.Supplier;

public class SupplierDemo1 {
    public static void main(String[] args) {
    Supplier<Integer> oneDigitRandom = () -> {
        SecureRandom random = new SecureRandom();
        return random.nextInt(10);
    };
    for (int i = 0; i < 5; i++) {
        System.out.println(oneDigitRandom.get());
    }
    }
}

 还有一些Supplier的变体，例如DoubleSupplier (返回 Double), IntSupplier 和LongSupplier.

Consumer

Consumer是一个没有返回值的操作，它有一个抽象方法accept。

下面的例子使用ConSumer传递一个字符串参数，根据字符串的长度，和使用Function返回的空格的长度，最后把空格与字符串连接。

import java.util.function.Consumer;
import java.util.function.Function;

public class ConsumerDemo1 {
    public static void main(String[] args) {
    Function<Integer, String> spacer = (count) -> {
        StringBuilder sb = new StringBuilder(count);
        for (int i = 0; i < count; i++) {
        sb.append(" ");
        }
        return sb.toString();
    };

    int lineLength = 60; // characters
    Consumer<String> printCentered = (input) -> {
        int length = input.length();
        String spaces = spacer.apply((lineLength - length) / 2);
        System.out.println(spaces + input);
    };

    printCentered.accept("A lambda expression a day");
    printCentered.accept("makes you");
    printCentered.accept("look smarter");
    }
}