Java8教程

在本教程中主要讲解Java 8新的函数式编程功能，熟悉这些新的 API：streams, 函数接口, map扩展和新的日期API。

接口的缺省方法

Java 8让我们能够增加非抽象方法实现到一个接口中， 使用default，这个特点就是 Extension Methods.

interface Formula {

    double calculate(int a); 
    default double sqrt(int a) {
        return Math.sqrt(a);
    }
}

接口 Formula 定义了一个默认方法sqrt. 该接口实现类只要完成接口中抽象方法calculate即可，而sqrt方法可以被外部使用。

ormula formula = new Formula() {

    @Override
    public double calculate(int a) {
        return sqrt(a * 100);
    }
};

formula.calculate(100);     // 100.0
formula.sqrt(16);           // 4.0

代码中formula 实现类是一个匿名类，在Java 8中有很多好的方法实现这种单个方法的匿名类。

Lambda表达式

先看看传统Java的代码例子：

List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");

Collections.sort(names, new Comparator<String>() {

    @Override
    public int compare(String a, String b) {
        return b.compareTo(a);
    }

});

静态方法Collections.sort接受一个集合List和一个比较器comparator，后者是为了对集合中元素排序，一般我们都是创建一个匿名的比较器对象传递集合中。

Java 8使用Lambda表达式替代这种匿名类。

Collections.sort(names, (String a, String b) -> {

    return b.compareTo(a);

});

代码相对简短，还可以再短小些：

Collections.sort(names, (String a, String b) -> b.compareTo(a));

对于只有一个方法，你可以忽略{} 和 return语法，当然还可以再简短：

Collections.sort(names, (a, b) -> b.compareTo(a));

Java编译器会照顾你忽略了a和b的类型String。这称为语言的类型判断。

 

函数接口

Lambda表达式是一种函数语法，与Java的类型语言是两种不同性质的语法，如同南北两个不同方向，那么Java 8的Lambda表达式如何配合Java天生的类型系统呢？每个Lambda都对应一个给定的类型，主要是一个接口类型，也称为函数接口，只能包含一个抽象方法，每个类型的Lambda表达式与这个抽象方法匹配，因为默认default方法不是抽象方法，你可以在接口中自由增加自定义的default默认方法。

我们可以使用很多接口作为lambda表达式，只要这个接口只包含一个抽象方法，为了确保你的接口符合需要，你应当加入元注解 @FunctionalInterface. 编译器将会注意到这个元注解，如果你试图增加第二个抽象方法到接口中，它会抛出编译错误。

@FunctionalInterface

interface Converter<F, T> {

    T convert(F from);

}

Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
Integer converted = converter.convert("123");
System.out.println(converted);    // 123

这段代码中，我们定义了接口Converter一个抽象方法，注意虽然使用了@FunctionalInterface ，但是不使用也是可以，那么这个接口中抽象方法就可以作为Lambda表达式使用，首先，我们定义了这个接口的实现：

Converter<String, Integer> converter = (from) -> Integer.valueOf(from);

(from) -> Integer.valueOf(from)实际是抽象方法 T convert(F from)的实现具体细节，这里是将字符串转换为整数型。

然后，我们就可以直接调用这个接口：converter.convert("123")

 

方法和构造器的引用

上述代码如果使用静态方法引用static method references将会更加简化：

Converter<String, Integer> converter = Integer::valueOf;
Integer converted = converter.convert("123");
System.out.println(converted);   // 123

Java 8 使用符号 ::让你传递方法或构造器的引用，因为 Integer.valueOf是一个静态方法，其引用方式是 Integer::valueOf，我们还能引用一个对象的普通方法：

class Something {

    String startsWith(String s) {

        return String.valueOf(s.charAt(0));

    }

}

Something something = new Something();
Converter<String, String> converter = something::startsWith;
String converted = converter.convert("Java");
System.out.println(converted);    // "J"

这里引用的是类Something的方法startsWith，我们首先要创建这个类的实例，然后使用something::startsWith，这相当于实现了接口Converter的convert方法。不必像我们传统方式，通过Something implements Converter，然后在具体实现Converter的抽象方法convert。这样摆脱了子类对接口的依赖。

符号::也可以使用在构造器方法中：

class Person {

    String firstName;
    String lastName;
    Person() {}

    Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;

    }

}

