Java 8簡明教程

importnew發表於2014-03-22

　　“Java並沒有沒落，人們很快就會發現這一點”

　　歡迎閱讀我編寫的Java 8介紹。本教程將帶領你一步一步地認識這門語言的新特性。通過簡單明瞭的程式碼示例，你將會學習到如何使用預設介面方法，Lambda表示式，方法引用和重複註解。看完這篇教程後，你還將對最新推出的API有一定的瞭解，例如：流控制，函式式介面，map擴充套件和新的時間日期API等等。

　　允許在介面中有預設方法實現

　　Java 8 允許我們使用default關鍵字，為介面宣告新增非抽象的方法實現。這個特性又被稱為擴充套件方法。下面是我們的第一個例子：

interface Formula {
    double calculate(int a);

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

　　在介面Formula中，除了抽象方法caculate以外，還定義了一個預設方法sqrt。Formula的實現類只需要實現抽象方法caculate就可以了。預設方法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物件以匿名物件的形式實現了Formula介面。程式碼很囉嗦：用了6行程式碼才實現了一個簡單的計算功能：a*100開平方根。我們在下一節會看到，Java 8 還有一種更加優美的方法，能夠實現包含單個函式的物件。

　　Lambda表示式

　　讓我們從最簡單的例子開始，來學習如何對一個string列表進行排序。我們首先使用Java 8之前的方法來實現：

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介面作為輸入引數，Comparator的實現類可以對輸入的list中的元素進行比較。通常情況下，你可以直接用建立匿名Comparator物件，並把它作為引數傳遞給sort方法。

　　除了建立匿名物件以外，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表示式的威力吧。

　　函式式介面

　　Lambda表示式如何匹配Java的型別系統？每一個lambda都能夠通過一個特定的介面，與一個給定的型別進行匹配。一個所謂的函式式介面必須要有且僅有一個抽象方法宣告。每個與之對應的lambda表示式必須要與抽象方法的宣告相匹配。由於預設方法不是抽象的，因此你可以在你的函式式介面裡任意新增預設方法。

　　任意只包含一個抽象方法的介面，我們都可以用來做成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

　　注意，如果你不寫@FunctionalInterface 標註，程式也是正確的。

　　方法和建構函式引用

　　上面的程式碼例項可以通過靜態方法引用，使之更加簡潔：

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"

　　讓我們看看如何使用::關鍵字引用建構函式。首先我們定義一個示例bean，包含不同的構造方法：

class Person {
    String firstName;
    String lastName;

    Person() {}

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

　　接下來，我們定義一個person工廠介面，用來建立新的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的範圍

　　對於lambdab表示式外部的變數，其訪問許可權的粒度與匿名物件的方式非常類似。你能夠訪問區域性對應的外部區域的區域性final變數，以及成員變數和靜態變數。

　　訪問區域性變數

　　我們可以訪問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;

　　在lambda表示式內部企圖改變num的值也是不允許的。

　　訪問成員變數和靜態變數

　　與區域性變數不同，我們在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，該方法能夠訪問formula所有的物件例項，包括匿名物件。這個對lambda表示式來講則無效。

　　預設方法無法在lambda表示式內部被訪問。因此下面的程式碼是無法通過編譯的：

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

　　內建函式式介面

　　JDK 1.8 API中包含了很多內建的函式式介面。有些是在以前版本的Java中大家耳熟能詳的，例如Comparator介面，或者Runnable介面。對這些現成的介面進行實現，可以通過@FunctionalInterface 標註來啟用Lambda功能支援。

　　此外，Java 8 API 還提供了很多新的函式式介面，來降低程式設計師的工作負擔。有些新的介面已經在Google Guava庫中很有名了。如果你對這些庫很熟的話，你甚至閉上眼睛都能夠想到，這些介面在類庫的實現過程中起了多麼大的作用。

　　Predicates

　　Predicate是一個布林型別的函式，該函式只有一個輸入引數。Predicate介面包含了多種預設方法，用於處理複雜的邏輯動詞（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

　　Function介面接收一個引數，並返回單一的結果。預設方法可以將多個函式串在一起（compse, andThen）

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

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

　　Suppliers

　　Supplier介面產生一個給定型別的結果。與Function不同的是，Supplier沒有輸入引數。

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

　　Consumers

　　Consumer代表了在一個輸入引數上需要進行的操作。

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

　　Comparators

　　Comparator介面在早期的Java版本中非常著名。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

　　Optional不是一個函式式介面，而是一個精巧的工具介面，用來防止NullPointerEception產生。這個概念在下一節會顯得很重要，所以我們在這裡快速地瀏覽一下Optional的工作原理。

　　Optional是一個簡單的值容器，這個值可以是null，也可以是non-null。考慮到一個方法可能會返回一個non-null的值，也可能返回一個空值。為了不直接返回null，我們在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操作可以是中間操作，也可以是完結操作。完結操作會返回一個某種型別的值，而中間操作會返回流物件本身，並且你可以通過多次呼叫同一個流操作方法來將操作結果串起來（就像StringBuffer的append方法一樣————譯者注）。Stream是在一個源的基礎上建立出來的，例如java.util.Collection中的list或者set（map不能作為Stream的源）。Stream操作往往可以通過順序或者並行兩種方式來執行。

　　我們先了解一下序列流。首先，我們通過string型別的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");

　　Java 8中的Collections類的功能已經有所增強，你可以之直接通過呼叫Collections.stream()或者Collection.parallelStream()方法來建立一個流物件。下面的章節會解釋這個最常用的操作。

　　Filter

　　Filter接受一個predicate介面型別的變數，並將所有流物件中的元素進行過濾。該操作是一箇中間操作，因此它允許我們在返回結果的基礎上再進行其他的流操作（forEach）。ForEach接受一個function介面型別的變數，用來執行對每一個元素的操作。ForEach是一箇中止操作。它不返回流，所以我們不能再呼叫其他的流操作。

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只是建立一個流物件排序的檢視，而不會改變原來集合中元素的順序。原來string集合中的元素順序是沒有改變的。

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

　　Map

　　map是一個對於流物件的中間操作，通過給定的方法，它能夠把流物件中的每一個元素對應到另外一個物件上。下面的例子就演示瞭如何把每個string都轉換成大寫的string. 不但如此，你還可以把每一種物件對映成為其他型別。對於帶泛型結果的流物件，具體的型別還要由傳遞給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型別的結果。

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());
}

