Java 8 再不知道就老了

Java 8 特性介绍

1.简介

毫无疑问，Java 8是自Java 5（2004年）发布以来Java语言最大的一次版本升级，如果不学习，你会怀疑自己面前的代码是不是Java。Java 8带来了很多的新特性，比如编译器、类库、开发工具和JVM（Java虚拟机），但最最主要的还是函数式编程。接下来将会结合代码去展示Java 8的新特性。

下面主要介绍Java 8的最显著特性：

接口增强

Lambda编程

函数式接口

Stream

Annotations

接口增强

Java 8允许我们在方法前使用default关键字在接口中加入一个具体的方法。

interface Formula {
    double calculate(int a);    
    default double sqrt(int a) {
        return Math.sqrt(a);
    }
    static int positive(int a) {
        return a > 0 ? a : 0;
    }
}

在实现Formula接口的时候只需实现calculate即可（当然也可以重写sqrt方法）

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

formula.calculate(100);     // 100.0
formula.sqrt(16);           // 4.0
Formula.positive(-4);        // 0.0

关键字default定义的方法不可以直接通过接口类名调用

Formula.sqrt(100);

必须通过实例化的接口对象调用。接口在加入这个特性后非常像抽象类，也就是说我们可以在接口中实现模板模式。

与此同时，Java 8还允许我们在接口中添加一个静态方法，如上例的positive方法。

Lambda 表达式

Java 8中最大的特性应该就是加入了函数式编程，那么函数式编程语言是什么？函数式编程语言的核心是它以处理数据的方式处理代码

我们看一个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);
    }
});

我们经常像这个代码一样写一些匿名内部类。在Java 8你可以通过Lambda来代替这种编程

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

Lambda的基本形式是()->，->左面是入参，可以为空，->右面是具体的执行，可以写多行，但需要使用{}，这样我们就把一段代码写入了函数的参数

我们以后就可以这样开一个Thread了

Thread t = new Thread(
    () -> System.out.println("Hello"););

Lambda函数的作用域

既然我们上面说到了Lambda表达式和匿名内部类很像，那么使用参数的作用域也是如此，在Lambda中可以使用类的成员函数或者static变量，有点稍稍不同的是，如果使用方法中的变量在内部类中必须使用定义为final的变量，Lambda没有明确要求变量必须使用final定义，但该变量不能更改（其实只是不需要final的final），所以下面最后一行代码会导致出错。

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

函数式接口

函数式接口的目的是为了使Lambda表达式更好的融入Java，那我们先看看什么是函数式接口，如果一个接口只包含一个抽象的方法，那么该接口成为函数式接口，同时提供一个新的注解@FunctionalInterface，这个注解不是必须的，如果满足条件不加@FunctionalInterface也会被虚拟机翻译为函数式接口，若增加@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

default方法不能使用Lambda表达式。

同时Java 8自带了很多函数式接口，例如Comparator和Runnable，同时还加入了很多很好用的函数式接口

Predicates

Predicate提供一个单参数返回值为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

Function

Suppliers

Suppliers提供一个无参的方法，返回值为定义的泛型

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

Consumers

而Consumers则是提供一个一个参数的void函数

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

Comparators

在以往的Java中这个借口还是很常见的，现在的Comparator增加了很多的default和static方法。

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不是函数式接口但是是一个很实用的final类，Optional主要针对函数时而返回值时而返回null的时候，比如我们在Map.get的时候或者调用网络接口都是这样的使用场景

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"

方法或构造函数引用

方法引用

Java 8引入::关键字使得我们对类中的方法和构造函数的使用增加了一种方式。上面的例子可以这么改写

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

上面我们通过::引用了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"

构造方法引用

我们来看构造方法如何使用

class Person {
    String firstName;
    String lastName;

