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等等.

我但願個人這篇文章可以幫助你,同時也但願你讀後有所收穫.你也能夠經過公衆號：程序零世界 向我反饋意見.