摘要：雖然目前工作環(huán)境仍然以為主，不過(guò)目前已是大勢(shì)所趨了。標(biāo)準(zhǔn)函數(shù)式接口新的包定義旨在使用的廣泛函數(shù)式接口。這一改進(jìn)使得擁有了類似于多繼承的能力。

從Java8發(fā)布到現(xiàn)在有好幾年了,而Java9也提上發(fā)布日程了(沒(méi)記錯(cuò)的話好像就是這個(gè)月2017年7月，也許會(huì)再度跳票吧，不過(guò)沒(méi)關(guān)系，穩(wěn)定大于一切，穩(wěn)定了再發(fā)布也行)，現(xiàn)在才開(kāi)始去真正學(xué)習(xí)，說(shuō)來(lái)也是慚愧。雖然目前工作環(huán)境仍然以Java6為主，不過(guò)Java8目前已是大勢(shì)所趨了。Java8帶來(lái)了許多令人激動(dòng)的新特性，如lambda表達(dá)式，StreamsAPI與并行集合計(jì)算，新的時(shí)間日期API(借鑒joda-time)，字節(jié)碼支持保存方法參數(shù)名(對(duì)于框架開(kāi)發(fā)真的是非常贊的一個(gè)特性),Optional類解決空指針問(wèn)題(雖然Guava中早就有這個(gè)了)等。

語(yǔ)法:

v->System.out.println(v)

(v)->System.out.println(v)

(String v)->System.out.println(v)

(v)->{System.out.println(v);return v+1;}

List numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
numbers.forEach((Integer value) -> System.out.println(value));

注意：lambda表達(dá)式內(nèi)如果引用了外部的局部變量，那么這個(gè)局部變量必須是final的，如果不是，編譯器會(huì)自動(dòng)給加上final。比如下面這段是錯(cuò)誤的

//這是錯(cuò)誤的
int num = 2;
Function stringConverter = (from) -> from * num;
num++;//會(huì)報(bào)錯(cuò)，因?yàn)榇藭r(shí)num已經(jīng)是final聲明的了
System.out.println(stringConverter.apply(3));

僅有一個(gè)抽象方法的接口(注：Java8之后接口也可以有非抽象方法，所以此處強(qiáng)調(diào)只有一個(gè)抽象方法的接口)

可選注解：@FunctionalInterface ， 作用：編譯器會(huì)檢查，javadoc文檔中會(huì)特別說(shuō)明。

這里需要強(qiáng)調(diào)的是，函數(shù)式接口只能有一個(gè)抽象方法，而不是指只能有一個(gè)方法。這分兩點(diǎn)來(lái)說(shuō)明。首先，在Java 8中，接口運(yùn)行存在實(shí)例方法（見(jiàn)默認(rèn)方法一節(jié)），其次任何被java.lang.Object實(shí)現(xiàn)的方法，都不能視為抽象方法，因此，下面的NonFunc接口不是函數(shù)式接口，因?yàn)閑quals()方法在java.lang.Object中已經(jīng)實(shí)現(xiàn)。

標(biāo)準(zhǔn)函數(shù)式接口
新的 java.util.function 包定義旨在使用 lambdas 的廣泛函數(shù)式接口。這些接口分為幾大類：

Function：接受一個(gè)參數(shù)，基于參數(shù)值返回結(jié)果

Predicate：接受一個(gè)參數(shù)，基于參數(shù)值返回一個(gè)布爾值

BiFunction：接受兩個(gè)參數(shù)，基于參數(shù)值返回結(jié)果

Supplier：不接受參數(shù)，返回一個(gè)結(jié)果

Consumer：接受一個(gè)參數(shù)，無(wú)結(jié)果 (void)

interface NonFunc {
boolean equals(Object obj);
}

同理，下面實(shí)現(xiàn)的IntHandler接口符合函數(shù)式接口要求，雖然看起來(lái)它不像，但實(shí)際上它是一個(gè)完全符合規(guī)范的函數(shù)式接口。

@FunctionalInterface
public static interface IntHandler{
    void handle(int i);
    boolean equals(Object obj);
}

在Java 8之前的版本，接口只能包含抽象方法，Java 8 對(duì)接口做了進(jìn)一步的增強(qiáng)。在接口中可以添加使用 default 關(guān)鍵字修飾的非抽象方法。還可以在接口中定義靜態(tài)方法。如今，接口看上去與抽象類的功能越來(lái)越類似了。這一改進(jìn)使得Java 8擁有了類似于多繼承的能力。一個(gè)對(duì)象實(shí)例，將擁有來(lái)自于多個(gè)不同接口的實(shí)例方法。
比如，對(duì)于接口IHorse，實(shí)現(xiàn)如下：

public interface IHorse{
    void eat();
    default void run(){
        System.out.println(“hourse run”);
    }
}

在Java 8中，使用default關(guān)鍵字，可以在接口內(nèi)定義實(shí)例方法。注意，這個(gè)方法是并非抽象方法，而是擁有特定邏輯的具體實(shí)例方法。

所有的動(dòng)物都能自由呼吸，所以，這里可以再定義一個(gè)IAnimal接口，它也包含一個(gè)默認(rèn)方法breath()。

public interface IAnimal {
  default void breath(){
      System.out.println(“breath”);
    }
}

騾是馬和驢的雜交物種，因此騾（Mule）可以實(shí)現(xiàn)為IHorse，同時(shí)騾也是動(dòng)物，因此有：

public class Mule implements IHorse,IAnimal{
    @Override
    public void eat() {
        System.out.println(“Mule eat”);
      }
    public static void main(String[] args) {
     Mule m=new Mule();
     m.run();
     m.breath();
      }
}

