Java并无衰落.你们对它的认识才刚刚开始 Java8全新出发

Java并无衰落.你们对它的认识才刚刚开始

很高兴能在此给你们分享Java8的新特性。这篇文章将一步一步带你了解Java8的全部新特性。我将经过简单的实例代码向你们展现接口中默认方法，lambda 表达式,方法引用,重复注解的使用. 看过这篇文章以后你将了解流、函数、接口、map扩展、日期中的新变化.不废话，放码过来!

Default Methods for Interfaces(接口中的默认方法)

Java 8准许咱们在接口中增长一个经过default关键字修饰的非抽象的方法. 这个特性被咱们称为扩展方法. 下面举例说明:

interface Formula {
    double calculate(int a);

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

接口Formula 中除了抽象方法calculate 其中还定义了非抽象方法sqrt. 实现类里面继承了抽象方法calculate. 而默认方法能够直接调用.

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是一个继承Formula 接口的匿名对象. 实例代码十分详细: 仅仅6行代码实现了一个简单的 sqrt(a * 100)计算. 在接下来的章节, 将给你们介绍更加完善的方案实现单个方法对象在Java8中的使用.

Lambda expressions(Lambda表达式)

经过下面实例向你们展现怎么在以前版本中对List中的String排序:

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和compare来对每一个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编译器可以自动识别参数类型因此你可以省略它们. 让咱们更深刻的了解lambda 表达式在java中更普遍的应用.

Functional Interfaces(函数化接口)

lambda表达式怎么去匹配Java类型呢? 每个lambda表达式至关于指定一个接口的类型. 一个必须定义一个抽线的方法的函数接口. 每个lambda表达式类型都将和这个抽象方法匹配.因为默认方法并非抽象方法，因此你能够自由的添加默认方法到你的函数接口中.

咱们可以使用任意接口做为lambda表达式,这个接口中只须要包含一个抽象的方法就能够了. 为了确保你的接口知足需求，你须要在你接口上添加一个@FunctionalInterface注解.当你使用这个注解以后，这个接口只能定义一个抽象方法，否者编译器会报错 .
Example:

@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

注意@FunctionalInterface也是有效代码.

Method and Constructor References(方法和构造器的引用)

上面的代码能够经过静态方法应用能够更加简洁:

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

Java 8可以传递一个方法或者构造器引用经过 ::关键字. 上面的实例向大家展现了怎么去引用一个静态方法. 咱们也可以引用一个普通对象方法:

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"

让咱们来看看::是怎么引用构造器的的. 首先咱们定义两个构造器在一个javabean中:

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 Scopes(Lambda 的做用域)

从 lambda表达式访问局部变量和匿名对象是类似的.你能够访问final修饰的局部变量也可以访问实例化局部属性和静态变量.

Accessing local variables(访问本地变量)

lambda 表达式可以从局部读取一个的final修饰的局部变量:

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

stringConverter.convert(2);     // 3

和匿名对象不一样的是，在匿名对象中变量num并不须要用 final修饰. 也能正常调用:

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

stringConverter.convert(2);     // 3

然而num必须隐式使用final修饰才能编译. 下面代码就不会编译:

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

把num 写到lambda表达式内也是被禁止的.

Accessing fields and static variables(访问属性和静态变量)

与局部变量相比咱们在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);
        };
    }
}

Accessing Default Interface Methods(访问默认的接口方法)

还记得第一个 formula 的实例嘛? 接口Formula定义一个默认的方法 sqrt，它可以被每一个formula实例包括匿名对象访问. 它却不适合lambda 表达式.

lambda表达式不能访问接口的默认方法. 下面代码不能编译经过:

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

Built-in Functional Interfaces(内置函数)

DK 1.8 API包含了许多内置函数. 它们中不少在老版本中是你们很熟悉的,像 Comparator 和Runnable. 这些接口经过 添加@FunctionalInterface注解来支持Lambda表达式.

可是Java 8 API 也添加了不少新接口使编程变的更加容易 . 这些新的函数不少是借鉴被你们所熟知的 Google Guava 函数库.即便你很熟悉这些函数库,你也须要关注这些方法是怎么在接口中扩展的以及它们怎么使用.

Predicates( 判断)
判断是传递一个参数返回一个布尔值. 这个接口包含各类默认的方法组成复杂的逻辑判断单元 (and, or, negate)

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(函数)

函数接收一个参数返回一个结果. 默认方法可以链式调用 (compose, andThen).

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

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

Suppliers(生产者)

Suppliers返回一个给定的泛型类型的结果. 不像函数, 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在老版本中你们都比较熟悉. Java 8 为这个接口增长了几种默认的方法.

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 并非一个函数接口, 相反的它的做用就是避免出现空指针异常.它是一个很重要的概念对以一部分,然咱们来快速了解它.