　　現在，我們測量一下對這個集合進行排序所使用的時間。

　　順序排序

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

　　如你所見，所有的程式碼段幾乎都相同，唯一的不同就是把stream()改成了parallelStream(), 結果並行排序快了50%。

　　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避免我們將null寫入；forEach接受一個消費者物件，從而將操作實施到每一個map中的值上。

　　下面的這個例子展示瞭如何使用函式來計算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值時，如何把一個例項從對應的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

　　合併操作先看map中是否沒有特定的key/value存在，如果是，則把key/value存入map，否則merging函式就會被呼叫，對現有的數值進行修改。

　　時間日期API

　　Java 8 包含了全新的時間日期API，這些功能都放在了java.time包下。新的時間日期API是基於Joda-Time庫開發的，但是也不盡相同。下面的例子就涵蓋了大多數新的API的重要部分。

　　Clock

　　Clock提供了對當前時間和日期的訪問功能。Clock是對當前時區敏感的，並可用於替代System.currentTimeMillis()方法來獲取當前的毫秒時間。當前時間線上的時刻可以用Instance類來表示。Instance也能夠用於建立原先的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

　　本地時間類表示一個沒有指定時區的時間，例如，10 p.m.或者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<span style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; font-size: 13px; line-height: 19px;">Parsing a LocalDate from a string is just as simple as parsing a LocalTime:</span>

　　解析字串並形成LocalDate物件，這個操作和解析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的工作原理相同。我們可以通過呼叫方法來獲取日期時間物件中特定的資料域。

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

　　如果再加上的時區資訊，LocalDateTime能夠被轉換成Instance例項。Instance能夠被轉換成以前的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

　　格式化日期-時間物件就和格式化日期物件或者時間物件一樣。除了使用預定義的格式以外，我們還可以建立自定義的格式化物件，然後匹配我們自定義的格式。

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();
}

　　只要在前面加上註解名：@Repeatable，Java 8 允許我們對同一型別使用多重註解，

　　變體1：使用註解容器（老方法）

@Hints({@Hint("hint1"), @Hint("hint2")})
class Person {}

　　變體2：使用可重複註解（新方法）

@Hint("hint1")
@Hint("hint2")
class Person {}

　　使用變體2，Java編譯器能夠在內部自動對@Hint進行設定。這對於通過反射來讀取註解資訊來說，是非常重要的。

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

　　儘管我們絕對不會在Person類上宣告@Hints註解，但是它的資訊仍然可以通過getAnnotation(Hints.class)來讀取。並且，getAnnotationsByType方法會更方便，因為它賦予了所有@Hints註解標註的方法直接的訪問許可權。

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

　　先到這裡