注意上述代碼中Mule實(shí)例同時(shí)擁有來(lái)自不同接口的實(shí)現(xiàn)方法。在這Java 8之前是做不到的。從某種程度上說(shuō)，這種模式可以彌補(bǔ)Java單一繼承的一些不便。但同時(shí)也要知道，它也將遇到和多繼承相同的問(wèn)題，如果IDonkey也存在一個(gè)默認(rèn)的run()方法，那么同時(shí)實(shí)現(xiàn)它們的Mule，就會(huì)不知所措，因?yàn)樗恢缿?yīng)該以哪個(gè)方法為準(zhǔn)。此時(shí)，由于IHorse和IDonkey擁有相同的默認(rèn)實(shí)例方法，故編譯器會(huì)拋出一個(gè)錯(cuò)誤：Duplicate default methods named run with the parameters () and () are inherited from the types IDonkey and IHorse

接口默認(rèn)實(shí)現(xiàn)對(duì)于整個(gè)函數(shù)式編程的流式表達(dá)式非常重要。比如，大家熟悉的java.util.Comparator接口，它在JDK 1.2時(shí)就已經(jīng)被引入。在Java 8中，Comparator接口新增了若干個(gè)默認(rèn)方法，用于多個(gè)比較器的整合。其中一個(gè)常用的默認(rèn)如下：

default Comparator thenComparing(Comparator other) {
  Objects.requireNonNull(other);
  return (Comparator & Serializable) (c1, c2) -> {
    int res = compare(c1, c2);
    return (res != 0) ? res : other.compare(c1, c2);
  };

}

有個(gè)這個(gè)默認(rèn)方法，在進(jìn)行排序時(shí)，我們就可以非常方便得進(jìn)行元素的多條件排序，比如，如下代碼構(gòu)造一個(gè)比較器，它先按照字符串長(zhǎng)度排序，繼而按照大小寫不敏感的字母順序排序。

Comparator cmp = Comparator.comparingInt(String::length)
.thenComparing(String.CASE_INSENSITIVE_ORDER);

在接口中，還允許定義靜態(tài)的方法。接口中的靜態(tài)方法可以直接用接口來(lái)調(diào)用。
例如，下面接口中定義了一個(gè)靜態(tài)方法 find，該方法可以直接用 StaticFunInterface .find() 來(lái)調(diào)用。

public interface StaticFunInterface {
public static int find(){
return 1;
}
}
public class TestStaticFun {
public static void main(String[] args){
//接口中定義了靜態(tài)方法 find 直接被調(diào)用
StaticFunInterface.fine();
}
}

說(shuō)明：雖然我知道了default方法是為了便于集合接口(新的StreamsAPI)向后兼容而設(shè)計(jì)的，但是這個(gè)接口靜態(tài)方法暫時(shí)還沒(méi)體會(huì)其作用，可能得接觸多了才會(huì)明白吧。

靜態(tài)方法引用：ClassName::methodName

實(shí)例上的實(shí)例方法引用：instanceReference::methodName (這里還可以使用this)

超類上的實(shí)例方法引用：super::methodName

類型上的實(shí)例方法引用：ClassName::methodName

構(gòu)造方法引用：Class::new

數(shù)組構(gòu)造方法引用：TypeName[]::new

public class InstanceMethodRef {
  public static void main(String[] args) {
    List users=new ArrayList();
    for(int i=1;i<10;i++){
      users.add(new User(i,”billy”+Integer.toString(i)));
    }
    users.stream().map(User::getName).forEach(System.out::println);
  }
}

注意幾點(diǎn)：
對(duì)于第一個(gè)方法引用User::getName，表示User類的實(shí)例方法。在執(zhí)行時(shí)，Java會(huì)自動(dòng)識(shí)別流中的元素（這里指User實(shí)例）是作為調(diào)用目標(biāo)還是調(diào)用方法的參數(shù)。
一般來(lái)說(shuō)，如果使用的是靜態(tài)方法，或者調(diào)用目標(biāo)明確，那么流內(nèi)的元素會(huì)自動(dòng)作為參數(shù)使用。如果函數(shù)引用表示實(shí)例方法，并且不存在調(diào)用目標(biāo)，那么流內(nèi)元素就會(huì)自動(dòng)作為調(diào)用目標(biāo)。
因此，如果一個(gè)類中存在同名的實(shí)例方法和靜態(tài)函數(shù)，那么編譯器就會(huì)感到很困惑，因?yàn)榇藭r(shí)，它不知道應(yīng)該使用哪個(gè)方法進(jìn)行調(diào)用。

打開(kāi) Collection Api可以看到多了一個(gè) stream() default 方法:

default Stream stream() {
    return StreamSupport.stream(spliterator(), false);
}

Stream 允許以聲明方式處理集合等可以轉(zhuǎn)換為 Stream 的數(shù)據(jù), 他有很多特點(diǎn):

內(nèi)部迭代 :與原有的 Iterator 不同, Stream 將迭代操作(類似 for / for-each )全部固化到了Api內(nèi)部實(shí)現(xiàn), 用戶只需傳入表達(dá)計(jì)算邏輯的 lambda 表達(dá)式(可以理解為 Supplier 、 Function 這些的 @FunctionalInterface 的實(shí)現(xiàn)), Stream 便會(huì)自動(dòng)迭代- 數(shù)據(jù)觸發(fā)計(jì)算邏輯并生成結(jié)果. 內(nèi)部迭代主要解決了兩方面的問(wèn)題: 避免集合處理時(shí)的套路和晦澀 ; 便于庫(kù)內(nèi)部實(shí)現(xiàn)的多核并行優(yōu)化 .

流水線 :很多 Stream 操作會(huì)再返回一個(gè) Stream , 這樣多個(gè)操作就可以鏈接起來(lái), 形成一個(gè)大的流水線, 使其看起來(lái)像是 對(duì)數(shù)據(jù)源進(jìn)行數(shù)據(jù)庫(kù)式查詢 , 這也就讓自動(dòng)優(yōu)化成為可能, 如 隱式并行 .

隱式并行 :如將 .stream() 替換為 .parallelStream() , Stream 則會(huì)自動(dòng)啟用Fork/Join框架, 并行執(zhí)行各條流水線, 并最終自動(dòng)將結(jié)果進(jìn)行合并.