Optional是一个简单的容器里面包含有空或者非空的值.想象一下若是有一个方法可以返回一个空或者一个非空的值 . 在Java8中你能够经过返回一个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操做能够包括对中间部分或者终端部分进行操做. 终端操做可以返回一个肯定的类型, 中间操做能返回流的自己你可以经过多种方法调用某一行. Streams 能够经过一个源来建立, 例如. 像 java.util.Collection中的lists 或 sets (maps 不支持)均可以建立流. Stream 可以串行操做也能并行操做.

首先看下流怎么进行序列操做. 咱们先经过一个包含字符串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");

在Java8中Collections已经继承了streams ，因此你可以经过in Java 8 are extended so you can simply create 调用Collection.stream() 和 Collection.parallelStream()来建立流.下面将给你介绍大部分流的操做 .

Filter(过滤)
Filter接收一个判断用来过滤流中的全部元素. 这个操做是中间操做，它可以使咱们对结果进行另外一个流操做(forEach) . ForEach接受一个consumer操做对每个过滤的流元素中. ForEach是一个终端操做. 它返回值void,因此咱们不能调用另外一个函数操做.

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"

注意 sorted 仅仅是建立一个排序后的视图操做，并无操做排序返回的集合. 排序的 stringCollection并无受到影响:

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

Map(映射)
中间操做 map转换每一个元素到另外一个元素中经过给定的函数.下面的实例是把把每个字符串转换成大写.你也可使用map转换每一个对象的类型. 泛型流依赖你传递给map的泛型函数.

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

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

Match(匹配)
可使用各类匹配操做来肯定是不是肯定的流. 全部这些操做是终端操做并返回一个布尔值.

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是一个终端操做返回流中元素的个数.

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

System.out.println(startsWithB);    // 3
Reduce(合并)

这个终端操做完成一个流中元素合并操做经过给定的函数.返回的结果经过 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"
Parallel Streams(并行流)

上文提到过流能够是串行的也能够是并行的. 串行的序列操做是单线程的,而并行流是在多个线程上进行操做.

下面的实例向你展现经过并行流增长性能.

首先建立一个元素出现次数惟一的大的List:

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

如今测试它的排序所消耗的时间.

Sequential Sort(串行排序)
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
Parallel Sort(并行排序)
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

你能看到上述代码基本相同的,可是并行大约快了50%.你能够测试着用 parallelStream()操做代替stream().

Map(映射)
上文提到map并不支持流操做. 可是新的map支持各类新方法和常见的任务操做.

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方法对传统的非空检验 ; forEach 方法遍历map中每个值进行consumer操做.

这个实例展现了怎么利用函数在map上进行操做:

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

下一步,咱们学习怎么给定一个key怎么移除对象操做, 如今加入给一个键值对:

map.remove(3, "val3");
map.get(3);             // val33

map.remove(3, "val33");
map.get(3);             // null

另外一个有用的方法:

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

map中合并对象操做很容易:

map.merge(9, "val9", (value, newValue) -> value.concat(newValue));
map.get(9);             // val9

map.merge(9, "concat", (value, newValue) -> value.concat(newValue));
map.get(9);             // val9concat

合并操做若是键值对不存在就添加到里面, 合并操做也能够用来改变存在的值.

Date API(日期API)

Java 8 包含一个全新的日期和时间操做API在 java.time包里面. 新的Date API 能够和 Joda-Time 包相媲美, 不过，它们并不同. 下面给你实例一下新日期里面主要新的API.

Clock(时钟)

时钟提供了访问如今的日期和时间的方法. 时钟意思到时区将可能替代 System.currentTimeMillis() 来获取如今的毫秒数. 这样一个瞬时点在时间线上用类 Instant来表明.代替可以被使用的java.util.Date 传统对象.

Clock clock = Clock.systemDefaultZone();
long millis = clock.millis();

Instant instant = clock.instant();
Date legacyDate = Date.from(instant);   // legacy java.util.Date

Timezones(时区)
时区被ZoneId代替. 你能够很方便的访问经过一个静态的工厂方法. 时区定义一个弥补了一个重要在瞬时和本地时间和日期上的转换.

System.out.println(ZoneId.getAvailableZoneIds());
// prints all available timezone ids

ZoneId zone1 = ZoneId.of("Europe/Berlin");
ZoneId zone2 = ZoneId.of("Brazil/East");
System.out.println(zone1.getRules());
System.out.println(zone2.getRules());

// ZoneRules[currentStandardOffset=+01:00]
// ZoneRules[currentStandardOffset=-03:00]
LocalTime(本地时间)

本地时间表明一个不包含时区的时间, 例如. 10pm 或者 17:30:15. 下面两个实例建立两个本地时间包含上面定义的时区. 而后咱们比较两个时间和日历在小时和分钟的不一样之处.

LocalTime now1 = LocalTime.now(zone1);
LocalTime now2 = LocalTime.now(zone2);

System.out.println(now1.isBefore(now2));  // false

long hoursBetween = ChronoUnit.HOURS.between(now1, now2);
long minutesBetween = ChronoUnit.MINUTES.between(now1, now2);