　　我的Java 8程式設計指南就到此告一段落。當然，還有很多內容需要進一步研究和說明。這就需要靠讀者您來對JDK 8進行探究了，例如：Arrays.parallelSort, StampedLock和CompletableFuture等等 ———— 我這裡只是舉幾個例子而已。

　　我希望這個博文能夠對您有所幫助，也希望您閱讀愉快。完整的教程原始碼放在了GitHub上。您可以盡情地fork，並請通過Twitter告訴我您的反饋。

　　原文連結： winterbe 翻譯： ImportNew.com - 黃小非

Java 8 簡明教程
2015-11-22
Java
簡明 docker 教程
2019-01-20
Docker
Java基礎系列-Java8 Stream 簡明教程
2019-11-23
Java
簡明 Python 教程
2014-05-18
Python
Java 8 教程
2019-04-03
Java
Java 8教程
2014-03-19
Java
GitBook簡明安裝教程
2022-02-12
Git
簡明 MongoDB 入門教程
2017-08-08
MongoDB
簡明Python 教程 --模組
2006-12-21
Python
最簡明的Shiro教程
2020-03-22
《簡明 PHP 教程》00 開篇
2018-08-23
PHP
《簡明 PHP 教程》04 基礎
2018-08-31
PHP
《簡明 PHP 教程》02 安裝
2018-08-28
PHP
Raspberry Pi 3簡明配置教程
2018-03-27
iOS Core Animation 簡明系列教程
2016-05-11
iOS
《簡明 PHP 教程》01 關於 PHP
2018-08-26
PHP
Redux 莞式教程之簡明篇
2016-08-24
Redux
哪有簡明python教程下載？
2017-08-04
Python
Java 8 CompletableFuture 教程
2019-01-19
Java
《簡明 PHP 教程》03 第一步
2018-08-29
PHP
《MySQL 8 DBA基礎教程》簡介
2022-07-01
MySql
Java NIO 簡明教程系列
2018-09-17
Java
Java泛型簡明教程
2015-02-06
Java泛型
簡明Python3教程 1.介紹
2013-01-03
Python
【譯】Java8官方教程：Java技術概述
2019-05-09
Java
WCF簡單教程(8)安全-Windows認證
2017-11-09
Windows
Java Servlet和JSP教程（8）(轉)
2007-08-11
JavaServletJS
最簡明扼要的 Systemd 教程，只需十分鐘
2016-01-14
Java 8 ArrayList 原始碼簡單分析
2020-03-09
Java原始碼
A byte of Python的中文譯本《簡明Python教程》
2009-04-15
Python
【譯】Java NIO 簡明教程系列之 NIO 簡介
2018-09-17
Java
簡析JAVA8函式式介面
2021-04-27
Java函式
Java IO8：IO簡單總結
2015-10-20
Java
Java 8 的 Nashorn 指令碼引擎教程
2016-12-14
Java指令碼
一條資料HBase之旅，簡明HBase入門教程開篇
2018-06-15
全面梳理簡明安裝指南 mysql 8 安裝升級與配置
2020-04-09
MySql
【譯】Java NIO 簡明教程系列之 Channel
2018-10-13
Java
簡明高效的 Java 併發程式設計學習指南
2019-03-01
Java程式設計

Java 8簡明教程

“Java並沒有沒落，人們很快就會發現這一點”

允許在介面中有預設方法實現

Lambda表示式

函式式介面

方法和建構函式引用

Lambda的範圍

訪問區域性變數

訪問成員變數和靜態變數

訪問預設介面方法

內建函式式介面

Predicates

Functions

Suppliers

Consumers

Comparators

Optionals

Streams

Filter

Sorted

Map

Match

Count

Reduce

Parallel Streams

順序排序

並行排序

Map

時間日期API

Clock

Timezones

LocalTime

LocalDate

LocalDateTime

Annotations

先到這裡

相關文章

　　“Java並沒有沒落，人們很快就會發現這一點”

　　允許在介面中有預設方法實現

　　Lambda表示式

　　函式式介面

　　方法和建構函式引用

　　Lambda的範圍

　　訪問區域性變數

　　訪問成員變數和靜態變數

　　訪問預設介面方法

　　內建函式式介面

　　Predicates

　　Functions

　　Suppliers

　　Consumers

　　Comparators

　　Optionals

　　Streams

　　Filter

　　Sorted

　　Map

　　Match

　　Count

　　Reduce

　　Parallel Streams

　　順序排序

　　並行排序

　　Map

　　時間日期API

　　Clock

　　Timezones

　　LocalTime

　　LocalDate

　　LocalDateTime

　　Annotations

　　先到這裡