延遲計(jì)算 :由于 Stream 大部分的操作(如 filter() 、 generate() 、 map() …)都是接受一段 lambda 表達(dá)式, 邏輯類似接口實(shí)現(xiàn)(可以看成是 回調(diào) ), 因此代碼并不是立即執(zhí)行的, 除非流水線上觸發(fā)一個(gè)終端操作, 否則中間操作不會(huì)執(zhí)行任何處理.

短路求值 :有些操作不需要處理整個(gè)流就能夠拿到結(jié)果, 很多像 anyMatch() 、 allMatch() 、 limit() , 只要找到一個(gè)元素他們的工作就可以結(jié)束, 也就沒(méi)有必要執(zhí)行后面的操作, 因此如果后面有大量耗時(shí)的操作, 此舉可大大節(jié)省性能.

Stream 構(gòu)成
一個(gè)流管道(Stream pipeline)通常由3部分構(gòu)成: 數(shù)據(jù)源(Source) -> 中間操作/轉(zhuǎn)換(Transforming) -> 終端操作/執(zhí)行(Operations) : Stream 由數(shù)據(jù)源生成, 經(jīng)由中間操作串聯(lián)起來(lái)的一條流水線的轉(zhuǎn)換, 最后由終端操作觸發(fā)執(zhí)行拿到結(jié)果.

除了前面介紹過(guò)的 collection.stream() , 流的生成方式多種多樣, 可簡(jiǎn)單概括為3類: 通用流 、 數(shù)值流 、 其他 , 其中以 通用流最為常用, 數(shù)值流是Java為 int 、 long 、 double 三種數(shù)值類型防 拆裝箱 成本所做的優(yōu)化:
A、通用流

Arrays.stream(T[] array)

Stream.empty()

Stream.generate(Supplier s) 返回?zé)o限無(wú)序流，其中每個(gè)元素由Supplier生成.

Stream.iterate(T seed, UnaryOperator f) 返回?zé)o限有序流。

Stream.of(T... values)

Stream.concat(Stream a, Stream b) 創(chuàng)建一個(gè)懶惰連接的流，其元素是第一個(gè)流的所有元素，后跟第二個(gè)流的所有元素.

StreamSupport.stream(Spliterator spliterator, boolean parallel) 從Spliterator創(chuàng)建一個(gè)新的順序流或并行流。.

B、數(shù)值流

Arrays.stream(Xxx[] array) Returns a sequential Int/Long/DoubleStream with the specified array as its source.

XxxStream.empty() Returns an empty sequential Int/Long/DoubleStream .

XxxStream.generate(XxxSupplier s) Returns an infinite sequential unordered stream where each element is generated by the provided Int/Long/DoubleSupplier .

XxxStream.iterate(Xxx seed, XxxUnaryOperator f) Returns an infinite sequential ordered Int/Long/DoubleStream like as Stream.iterate(T seed, UnaryOperator f)

XxxStream.of(Xxx... values) Returns a sequential ordered stream whose elements are the specified values.

XxxStream.concat(XxxStream a, XxxStream b) Creates a lazily concatenated stream whose elements are all the elements of the first stream followed by all the elements of the second stream.

Int/LongStream.range(startInclusive, endExclusive) Returns a sequential ordered Int/LongStream from startInclusive (inclusive) to endExclusive (exclusive) by an incremental step of 1.

Int/LongStream.rangeClosed(startInclusive, endInclusive) Returns a sequential ordered Int/LongStream from startInclusive (inclusive) to endInclusive (inclusive) by an incremental step of 1.

C、其他
C.1、I/O Stream

BufferedReader.lines()

C.2、File Stream

Files.lines(Path path)

Files.find(Path start, int maxDepth, BiPredicate matcher, FileVisitOption... options)

DirectoryStream newDirectoryStream(Path dir)

Files.walk(Path start, FileVisitOption... options)

C.3、Jar

JarFile.stream()

C.4、Random

Random.ints()

Random.longs()

Random.doubles()

C.5、Pattern

splitAsStream(CharSequence input) …

另外, 三種數(shù)值流之間, 以及數(shù)值流與通用流之間都可以相互轉(zhuǎn)換:

數(shù)值流轉(zhuǎn)換: doubleStream.mapToInt(DoubleToIntFunction mapper) 、 intStream.asLongStream() …

數(shù)值流轉(zhuǎn)通用流: longStream.boxed() 、 intStream.mapToObj(IntFunction mapper) …

通用流轉(zhuǎn)數(shù)值流: stream.flatMapToInt(Function mapper) 、 stream.mapToDouble(ToDoubleFunction mapper) …

所有的中間操作都會(huì)返回另一個(gè) Stream , 這讓多個(gè)操作可以鏈接起來(lái)組成中間操作鏈, 從而形成一條流水線, 因此它的特點(diǎn)就是前面提到的 延遲執(zhí)行 : 觸發(fā)流水線上觸發(fā)一個(gè)終端操作, 否則中間操作不執(zhí)行任何處理.

filter(Predicate predicate)

distinct() Returns a stream consisting of the distinct elements (according to Object.equals(Object) ) of this stream.

limit(long maxSize)

skip(long n)

sorted(Comparator comparator)

map(Function mapper) Returns a stream consisting of the results of applying the given function to the elements of this stream.

flatMap(Function> mapper) Returns a stream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the - provided mapping function to each element.

peek(Consumer action) Returns a stream consisting of the elements of this stream, additionally performing the provided action on each element as elements are consumed from the resulting stream.

這里著重講解下 flatMap()
假設(shè)我們有這樣一個(gè)字符串list: List strs = Arrays.asList("hello", "alibaba", "world"); 如何列出里面各不相同的字符呢?

Stream> streamStream = strs.stream()  
        .map(str -> Arrays.stream(str.split("")));  

我們將 String 分解成 String[] 后再由 Arrays.stream() 將 String[] 映射成 Stream , 但這個(gè)結(jié)果是我們不想看到的: 我們明明想要的是 Stream 卻得到的是 Stream> , 他把我們想要的結(jié)果包到 Stream 里面了. 這時(shí)候就需要我們的 flatMap() 出場(chǎng)了:

Stream stringStream = strs.stream()
        .flatMap(str -> Arrays.stream(str.split("")));

flatMap() 把 Stream 中的層級(jí)結(jié)構(gòu)扁平化了, 將內(nèi)層 Stream 內(nèi)的元素抽取出來(lái), 最終新的 Stream 就沒(méi)有內(nèi)層 Stream 了.
可以簡(jiǎn)單概括為: flatMap() 方法讓你把一個(gè)流中的每個(gè)值都換成另一個(gè) Stream , 然后把所有的 Stream 連接起來(lái)成為一個(gè) Stream .

終端操作不僅擔(dān)負(fù)著觸發(fā)流水線執(zhí)行的任務(wù), 他還需要拿到流水線執(zhí)行的結(jié)果, 其結(jié)果為任何不是流的值.

count()

max(Comparator comparator)

min(Comparator comparator)

allMatch(Predicate predicate)

anyMatch(Predicate predicate)

noneMatch(Predicate predicate)

findAny()

findFirst()

reduce(BinaryOperator accumulator) Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an Optional describing the reduced value, if any.

toArray()

forEach(Consumer action)

forEachOrdered(Consumer action) Performs an action for each element of this stream, in the encounter order of the stream if the stream has a defined encounter order.

collect(Collector collector) Performs a mutable reduction operation on the elements of this stream using a Collector .

像 IntStream / LongStream / DoubleStream 還提供了 average() 、 sum() 、 summaryStatistics() 這樣的操作, 拿到一個(gè)對(duì) Stream 進(jìn)行匯總了的結(jié)果.

java.util.stream.Stream 接口繼承自 java.util.stream.BaseStream 接口, 而 BaseStream 接口也提供了很多工具方法(如將串行流轉(zhuǎn)換為并行流的 parallel() 方法)供我們使用:

S onClose(Runnable closeHandler) Returns an equivalent stream with an additional close handler .

void close()

S unordered()

Iterator iterator()

Spliterator spliterator() Returns a spliterator for the elements of this stream.

S sequential()

S parallel()

boolean isParallel()

簡(jiǎn)單點(diǎn)的：

static int [] arr={1,4,3,6,5,7,2,9};

public static void main(String[]args){
//Array.stream()方法返回了一個(gè)流對(duì)象。類似于集合或者數(shù)組，流對(duì)象也是一個(gè)對(duì)象的集合，它將給予我們遍歷處理流內(nèi)元素的功能
  Arrays.stream(arr).forEach((x)->System.out.println(x));
}

復(fù)雜點(diǎn)的：

public void joiningList() {
    // 生成一段[0,20)序列
    List list = IntStream.range(0, 20)
            .boxed()
            .collect(Collectors.toList());

    // 將list內(nèi)的偶數(shù)提取反向排序后聚合為一個(gè)String
    String string = list.stream()
            .filter(n -> n % 2 == 0)
            .sorted(Comparator.comparing((Integer i) -> i).reversed())
            .limit(3)
            .peek((i) -> System.out.println("remained: " + i))
            .map(String::valueOf)
            .collect(Collectors.joining());

    System.out.println(string);
}

public class StreamLambda {
    private List transactions;

    @Before
    public void setUp() {
        Trader raoul = new Trader("Raoul", "Cambridge");
        Trader mario = new Trader("Mario", "Milan");
        Trader alan = new Trader("Alan", "Cambridge");
        Trader brian = new Trader("Brian", "Cambridge");

        transactions = Arrays.asList(
                new Transaction(brian, 2011, 300),
                new Transaction(raoul, 2012, 1000),
                new Transaction(raoul, 2011, 400),
                new Transaction(mario, 2012, 710),
                new Transaction(mario, 2012, 700),
                new Transaction(alan, 2012, 950)
        );
    }

    @Test
    public void action() {
        // 1. 打印2011年發(fā)生的所有交易, 并按交易額排序(從低到高)
        transactions.stream()
                .filter(transaction -> transaction.getYear() == 2011)
                .sorted(Comparator.comparing(Transaction::getValue))
                .forEachOrdered(System.out::println);

        // 2. 找出交易員都在哪些不同的城市工作過(guò)
        Set distinctCities = transactions.stream()
                .map(transaction -> transaction.getTrader().getCity())
                .collect(Collectors.toSet());   // or .distinct().collect(Collectors.toList())
        System.out.println(distinctCities);

        // 3. 找出所有來(lái)自于劍橋的交易員, 并按姓名排序
        Trader[] traders = transactions.stream()
                .map(Transaction::getTrader)
                .filter(trader -> trader.getCity().equals("Cambridge"))
                .distinct()
                .sorted(Comparator.comparing(Trader::getName))
                .toArray(Trader[]::new);
        System.out.println(Arrays.toString(traders));

        // 4. 返回所有交易員的姓名字符串, 并按字母順序排序
        String names = transactions.stream()
                .map(transaction -> transaction.getTrader().getName())
                .distinct()
                .sorted(Comparator.naturalOrder())
                .reduce("", (str1, str2) -> str1 + " " + str2);
        System.out.println(names);

        // 5. 返回所有交易員的姓名字母串, 并按字母順序排序
        String letters = transactions.stream()
                .map(transaction -> transaction.getTrader().getName())
                .distinct()
                .map(name -> name.split(""))
                .flatMap(Arrays::stream)
                .sorted()
                .collect(Collectors.joining());
        System.out.println(letters);

        // 6. 有沒(méi)有交易員是在米蘭工作
        boolean workMilan = transactions.stream()
                .anyMatch(transaction -> transaction.getTrader().getCity().equals("Milan"));
        System.out.println(workMilan);

        // 7. 打印生活在劍橋的交易員的所有交易額總和
        long sum = transactions.stream()
                .filter(transaction -> transaction.getTrader().getCity().equals("Cambridge"))
                .mapToLong(Transaction::getValue)
                .sum();
        System.out.println(sum);

        // 8. 所有交易中，最高的交易額是多少
        OptionalInt max = transactions.stream()
                .mapToInt(Transaction::getValue)
                .max();
        // or transactions.stream().map(Transaction::getValue).max(Comparator.naturalOrder());
        System.out.println(max.orElse(0));

        // 9. 找到交易額最小的交易
        Optional min = transactions.stream()
                .min(Comparator.comparingInt(Transaction::getValue));
        System.out.println(min.orElseThrow(IllegalArgumentException::new));
    }
}