System.out.println(hoursBetween);       // -3
System.out.println(minutesBetween);     // -239

LocalTime能够从各类工厂方法简单的建立新实例, 包含格式化的字符串.

LocalTime late = LocalTime.of(23, 59, 59);
System.out.println(late);       // 23:59:59

DateTimeFormatter germanFormatter =
    DateTimeFormatter
        .ofLocalizedTime(FormatStyle.SHORT)
        .withLocale(Locale.GERMAN);

LocalTime leetTime = LocalTime.parse("13:37", germanFormatter);
System.out.println(leetTime);   // 13:37

LocalDate(本地日期)
本地日期表明了清晰的日期 , 例如. 2014-03-11. 它是不可更改的彻底模拟LocalTime. 这个简单的实例展现怎么计算新的日期经过增长或者减去天、月、或者年. 注意每一个操纵返回一个新的实例.

LocalDate today = LocalDate.now();
LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS);
LocalDate yesterday = tomorrow.minusDays(2);

LocalDate independenceDay = LocalDate.of(2014, Month.JULY, 4);
DayOfWeek dayOfWeek = independenceDay.getDayOfWeek();
System.out.println(dayOfWeek);    // FRIDAY

经过一个字符串解析LocalDate from 和解析LocalTime同样简单:

DateTimeFormatter germanFormatter =
    DateTimeFormatter
        .ofLocalizedDate(FormatStyle.MEDIUM)
        .withLocale(Locale.GERMAN);

LocalDate xmas = LocalDate.parse("24.12.2014", germanFormatter);
System.out.println(xmas);   // 2014-12-24

LocalDateTime(本地日期时间)
LocalDateTime表明一个日期时间. 它是上例时间和日期的一个组合. LocalDateTime也是不可变的,它工做原理和 LocalTime、LocalDate工做原理同样.咱们可以利用方法获取一个属性从date-time:

LocalDateTime sylvester = LocalDateTime.of(2014, Month.DECEMBER, 31, 23, 59, 59);

DayOfWeek dayOfWeek = sylvester.getDayOfWeek();
System.out.println(dayOfWeek);      // WEDNESDAY

Month month = sylvester.getMonth();
System.out.println(month);          // DECEMBER

long minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY);
System.out.println(minuteOfDay);    // 1439

传统的 timezone 可以转换成一个 instant. Instants 也可以很轻松转换成一个传统的java.util.Date.

Instant instant = sylvester
        .atZone(ZoneId.systemDefault())
        .toInstant();

Date legacyDate = Date.from(instant);
System.out.println(legacyDate);     // Wed Dec 31 23:59:59 CET 2014

格式化date-times 就是格式化dates 和 times同样.咱们也可使用预先定义的格式才建立定制的格式 .

DateTimeFormatter formatter =
    DateTimeFormatter
        .ofPattern("MMM dd, yyyy - HH:mm");

LocalDateTime parsed = LocalDateTime.parse("Nov 03, 2014 - 07:13", formatter);
String string = formatter.format(parsed);
System.out.println(string);     // Nov 03, 2014 - 07:13

不像java.text.NumberFormat 新的 DateTimeFormatter是不可修改的且线程安全的.

Annotations(注解)

注解在Java 8中可重复使用.让咱们经过实例来深刻了解.

首先, 咱们定义一个包装注解,它包含一个实际的注解数组:

@interface Hints {
    Hint[] value();
}

@Repeatable(Hints.class)
@interface Hint {
    String value();
}

Java 8使咱们可以使用同样的注解经过@Repeatable注解定义.

Variant 1: 使用容器注解(old school)
@Hints({@Hint("hint1"), @Hint("hint2")})
class Person {}
Variant 2: 使用重复注解(new school)
@Hint("hint1")
@Hint("hint2")
class Person {}

使用variant 2java编译器会隐式的设置 一个@Hints注解. 这个是很重要的经过反射读取注解信息.

Hint hint = Person.class.getAnnotation(Hint.class);
System.out.println(hint);                   // null

Hints hints1 = Person.class.getAnnotation(Hints.class);
System.out.println(hints1.value().length);  // 2

Hint[] hints2 = Person.class.getAnnotationsByType(Hint.class);
System.out.println(hints2.length);          // 2

虽然咱们历来没有定义 @Hints注解在 Person 类上,它一直能获取到经过 getAnnotation(Hints.class). 然而,这里有更方便的方法getAnnotationsByType它可以直接访问全部的 @Hint 注解.

此外使用Java8注解是扩展的两个新的目标:

@Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
@interface MyAnnotation {}

个人Java 8新特征实例到此结束. 若是你想学习 JDK 8 API全部新特性和类, 能够关注公众号：程序零世界 它帮你了解全部的新类和一些隐藏的新特性在 JDK 8,像 Arrays.parallelSort, StampedLock 和CompletableFuture等等.

我但愿个人这篇文章可以帮助你,同时也但愿你读后有所收获.你也能够经过公众号：程序零世界 向我反馈意见.