下面是创建Person的工厂接口：

interface PersonFactory<P extends Person> {

    P create(String firstName, String lastName);

}

有别于传统手工实现这个接口的方式，我们使用::将接口和实现粘合在一起。

PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");

我们使用Person::new创建了一个指向Person构造器的引用，Java编译器将会自动挑选匹配PersonFactory.create方法签名的构造器。

 

Lambda作用域

从Lambda表达式访问外部变量非常类似匿名对象访问外部一样，匿名对象只能访问外部访问有final定义的变量。

访问本地变量:

final int num = 1;
Converter<Integer, String> stringConverter =   (from) -> String.valueOf(from + num);
stringConverter.convert(2);   

 

这里(from) -> String.valueOf(from + num)表达式 访问了外部的变量num，区别于匿名类，这个变量不是必须加上final定义。下面也可以：

int num = 1;
Converter<Integer, String> stringConverter =  (from) -> String.valueOf(from + num);

这就是Lambda表达式比匿名类的好处。但是这不代表你可以修改num值，这里是隐式的final，下面语法是不可以的：

int num = 1;
Converter<Integer, String> stringConverter =   (from) -> String.valueOf(from + num);
num = 3;

一旦被写入了Lambda表达式的变量不能再被修改了。

访问字段和静态变量

正好和本地变量相反，我们在Lambda表达式中可以对实例的字段和静态变量进行读和写。无论这个字段或静态变量是否在lambda表达式中使用过。

class Lambda4 {

    static int outerStaticNum;
    int outerNum;

    void testScopes() {

        Converter<Integer, String> stringConverter1 = (from) -> {
            outerNum = 23;
            return String.valueOf(from);
        };

        Converter<Integer, String> stringConverter2 = (from) -> {
            outerStaticNum = 72;
            return String.valueOf(from);
        };
    }
}

访问接口的默认方法

还记得开始的formula案例吗？接口Formula定义了一个默认方法sqrt，它可以被匿名对象访问 ，但是不能被Lambda表达式访问。

默认方法不能在Lambda表达式中访问，下面代码不会编译通过：

Formula formula = (a) -> sqrt( a * 100);

上节我们已经明白了Lambda表达式是通过函数接口实现的，JDK 1.8 API 包含了很多内建的函数接口，有一些是为了老版本如Comparator or Runnable. 这些已经存在的接口都做了拓展，通过 @FunctionalInterface 注解以便更好地支持Lambda。

　　但是在Java 8中还有一些新的函数接口让你开发更简单，一些新的接口来自于google的 Guava库。

内建函数接口

Predicates

Predicates是一个只有一个参数的返回boolean值的函数 这个接口包含了各种默认方法，用来组合predicates完成复杂的逻辑表达(and, or, negate)

//只有一个输入参数s，返回的是非真即否的boolean类型
Predicate<String> predicate = (s) -> s.length() > 0;

predicate.test("foo"); // true
predicate.negate().test("foo"); // false

Predicate<Boolean> nonNull = Objects::nonNull;
Predicate<Boolean> isNull = Objects::isNull;

Predicate<String> isEmpty = String::isEmpty;
Predicate<String> isNotEmpty = isEmpty.negate();

 

Functions

Functions 接受一个输入参数，产生一个结果，默认方法能被多个函数一起作为链条一样使用 (compose, andThen).

Function<String, Integer> toInteger = Integer::valueOf;
Function<String, String> backToString = toInteger.andThen(String::valueOf);

backToString.apply("123"); // "123"

 

Suppliers

Suppliers 产生一个给定泛型类型的结果，不像Functions, Suppliers并不接受输入参数。

Supplier<Person> personSupplier = Person::new;
personSupplier.get(); // new Person

 

Consumers

Consumers是对单个输入参数执行的一些操作。

Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
greeter.accept(new Person("Luke", "Skywalker"));

 

Comparators

Comparators是老版本比较器在Java8应用，Java 8加了默认方法，可以作为Lambda表达式使用，不再需要以前老式专门做一个Comparator实现类了。

Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);

Person p1 = new Person("John", "Doe");
Person p2 = new Person("Alice", "Wonderland");

comparator.compare(p1, p2); // > 0
comparator.reversed().compare(p1, p2); // < 0

 

Optionals

Optionals并不是函数接口，它是一个能够阻止空指针错误NullPointerException小巧的工具。