在Java8中，可以在接口不變的情況下，將流改為并行流。這樣，就可以很自然地使用多線程進(jìn)行集合中的數(shù)據(jù)處理。

demo：我們希望可以統(tǒng)計(jì)一個(gè)1~1000000內(nèi)所有的質(zhì)數(shù)的數(shù)量。

IntStream.range(1,1000000).parallel().filter(PrimeUtil::isPrime).count();

從集合得到并行流

List ss =new ArrayList();
...
double ave = ss.parallelStream().mapToInt(s->s.score).average().getAsDouble();

int[]arr = new int [10000000];
Arrarys.parallelSort(arr);

1、Stream.generate

通過(guò)實(shí)現(xiàn) Supplier 接口，你可以自己來(lái)控制流的生成。這種情形通常用于隨機(jī)數(shù)、常量的 Stream，或者需要前后元素間維持著某種狀態(tài)信息的 Stream。把 Supplier 實(shí)例傳遞給 Stream.generate() 生成的 Stream，默認(rèn)是串行（相對(duì) parallel 而言）但無(wú)序的（相對(duì) ordered 而言）。由于它是無(wú)限的，在管道中，必須利用 limit 之類的操作限制 Stream 大小。

//生成 10 個(gè)隨機(jī)整數(shù)
Random seed = new Random();
Supplier random = seed::nextInt;
Stream.generate(random).limit(10).forEach(System.out::println);
//Another way
IntStream.generate(() -> (int) (System.nanoTime() % 100)).
limit(10).forEach(System.out::println);

注意幾個(gè)關(guān)鍵詞：默認(rèn)串行、無(wú)序、無(wú)限(需要進(jìn)行短路求值操作如limit)。

2、Stream.iterate

iterate 跟 reduce 操作很像，接受一個(gè)種子值，和一個(gè) UnaryOperator（例如 f）。然后種子值成為 Stream 的第一個(gè)元素，f(seed) 為第二個(gè)，f(f(seed)) 第三個(gè)，以此類推。

//生成一個(gè)等差數(shù)列 0 3 6 9 12 15 18 21 24 27
Stream.iterate(0, n -> n + 3).limit(10). forEach(x -> System.out.print(x + " "));.

與 Stream.generate 相仿，在 iterate 時(shí)候管道必須有 limit 這樣的操作來(lái)限制 Stream 大小。

java.util.stream.Collectors 類的主要作用就是輔助進(jìn)行各類有用的 reduction 操作，例如轉(zhuǎn)變輸出為 Collection，把 Stream 元素進(jìn)行歸組。
1、groupingBy/partitioningBy

//按照年齡歸組
Map> personGroups = Stream.generate(new PersonSupplier()).
 limit(100).
 collect(Collectors.groupingBy(Person::getAge));
Iterator it = personGroups.entrySet().iterator();
while (it.hasNext()) {
 Map.Entry> persons = (Map.Entry) it.next();
 System.out.println("Age " + persons.getKey() + " = " + persons.getValue().size());
}


//按照未成年人和成年人歸組
Map> children = Stream.generate(new PersonSupplier()).
 limit(100).
 collect(Collectors.partitioningBy(p -> p.getAge() < 18));
System.out.println("Children number: " + children.get(true).size());
System.out.println("Adult number: " + children.get(false).size());

//在使用條件“年齡小于 18”進(jìn)行分組后可以看到，不到 18 歲的未成年人是一組，成年人是另外一組。partitioningBy 其實(shí)是一種特殊的 groupingBy，它依照條件測(cè)試的是否兩種結(jié)果來(lái)構(gòu)造返回的數(shù)據(jù)結(jié)構(gòu)，get(true) 和 get(false) 能即為全部的元素對(duì)象。

其實(shí)這里很多觀念和Spark的RDD操作很相似。
總之，Stream 的特性可以歸納為：

不是數(shù)據(jù)結(jié)構(gòu)，它沒(méi)有內(nèi)部存儲(chǔ)，它只是用操作管道從 source（數(shù)據(jù)結(jié)構(gòu)、數(shù)組、generator function、IO channel）抓取數(shù)據(jù)。

它也絕不修改自己所封裝的底層數(shù)據(jù)結(jié)構(gòu)的數(shù)據(jù)。例如 Stream 的 filter 操作會(huì)產(chǎn)生一個(gè)不包含被過(guò)濾元素的新 Stream，而不是從 source 刪除那些元素。

所有 Stream 的操作必須以 lambda 表達(dá)式為參數(shù)

不支持索引訪問(wèn)，你可以請(qǐng)求第一個(gè)元素，但無(wú)法請(qǐng)求第二個(gè)，第三個(gè)，或最后一個(gè)。

很容易生成數(shù)組或者 List

惰性化，Intermediate 操作永遠(yuǎn)是惰性化的。

很多 Stream 操作是向后延遲的，一直到它弄清楚了最后需要多少數(shù)據(jù)才會(huì)開(kāi)始。

并行能力，當(dāng)一個(gè) Stream 是并行化的，就不需要再寫多線程代碼，所有對(duì)它的操作會(huì)自動(dòng)并行進(jìn)行的。

可以是無(wú)限的，集合有固定大小，Stream 則不必。limit(n) 和 findFirst() 這類的 short-circuiting 操作可以對(duì)無(wú)限的 Stream 進(jìn)行運(yùn)算并很快完成。