    Person() {}

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

再创建一个工厂类用于创建

interface PersonFactory<P extends Person> {
    P create(String firstName, String lastName);
}

我们不需要实现该工厂，只需要传递引用

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

而且我们不需要指定参数，Java编译器会根据构造函数的方法签名去匹配正确的构造函数。

Stream

Steam适用在集合数据处理，Java 8在java.util.Collection中的List和Set（Map并不直接提供）。

Steam存在两组重要的概念中间操作和终止操作和并行和串行

中间操作和终止操作是指根据对Stream流操作的结果而言，如果是中间操作那么将会返回Stream，以便接下来继续操作，而终止操作则是返回最终的操作结果，不能再对Stream操作。可以看到，有了Stream我们可以轻松对集合进行一系列的复杂操作，而且我们只需要写一行代码。类似于pipeline功能。

串行和并行

先创建一个List

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");

Collections在Java 8提供了创建Stream的方法，Collection.stream()-串行流和Collection.parallelStream()-并行流

中间操作和终止操作

• Filter

顾名思义，Filter可以为我们提供过滤功能，这是一个中间操作，我们可以设置我们需要的过滤规则。

• ForEach

还是顾名思义，也就是循环遍历Stream中的元素，显然这是一个终止操作。

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

// "aaa2", "aaa1"

• Sorted

Sorted是一个中间操作，可以接受Comparator参数，如果不传参将会默认使用字典顺序。

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

// "aaa1", "aaa2"

同时中间操作都不会改变原集合，也就是Java 8为中间操作重新分配了内存。

System.out.println(stringCollection);
// ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1

并行的优势

上面的例子我们都是串行，我们通过一个例子来看一下并行操作能带来的性能提升

int max = 1000000;
List<String> values = new ArrayList<>(max);
for (int i = 0; i < max; i++) {
    UUID uuid = UUID.randomUUID();
    values.add(uuid.toString());
}

串行操作

long t0 = System.nanoTime();

long count = values.stream().sorted().count();
System.out.println(count);

long t1 = System.nanoTime();

long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("sequential sort took: %d ms", millis));

// sequential sort took: 899 ms

并行操作

long t0 = System.nanoTime();

long count = values.parallelStream().sorted().count();
System.out.println(count);

long t1 = System.nanoTime();

long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("parallel sort took: %d ms", millis));

// parallel sort took: 472 ms

当然，具体性能的提升跟你的电脑性能有关，但是很明显并行给我们带来的不仅仅是性能的提升，如果我们在Java 8之前操作，我们必然要考虑多线程执行时候的同步问题吧，就拿上例来说，我们如果使用3个线程操作，那么三个线程需要从集合中取不同的数据，然后对中间结果sum的使用的时候我们需要保证操作的原子性。现在Java 8只需要一个方法，迅速摆脱烦恼啊！

Map

Map虽然没有直接提供Stream方法，但是我们可以创建Map中key，value，entrySet的Stream

同时Map提供了很多非常使用的方法

• forEach

顾名思义是用来遍历的

Map<Integer, String> map = new HashMap<>();

for (int i = 0; i < 10; i++) {
    map.putIfAbsent(i, "val" + i);
}

map.forEach((id, val) -> System.out.println(val));

• putIfAbsent & computeIfPresent

顾名思义第一个如果该key为null则插入。第二个是如果存在就计算

map.computeIfPresent(3, (num, val) -> val + num);
map.get(3);             // val33

map.computeIfPresent(9, (num, val) -> null);
map.containsKey(9);     // false

map.computeIfAbsent(23, num -> "val" + num);
map.containsKey(23);    // true

map.computeIfAbsent(3, num -> "bam");
map.get(3);             // val33

• getOrDefault

顾名思义，根据key获取，如果不存在则使用默认值

map.getOrDefault(42, "not found");  // not found

Annotations

注解在Java 8是可以重复的。只需要使用注解@Repeatable

@Retention(RetentionPolicy.RUNTIME) 
@interface Annots {
    Annot[] value();
} 
@Retention(RetentionPolicy.RUNTIME) 
@Repeatable(Annots.class)
@interface Annot {
    String value();
}
@Annot("a1")@Annot("a2")
public class Test {
    public static void main(String[] args) {
        Annots annots1 = Test.class.getAnnotation(Annots.class);
        System.out.println(annots1.value()[0]+","+annots1.value()[1]); 
        // @Annot(value=a1),@Annot(value=a2)
        Annot[] annots2 = Test.class.getAnnotationsByType(Annot.class);
        System.out.println(annots2[0]+","+annots2[1]); 
        // @Annot(value=a1),@Annot(value=a2)
        Annot annot1 = Test.class.getAnnotation(Annot.class);
        System.out.println(annots1);
        //null 
    }
}

注释 Annot 被 @Repeatable( Annots.class ) 注解。Annots 只是一个容器，它包含 Annot 数组, 编译器尽力向程序员隐藏它的存在。通过这样的方式，Test 类可以被 Annot 注解两次。重复注释的类型可以通过 getAnnotationsByType() 方法来返回。

Java 8剩余的特性

除了上述Java 8带来的很显著的变化。Java 8当然还有一些其他的特性：

• Date

API 如果你被Date类恶心过，那么你一定很期待Java 8给你带来的全新感受

• JVM

元空间（Metaspace）：一个新的内存空间的诞生

• Concurrency

Java 8

concurrentForkJoinPool类添加了新的方法来支持通用线程池操作。同时Java 8还添加了新的java.util.concurrent.locks.StampedLock类，用于支持基于容量的锁——该锁有三个模型用于支持读写操作（可以把这个锁当做是java.util.concurrent.locks.ReadWriteLock的替代者）