Optional是一个值容器，这个值可以是空或不空。过去我们一个方法应该返回不空的值，但是可能返回空，那么现在我们可以使用Java 8，返回一个Optional即可

Optional<String> optional = Optional.of("bam");

optional.isPresent(); // true
optional.get(); // "bam"
optional.orElse("fallback"); // "bam"

optional.ifPresent((s) -> System.out.println(s.charAt(0))); // "b"

 

Streams

　　java.util.Stream代表一个序列元素，这些元素能够执行一个或多个操作， Stream操作既可以是intermediate 或者terminal. 而terminal操作返回某个类型的一个结果, intermediate 操作返回的是stream自身，这样你能将多个调用链接在一行中实现。Streams是被一个源 如一个java.util.Collection 类似lists 或 sets 创建(maps还没有支持). Stream 操作可以顺序也可以并行实现。

　　为了看看顺序操作是如何执行的，我们首先创建如下源：

List<String> stringCollection = new ArrayList<>();
stringCollection.add("ddd2");
stringCollection.add("aaa2");
stringCollection.add("bbb1");
stringCollection.add("aaa1");
stringCollection.add("bbb3");
stringCollection.add("ccc");
stringCollection.add("bbb2");
stringCollection.add("ddd1");

这是一个字符串集合。在Java 8中中集合Collections已经被拓展，你能简单地调用 Collection.stream() 或 Collection.parallelStream()来创建Stream.下面解释 Stram的主要操作。

Filter

Filter接受一个predicate，然后根据其返回真或假对Stram中所有元素进行过滤，这个操作是intermediat，所以能让我们对结果再调用其他stream操作(如forEach)处理. ForEach能接受对 stream每个元素执行函数操作 (这个例子中是filtered). ForEach是一个terminal操作. 它返回 void, 这样我们不能基于其结果再调用其他Stram操作了。

stringCollection
    .stream()
    .filter((s) -> s.startsWith("a"))
    .forEach(System.out::println);

// "aaa2", "aaa1"

 

Sorted

Sorted是一个intermediate操作，能够返回Stream的排序结果，元素是按自然排序规则，除非你传入一个定制的Comparator.

stringCollection
    .stream()
    .sorted()
    .filter((s) -> s.startsWith("a"))
    .forEach(System.out::println);

// "aaa1", "aaa2"

请记住已经排序意味着创建一个排过许的视图，并不会在后端真正产生一个的排序集合，stringCollection中的元素顺序其实没有变化:

System.out.println(stringCollection);

// ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1

 

Map

Map操作也是intermediate的，按给定的函数对每个元素转换操作到一个结果。下面案例是使用函数转换字符串到大写将每个输入字符串转到到大写字符。

stringCollection
    .stream()
    .map(String::toUpperCase)
    .sorted((a, b) -> b.compareTo(a))
    .forEach(System.out::println);

// "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1"

你也可以使用map转换一个对象到另外一个类型，Stream的结果的泛型类型取决于你传入函数的泛型类型。

Match

各种匹配操作能够用于检测某个predicate是否匹配stream. 所有这些操作都是terminal，不能再被用作Stream其他操作的输入了，并且只返回一个boolean结果

 

boolean anyStartsWithA = 
    stringCollection
        .stream()
        .anyMatch((s) -> s.startsWith("a"));

System.out.println(anyStartsWithA);      // true

boolean allStartsWithA = 
    stringCollection
        .stream()
        .allMatch((s) -> s.startsWith("a"));

System.out.println(allStartsWithA);      // false

boolean noneStartsWithZ = 
    stringCollection
        .stream()
        .noneMatch((s) -> s.startsWith("z"));

System.out.println(noneStartsWithZ);      // true

 

Count

Count是一个terminal操作，返回Stream中元素的个数，类型是初始类型long.

long startsWithB = 
    stringCollection
        .stream()
        .filter((s) -> s.startsWith("b"))
        .count();

System.out.println(startsWithB);    // 3

 

Reduce

这个terminal操作执行对Stream元素按给定函数执行约简的操作，结果是包含约简好的元素的一个Optional。

Optional<String> reduced =
    stringCollection
        .stream()
        .sorted()
        .reduce((s1, s2) -> s1 + "#" + s2);

reduced.ifPresent(System.out::println);

// "aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2"