對(duì)于注解，Java 8 主要有兩點(diǎn)改進(jìn)：類型注解和重復(fù)注解。
Java 8 的類型注解擴(kuò)展了注解使用的范圍。在該版本之前，注解只能是在聲明的地方使用。現(xiàn)在幾乎可以為任何東西添加注解：局部變量、類與接口，就連方法的異常也能添加注解。新增的兩個(gè)注釋的程序元素類型 ElementType.TYPE_USE 和 ElementType.TYPE_PARAMETER 用來(lái)描述注解的新場(chǎng)合。
ElementType.TYPE_PARAMETER 表示該注解能寫在類型變量的聲明語(yǔ)句中。而 ElementType.TYPE_USE 表示該注解能寫在使用類型的任何語(yǔ)句中（例如聲明語(yǔ)句、泛型和強(qiáng)制轉(zhuǎn)換語(yǔ)句中的類型）。
對(duì)類型注解的支持，增強(qiáng)了通過(guò)靜態(tài)分析工具發(fā)現(xiàn)錯(cuò)誤的能力。原先只能在運(yùn)行時(shí)發(fā)現(xiàn)的問(wèn)題可以提前在編譯的時(shí)候被排查出來(lái)。Java 8 本身雖然沒(méi)有自帶類型檢測(cè)的框架，但可以通過(guò)使用 Checker Framework 這樣的第三方工具，自動(dòng)檢查和確認(rèn)軟件的缺陷，提高生產(chǎn)效率。

在Java8之前使用注解的一個(gè)限制是相同的注解在同一位置只能聲明一次，不能聲明多次。Java 8 引入了重復(fù)注解機(jī)制，這樣相同的注解可以在同一地方聲明多次。重復(fù)注解機(jī)制本身必須用 @Repeatable 注解。

增加了一些新的 IO/NIO 方法，使用這些方法可以從文件或者輸入流中獲取流（java.util.stream.Stream），通過(guò)對(duì)流的操作，可以簡(jiǎn)化文本行處理、目錄遍歷和文件查找。
新增的 API 如下：

BufferedReader.line(): 返回文本行的流 Stream

File.lines(Path, Charset):返回文本行的流 Stream

File.list(Path): 遍歷當(dāng)前目錄下的文件和目錄

File.walk(Path, int, FileVisitOption): 遍歷某一個(gè)目錄下的所有文件和指定深度的子目錄

File.find(Path, int, BiPredicate, FileVisitOption... ): 查找相應(yīng)的文件

下面就是用流式操作列出當(dāng)前目錄下的所有文件和目錄：

Files.list(new File(".").toPath())
 .forEach(System.out::println);

Java 的日期與時(shí)間 API 問(wèn)題由來(lái)已久，Java 8 之前的版本中關(guān)于時(shí)間、日期及其他時(shí)間日期格式化類由于線程安全、重量級(jí)、序列化成本高等問(wèn)題而飽受批評(píng)。Java 8 吸收了 Joda-Time 的精華，以一個(gè)新的開(kāi)始為 Java 創(chuàng)建優(yōu)秀的 API。新的 java.time 中包含了所有關(guān)于時(shí)鐘（Clock），本地日期（LocalDate）、本地時(shí)間（LocalTime）、本地日期時(shí)間（LocalDateTime）、時(shí)區(qū)（ZonedDateTime）和持續(xù)時(shí)間（Duration）的類。歷史悠久的 Date 類新增了 toInstant() 方法，用于把 Date 轉(zhuǎn)換成新的表示形式。這些新增的本地化時(shí)間日期 API 大大簡(jiǎn)化了了日期時(shí)間和本地化的管理。

Java日期/時(shí)間API包含以下相應(yīng)的包。

java.time包：這是新的Java日期/時(shí)間API的基礎(chǔ)包，所有的主要基礎(chǔ)類都是這個(gè)包的一部分，如：LocalDate, LocalTime, LocalDateTime, Instant, Period, Duration等等。所有這些類都是不可變的和線程安全的，在絕大多數(shù)情況下，這些類能夠有效地處理一些公共的需求。

java.time.chrono包：這個(gè)包為非ISO的日歷系統(tǒng)定義了一些泛化的API，我們可以擴(kuò)展AbstractChronology類來(lái)創(chuàng)建自己的日歷系統(tǒng)。

java.time.format包：這個(gè)包包含能夠格式化和解析日期時(shí)間對(duì)象的類，在絕大多數(shù)情況下，我們不應(yīng)該直接使用它們，因?yàn)?b>java.time包中相應(yīng)的類已經(jīng)提供了格式化和解析的方法。

java.time.temporal包：這個(gè)包包含一些時(shí)態(tài)對(duì)象，我們可以用其找出關(guān)于日期/時(shí)間對(duì)象的某個(gè)特定日期或時(shí)間，比如說(shuō)，可以找到某月的第一天或最后一天。你可以非常容易地認(rèn)出這些方法，因?yàn)樗鼈兌季哂小皐ithXXX”的格式。

java.time.zone包：這個(gè)包包含支持不同時(shí)區(qū)以及相關(guān)規(guī)則的類。

例如，下面是對(duì) LocalDate，LocalTime 的簡(jiǎn)單應(yīng)用：

//LocalDate只保存日期系統(tǒng)的日期部分，有時(shí)區(qū)信息，LocalTime只保存時(shí)間部分，沒(méi)有時(shí)區(qū)信息。LocalDate和LocalTime都可以從Clock對(duì)象創(chuàng)建。
//LocalDate
LocalDate localDate = LocalDate.now(); //獲取本地日期
localDate = LocalDate.ofYearDay(2014, 200); // 獲得 2014 年的第 200 天 
System.out.println(localDate.toString());//輸出：2014-07-19
localDate = LocalDate.of(2014, Month.SEPTEMBER, 10); //2014 年 9 月 10 日 
System.out.println(localDate.toString());//輸出：2014-09-10
//LocalTime
LocalTime localTime = LocalTime.now(); //獲取當(dāng)前時(shí)間
System.out.println(localTime.toString());//輸出當(dāng)前時(shí)間
localTime = LocalTime.of(10, 20, 50);//獲得 10:20:50 的時(shí)間點(diǎn)
System.out.println(localTime.toString());//輸出: 10:20:50
//Clock 時(shí)鐘,Clock類可以替換 System.currentTimeMillis() 和 TimeZone.getDefault(). 如：Clock.systemDefaultZone().millis()
Clock clock = Clock.systemDefaultZone();//獲取系統(tǒng)默認(rèn)時(shí)區(qū) (當(dāng)前瞬時(shí)時(shí)間 )
long millis = clock.millis();//

//LocalDateTime類合并了LocalDate和LocalTime，它保存有ISO-8601日期系統(tǒng)的日期和時(shí)間，但是沒(méi)有時(shí)區(qū)信息。
final LocalDateTime datetime = LocalDateTime.now();
final LocalDateTime datetimeFromClock = LocalDateTime.now( clock );
System.out.println( datetime );
System.out.println( datetimeFromClock );

//如果您需要一個(gè)類持有日期時(shí)間和時(shí)區(qū)信息，可以使用ZonedDateTime，它保存有ISO-8601日期系統(tǒng)的日期和時(shí)間，而且有時(shí)區(qū)信息。
final ZonedDateTime zonedDatetime = ZonedDateTime.now();
final ZonedDateTime zonedDatetimeFromClock = ZonedDateTime.now( clock );
final ZonedDateTime zonedDatetimeFromZone = ZonedDateTime.now( ZoneId.of( "America/Los_Angeles" ) );
System.out.println( zonedDatetime );
System.out.println( zonedDatetimeFromClock );
System.out.println( zonedDatetimeFromZone );

Duration類，Duration持有的時(shí)間精確到納秒。它讓我們很容易計(jì)算兩個(gè)日期中間的差異。讓我們來(lái)看一下：

// Get duration between two dates
final LocalDateTime from = LocalDateTime.of( 2014, Month.APRIL, 16, 0, 0, 0 );
final LocalDateTime to = LocalDateTime.of( 2015, Month.APRIL, 16, 23, 59, 59 );
 
final Duration duration = Duration.between( from, to );
System.out.println( "Duration in days: " + duration.toDays() );
System.out.println( "Duration in hours: " + duration.toHours() );

上面的例子計(jì)算了兩個(gè)日期（2014年4月16日和2014年5月16日）之間的持續(xù)時(shí)間（基于天數(shù)和小時(shí)）

日期API操作

//日期算術(shù)操作，多數(shù)日期/時(shí)間API類都實(shí)現(xiàn)了一系列工具方法，如：加/減天數(shù)、周數(shù)、月份數(shù)，等等。還有其他的工具方法能夠使用TemporalAdjuster調(diào)整日期，并計(jì)算兩個(gè)日期間的周期。
LocalDate today = LocalDate.now();
//Get the Year, check if it"s leap year
System.out.println("Year "+today.getYear()+" is Leap Year? "+today.isLeapYear());
//Compare two LocalDate for before and after
System.out.println("Today is before 01/01/2015? "+today.isBefore(LocalDate.of(2015,1,1)));
//Create LocalDateTime from LocalDate
System.out.println("Current Time="+today.atTime(LocalTime.now()));
//plus and minus operations
System.out.println("10 days after today will be "+today.plusDays(10));
System.out.println("3 weeks after today will be "+today.plusWeeks(3));
System.out.println("20 months after today will be "+today.plusMonths(20));
System.out.println("10 days before today will be "+today.minusDays(10));
System.out.println("3 weeks before today will be "+today.minusWeeks(3));
System.out.println("20 months before today will be "+today.minusMonths(20));

//Temporal adjusters for adjusting the dates
System.out.println("First date of this month= "+today.with(TemporalAdjusters.firstDayOfMonth()));
LocalDate lastDayOfYear = today.with(TemporalAdjusters.lastDayOfYear());
System.out.println("Last date of this year= "+lastDayOfYear);

Period period = today.until(lastDayOfYear);
System.out.println("Period Format= "+period);
System.out.println("Months remaining in the year= "+period.getMonths()); 

解析和格式化：將一個(gè)日期格式轉(zhuǎn)換為不同的格式，之后再解析一個(gè)字符串，得到日期時(shí)間對(duì)象

        //Format examples
        LocalDate date = LocalDate.now();
        //default format
        System.out.println("Default format of LocalDate="+date);
        //specific format
        System.out.println(date.format(DateTimeFormatter.ofPattern("d::MMM::uuuu")));
        System.out.println(date.format(DateTimeFormatter.BASIC_ISO_DATE));
 
        LocalDateTime dateTime = LocalDateTime.now();
        //default format
        System.out.println("Default format of LocalDateTime="+dateTime);
        //specific format
        System.out.println(dateTime.format(DateTimeFormatter.ofPattern("d::MMM::uuuu HH::mm::ss")));
        System.out.println(dateTime.format(DateTimeFormatter.BASIC_ISO_DATE));
 
        Instant timestamp = Instant.now();
        //default format
        System.out.println("Default format of Instant="+timestamp);
 
        //Parse examples
        LocalDateTime dt = LocalDateTime.parse("27::Apr::2014 21::39::48",
                DateTimeFormatter.ofPattern("d::MMM::uuuu HH::mm::ss"));
        System.out.println("Default format after parsing = "+dt);

舊的日期時(shí)間支持轉(zhuǎn)換：

        //Date to Instant
        Instant timestamp = new Date().toInstant();
        //Now we can convert Instant to LocalDateTime or other similar classes
        LocalDateTime date = LocalDateTime.ofInstant(timestamp, 
                        ZoneId.of(ZoneId.SHORT_IDS.get("PST")));
        System.out.println("Date = "+date);
 
        //Calendar to Instant
        Instant time = Calendar.getInstance().toInstant();
        System.out.println(time);
        //TimeZone to ZoneId
        ZoneId defaultZone = TimeZone.getDefault().toZoneId();
        System.out.println(defaultZone);
 
        //ZonedDateTime from specific Calendar
        ZonedDateTime gregorianCalendarDateTime = new GregorianCalendar().toZonedDateTime();
        System.out.println(gregorianCalendarDateTime);
 
        //Date API to Legacy classes
        Date dt = Date.from(Instant.now());
        System.out.println(dt);
 
        TimeZone tz = TimeZone.getTimeZone(defaultZone);
        System.out.println(tz);
 
        GregorianCalendar gc = GregorianCalendar.from(gregorianCalendarDateTime);
        System.out.println(gc);

Future是Java 5添加的類，用來(lái)描述一個(gè)異步計(jì)算的結(jié)果。你可以使用isDone方法檢查計(jì)算是否完成，或者使用get阻塞住調(diào)用線程，直到計(jì)算完成返回結(jié)果，你也可以使用cancel方法停止任務(wù)的執(zhí)行。
雖然Future以及相關(guān)使用方法提供了異步執(zhí)行任務(wù)的能力，但是對(duì)于結(jié)果的獲取卻是很不方便，只能通過(guò)阻塞或者輪詢的方式得到任務(wù)的結(jié)果。阻塞的方式顯然和我們的異步編程的初衷相違背，輪詢的方式又會(huì)耗費(fèi)無(wú)謂的CPU資源，而且也不能及時(shí)地得到計(jì)算結(jié)果，為什么不能用觀察者設(shè)計(jì)模式當(dāng)計(jì)算結(jié)果完成及時(shí)通知監(jiān)聽(tīng)者呢？
其實(shí)Google guava早就提供了通用的擴(kuò)展Future:ListenableFuture、SettableFuture 以及輔助類Futures等,方便異步編程。

final String name = ...;
inFlight.add(name);
ListenableFuture future = service.query(name);
future.addListener(new Runnable() {
  public void run() {
    processedCount.incrementAndGet();
    inFlight.remove(name);
    lastProcessed.set(name);
    logger.info("Done with {0}", name);
  }
}, executor);

在Java 8中, 新增加了一個(gè)包含50個(gè)方法左右的類: CompletableFuture，提供了非常強(qiáng)大的Future的擴(kuò)展功能，可以幫助我們簡(jiǎn)化異步編程的復(fù)雜性，提供了函數(shù)式編程的能力，可以通過(guò)回調(diào)的方式處理計(jì)算結(jié)果，并且提供了轉(zhuǎn)換和組合CompletableFuture的方法。
CompletableFuture類實(shí)現(xiàn)了CompletionStage和Future接口，所以你還是可以像以前一樣通過(guò)阻塞或者輪詢的方式獲得結(jié)果，盡管這種方式不推薦使用。
盡管Future可以代表在另外的線程中執(zhí)行的一段異步代碼，但是你還是可以在本身線程中執(zhí)行：

public class BasicMain {
    public static CompletableFuture compute() {
        final CompletableFuture future = new CompletableFuture<>();
        return future;
    }
    public static void main(String[] args) throws Exception {
        final CompletableFuture f = compute();
        class Client extends Thread {
            CompletableFuture f;
            Client(String threadName, CompletableFuture f) {
                super(threadName);
                this.f = f;
            }
            @Override
            public void run() {
                try {
                    System.out.println(this.getName() + ": " + f.get());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
            }
        }
        new Client("Client1", f).start();
        new Client("Client2", f).start();
        System.out.println("waiting");

        //上面的代碼中future沒(méi)有關(guān)聯(lián)任何的Callback、線程池、異步任務(wù)等，如果客戶端調(diào)用future.get就會(huì)一致傻等下去。除非我們顯式指定complete
        f.complete(100);
        //f.completeExceptionally(new Exception());
        System.in.read();
    }
}

CompletableFuture.complete()、CompletableFuture.completeExceptionally只能被調(diào)用一次。但是我們有兩個(gè)后門方法可以重設(shè)這個(gè)值:obtrudeValue、obtrudeException，但是使用的時(shí)候要小心，因?yàn)閏omplete已經(jīng)觸發(fā)了客戶端，有可能導(dǎo)致客戶端會(huì)得到不期望的結(jié)果。

1、創(chuàng)建CompletableFuture對(duì)象。

public static CompletableFuture completedFuture(U value)

public class Main {
    private static Random rand = new Random();
    private static long t = System.currentTimeMillis();
    static int getMoreData() {
        System.out.println("begin to start compute");
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("end to start compute. passed " + (System.currentTimeMillis() - t)/1000 + " seconds");
        return rand.nextInt(1000);
    }
    public static void main(String[] args) throws Exception {
        CompletableFuture future = CompletableFuture.supplyAsync(Main::getMoreData);
        Future f = future.whenComplete((v, e) -> {
            System.out.println(v);
            System.out.println(e);
        });
        System.out.println(f.get());
        System.in.read();
    }
}

CompletableFuture future = CompletableFuture.supplyAsync(() -> {
    return 100;
});
CompletableFuture f =  future.thenApplyAsync(i -> i * 10).thenApply(i -> i.toString());
System.out.println(f.get()); //"1000"

CompletableFuture future = CompletableFuture.supplyAsync(() -> {
    return 100;
});
CompletableFuture f =  future.thenAccept(System.out::println);
System.out.println(f.get());

CompletableFuture future = CompletableFuture.supplyAsync(() -> {
    return 100;
});
CompletableFuture f =  future.thenAcceptBoth(CompletableFuture.completedFuture(10), (x, y) -> System.out.println(x * y));
System.out.println(f.get());

CompletableFuture future = CompletableFuture.supplyAsync(() -> {
    return 100;
});
CompletableFuture f =  future.thenRun(() -> System.out.println("finished"));
System.out.println(f.get());

Random rand = new Random();
CompletableFuture future = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(10000 + rand.nextInt(1000));
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return 100;
});
CompletableFuture future2 = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(10000 + rand.nextInt(1000));
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return 200;
});
CompletableFuture f =  future.applyToEither(future2,i -> i.toString());