Steam<T>?

接口流

• 類型參數(shù)：
  T?- 流元素的類型
  所有超級接口：
  AutoCloseable，BaseStream?<T，Stream?<T >>

  ---

  
  公共接口Stream <T> 擴展BaseStream <T，Stream <T >> 支持順序和并行聚合操作的一系列元素。以下示例說明使用Streamand?的聚合操作?IntStream： int sum = widgets.stream().filter(w -> w.getColor() == RED).mapToInt(w -> w.getWeight()).sum(); 在這個例子中，widgets是一個Collection<Widget>。我們通過創(chuàng)建一個Widget對象流Collection.stream()，對其進行過濾以產(chǎn)生只包含紅色小部件的流，然后將其轉(zhuǎn)換為int代表每個紅色小部件權(quán)重的值流。然后將這個流加起來產(chǎn)生總重量。

  除了Stream，這是對象引用的流，存在用于原始特IntStream，LongStream以及DoubleStream，所有這些都稱為“流”和符合此處描述的特征和限制。

  為了執(zhí)行計算，流?操作被組成?流管道。一個流管道由一個源（可能是一個數(shù)組，一個集合，一個生成器函數(shù)，一個I / O通道等），零個或多個中間操作（將流轉(zhuǎn)換成另一個流等filter(Predicate)）?終端操作（產(chǎn)生結(jié)果或副作用，如count()or?forEach(Consumer)）。流是懶惰的;?源數(shù)據(jù)的計算僅在終端操作啟動時執(zhí)行，而源元素僅在需要時消耗。

  收藏和流媒體雖然有一些膚淺的相似之處，卻有著不同的目標。收藏主要關(guān)心對元素的有效管理和訪問。相比之下，流不提供直接訪問或操作元素的手段，而是關(guān)注于聲明性地描述它們的來源以及將在該來源上進行的計算操作。然而，如果提供的流的操作不提供所期望的功能性，BaseStream.iterator()并且BaseStream.spliterator()操作可用于執(zhí)行受控的遍歷。

  流管道，就像上面的“小部件”示例一樣，可以被視為流源上的查詢。除非源代碼被明確設(shè)計用于并發(fā)修改（如a?ConcurrentHashMap），否則在查詢流源時修改流源可能會導致不可預(yù)知或錯誤的行為。

  大多數(shù)流操作接受描述用戶指定行為的參數(shù)，例如上例中w -> w.getWeight()傳遞給?的lambda表達式mapToInt。為了保持正確的行為，這些行為參數(shù)：

  • 必須是無干擾的?（他們不會修改流源）;?和
  • 在大多數(shù)情況下，它們必須是無狀態(tài)的?（它們的結(jié)果不應(yīng)該依賴于在流管道執(zhí)行期間可能會改變的任何狀態(tài)）。

  這樣的參數(shù)總是一個實例?功能接口如Function，也常常lambda表達式或方法的引用。除非另有規(guī)定，否則這些參數(shù)必須?是非空的。

  應(yīng)該只對一個數(shù)據(jù)流進行操作（調(diào)用中間或終端流操作）一次。這排除了例如“分叉”流，其中相同的源饋送兩個或更多個管線，或者多個遍歷相同的流。如果流IllegalStateException?檢測到流正在被重用，可能會拋出流。然而，由于一些流操作可能返回它們的接收者而不是新的流對象，所以在所有情況下可能無法檢測到重用。

  流有一個BaseStream.close()方法和實現(xiàn)AutoCloseable，但幾乎所有的流實例實際上并不需要在使用后關(guān)閉。一般來說，只有來源是IO通道的流（例如返回的流Files.lines(Path, Charset)）需要關(guān)閉。大多數(shù)流都由集合，數(shù)組或者生成函數(shù)來支持，而不需要特殊的資源管理。（如果流確實需要關(guān)閉，則可以在try-with-resources語句中將其聲明為資源。）

  流管線可以按順序或并行執(zhí)行?。這個執(zhí)行模式是流的一個屬性。流是通過順序或并行執(zhí)行的初始選擇創(chuàng)建的。（例如，?Collection.stream()創(chuàng)建一個順序流，并Collection.parallelStream()創(chuàng)建一個并行流。）執(zhí)行模式的這種選擇可以由BaseStream.sequential()or?BaseStream.parallel()方法修改?，并且可以用該BaseStream.isParallel()方法查詢。

  以來：
  1.8
  也可以看看：
  IntStream，?LongStream，?DoubleStream，?java.util.stream

• • 嵌套類摘要

    嵌套類修飾符和類型界面和說明

    static interface?	Stream.Builder<T> 一個可變的建設(shè)者Stream。

  • 方法摘要

    所有方法靜態(tài)方法實例方法抽象方法默認方法修飾符和類型方法和描述

    boolean	allMatch(Predicate<? super?T>?predicate) 返回此流的所有元素是否與提供的謂詞匹配。
    boolean	anyMatch(Predicate<? super?T>?predicate) 返回此流的任何元素是否與提供的謂詞匹配。
    static <T>?Stream.Builder<T>	builder() 返回一個生成器Stream。
    <R,A>?R	collect(Collector<? super?T,A,R>?collector) 使用a對此流的元素執(zhí)行可變減少操作?Collector。
    <R>?R	collect(Supplier<R>?supplier,?BiConsumer<R,? super?T>?accumulator,?BiConsumer<R,R>?combiner) 對此流的元素執(zhí)行可變減少操作。
    static <T>?Stream<T>	concat(Stream<? extends T>?a,?Stream<? extends T>?b) 創(chuàng)建一個延遲連接的流，其元素是第一個流的所有元素，后跟第二個流的所有元素。
    long	count() 返回此流中元素的數(shù)量。
    Stream<T>	distinct() 返回Object.equals(Object)由此流的不同元素（根據(jù)?）組成的流。
    static <T>?Stream<T>	empty() 返回一個空的順序Stream。
    Stream<T>	filter(Predicate<? super?T>?predicate) 返回由此流的元素組成的流，該流匹配給定的謂詞。
    Optional<T>	findAny() 返回Optional描述流的某個元素，Optional如果流為空，則返回一個空元素。
    Optional<T>	findFirst() 返回Optional描述此流的第一個元素，Optional如果流為空，則返回空。
    <R>?Stream<R>	flatMap(Function<? super?T,? extends?Stream<? extends R>>?mapper) 返回一個流，該流包含將此流的每個元素替換為通過將所提供的映射函數(shù)應(yīng)用于每個元素而生成的映射流的內(nèi)容的結(jié)果。
    DoubleStream	flatMapToDouble(Function<? super?T,? extends?DoubleStream>?mapper) 返回一個DoubleStream包含將此流的每個元素替換為通過將所提供的映射函數(shù)應(yīng)用于每個元素而生成的映射流的內(nèi)容的結(jié)果。
    IntStream	flatMapToInt(Function<? super?T,? extends?IntStream>?mapper) 返回一個IntStream包含將此流的每個元素替換為通過將所提供的映射函數(shù)應(yīng)用于每個元素而生成的映射流的內(nèi)容的結(jié)果。
    LongStream	flatMapToLong(Function<? super?T,? extends?LongStream>?mapper) 返回一個LongStream包含將此流的每個元素替換為通過將所提供的映射函數(shù)應(yīng)用于每個元素而生成的映射流的內(nèi)容的結(jié)果。
    void	forEach(Consumer<? super?T>?action) 對此流的每個元素執(zhí)行操作。
    void	forEachOrdered(Consumer<? super?T>?action) 為流的每個元素執(zhí)行操作，如果流具有已定義的遇到順序，則按流的遇到順序執(zhí)行操作。
    static <T>?Stream<T>	generate(Supplier<T>?s) 返回無限順序無序流，其中每個元素由提供的生成Supplier。
    static <T>?Stream<T>	iterate(T?seed,?UnaryOperator<T>?f) 返回一個無限連續(xù)有序Stream通過函數(shù)的迭代應(yīng)用產(chǎn)生f為初始元素seed，產(chǎn)生Stream包括seed，f(seed)，?f(f(seed))，等。
    Stream<T>	limit(long?maxSize) 返回由此流的元素組成的流，截斷的maxSize長度不得超過。
    <R>?Stream<R>	map(Function<? super?T,? extends R>?mapper) 返回由將給定函數(shù)應(yīng)用于此流的元素的結(jié)果組成的流。
    DoubleStream	mapToDouble(ToDoubleFunction<? super?T>?mapper) 返回DoubleStream由給定函數(shù)應(yīng)用于此流的元素的結(jié)果組成的結(jié)果。
    IntStream	mapToInt(ToIntFunction<? super?T>?mapper) 返回IntStream由將給定函數(shù)應(yīng)用于此流的元素的結(jié)果組成的結(jié)果。
    LongStream	mapToLong(ToLongFunction<? super?T>?mapper) 返回LongStream由給定函數(shù)應(yīng)用于此流的元素的結(jié)果組成的結(jié)果。
    Optional<T>	max(Comparator<? super?T>?comparator) 根據(jù)提供的內(nèi)容返回此流的最大元素?Comparator。
    Optional<T>	min(Comparator<? super?T>?comparator) 根據(jù)提供的返回此流的最小元素?Comparator。
    boolean	noneMatch(Predicate<? super?T>?predicate) 返回此流的元素是否與提供的謂詞匹配。
    static <T>?Stream<T>	of(T...?values) 返回一個順序排列的流，其元素是指定的值。
    static <T>?Stream<T>	of(T?t) 返回Stream包含單個元素的順序。
    Stream<T>	peek(Consumer<? super?T>?action) 返回由此流的元素組成的流，另外對每個元素執(zhí)行提供的操作，因為元素將從結(jié)果流中消耗。
    Optional<T>	reduce(BinaryOperator<T>?accumulator) 使用關(guān)聯(lián)累積函數(shù)執(zhí)行此流的元素?縮減，并返回描述縮小的值（如果有的話）。Optional
    T	reduce(T?identity,?BinaryOperator<T>?accumulator) 使用提供的標識值和關(guān)聯(lián)?累積函數(shù)執(zhí)行此流的元素?縮減，并返回縮小的值。
    <U>?U	reduce(U?identity,?BiFunction<U,? super?T,U>?accumulator,?BinaryOperator<U>?combiner) 使用提供的身份，積累和組合功能，執(zhí)行此流的元素縮減。
    Stream<T>	skip(long?n) 丟棄流的第一個n元素后，返回包含此流的其余元素的流。
    Stream<T>	sorted() 返回由此流的元素組成的流，按照自然順序排序。
    Stream<T>	sorted(Comparator<? super?T>?comparator) 返回由該流的元素組成的流，按照提供的順序進行排序Comparator。
    Object[]	toArray() 返回包含此流的元素的數(shù)組。
    <A>?A[]	toArray(IntFunction<A[]>?generator) 返回包含此流的元素的數(shù)組，使用提供的generator函數(shù)分配返回的數(shù)組，以及分區(qū)執(zhí)行或調(diào)整大小時可能需要的其他數(shù)組。

    • 從接口java.util.stream繼承的方法?BaseStream

      close,?isParallel,?iterator,?onClose,?parallel,?sequential,?spliterator,?unordered

• • 方法細節(jié)

    • filter

      Stream<T>?filter(Predicate<? super T>?predicate) 返回由此流的元素組成的流，該流匹配給定的謂詞。

      這是一個中間操作。

      參數(shù)：
      predicate-?適用于每個元素的非干擾，?無狀態(tài)謂詞，以確定是否應(yīng)該包含它
      返回：
      新的流

    • map

      <R>?Stream<R>?map(Function<? super T,? extends R>?mapper) 返回由將給定函數(shù)應(yīng)用于此流的元素的結(jié)果組成的流。

      這是一個中間操作。

      類型參數(shù)：
      R?- 新流的元素類型
      參數(shù)：
      mapper-一個無干擾，?無狀態(tài)的?功能應(yīng)用到每個元素
      返回：
      新的流

    • mapToInt

      IntStream ?mapToInt（ToIntFunction <？super T > mapper） 返回IntStream由將給定函數(shù)應(yīng)用于此流的元素的結(jié)果組成的結(jié)果。

      這是一個?中間操作。

      參數(shù)：
      mapper-一個無干擾，?無狀態(tài)的?功能應(yīng)用到每個元素
      返回：
      新的流

    • mapToLong

      LongStream ?mapToLong（ToLongFunction <？super T > mapper） 返回LongStream由給定函數(shù)應(yīng)用于此流的元素的結(jié)果組成的結(jié)果。

      這是一個中間操作。

      參數(shù)：
      mapper-一個無干擾，?無狀態(tài)的?功能應(yīng)用到每個元素
      返回：
      新的流

    • mapToDouble

      DoubleStream ?mapToDouble（ToDoubleFunction <？super T > mapper） 返回DoubleStream由給定函數(shù)應(yīng)用于此流的元素的結(jié)果組成的結(jié)果。

      這是一個中間操作。

      參數(shù)：
      mapper-一個無干擾，?無狀態(tài)的?功能應(yīng)用到每個元素
      返回：
      新的流

    • flatMap

      <R>?Stream<R>?flatMap(Function<? super T,? extends Stream<? extends R>>?mapper) 返回一個流，該流包含將此流的每個元素替換為通過將所提供的映射函數(shù)應(yīng)用于每個元素而生成的映射流的內(nèi)容的結(jié)果。每個映射的流都是?closed在其內(nèi)容被放入這個流之后。（如果使用映射的流是null?一個空的流，則改為）。

      這是一個中間操作。

      API注意：
      該flatMap()操作具有對流的元素應(yīng)用一對多轉(zhuǎn)換，然后將所得元素平坦化為新流的效果。

      例子。

      如果orders是采購訂單流，并且每個采購訂單都包含一系列行項目，則以下內(nèi)容會生成包含所有訂單中的所有行項目的流：

      orders.flatMap(order -> order.getLineItems().stream())...

      如果path是文件的路徑，則以下內(nèi)容將生成words包含在該文件中的一個流：

      Stream<String> lines = Files.lines(path, StandardCharsets.UTF_8);Stream<String> words = lines.flatMap(line -> Stream.of(line.split(" +"))); mapper傳遞?的函數(shù)flatMap使用一個簡單的正則表達式將行分割成一個單詞數(shù)組，然后從該數(shù)組創(chuàng)建一個單詞流。
      類型參數(shù)：
      R?- 新流的元素類型
      參數(shù)：
      mapper-一個非干擾，?無狀態(tài)?功能應(yīng)用到其產(chǎn)生新的值的流的每個元素
      返回：
      新的流

    • flatMapToInt

      IntStream ?flatMapToInt（Function <？super T，？extends IntStream > mapper） 返回一個IntStream包含將此流的每個元素替換為通過將所提供的映射函數(shù)應(yīng)用于每個元素而生成的映射流的內(nèi)容的結(jié)果。每個映射的流都是closed在其內(nèi)容被放入這個流之后。（如果使用映射的流是?null一個空的流，則改為）。

      這是一個中間操作。

      參數(shù)：
      mapper-一個非干擾，?無狀態(tài)?功能應(yīng)用到其產(chǎn)生新的值的流的每個元素
      返回：
      新的流
      也可以看看：
      flatMap(Function)

    • flatMapToLong

      LongStream ?flatMapToLong（Function <？super T，？extends LongStream > mapper） 返回一個LongStream包含將此流的每個元素替換為通過將所提供的映射函數(shù)應(yīng)用于每個元素而生成的映射流的內(nèi)容的結(jié)果。每個映射的流都是closed在其內(nèi)容被放入這個流之后。（如果使用映射的流是?null一個空的流，則改為）。

      這是一個中間操作。

      參數(shù)：
      mapper-一個非干擾，?無狀態(tài)?功能應(yīng)用到其產(chǎn)生新的值的流的每個元素
      返回：
      新的流
      也可以看看：
      flatMap(Function)

    • flatMapToDouble

      DoubleStream ?flatMapToDouble（Function <？super T，？extends DoubleStream > mapper） 返回一個DoubleStream包含將此流的每個元素替換為通過將所提供的映射函數(shù)應(yīng)用于每個元素而生成的映射流的內(nèi)容的結(jié)果。每個映射的流都是closed在其內(nèi)容已被放入該流之后。（如果使用映射的流是?null一個空的流，則改為）。

      這是一個中間操作。

      參數(shù)：
      mapper-一個非干擾，?無狀態(tài)?功能應(yīng)用到其產(chǎn)生新的值的流的每個元素
      返回：
      新的流
      也可以看看：
      flatMap(Function)

    • distinct

      Stream < T > distinct（） 返回Object.equals(Object)由此流的不同元素（根據(jù)?）組成的流。

      對于有序流，選擇不同的元素是穩(wěn)定的（對于重復(fù)的元素，保持在遇到順序中首先出現(xiàn)的元素）。對于無序流，沒有穩(wěn)定性保證。

      這是一個有狀態(tài)的中間操作。

      API注意：
      distinct()在并行管道中保持穩(wěn)定性是相對昂貴的（要求操作充當完全屏障，具有大量的緩沖開銷），并且通常不需要穩(wěn)定性。如果您的情況的語義允許，使用無序的流源（如generate(Supplier)）或刪除排序約束BaseStream.unordered()可能會導致distinct()在并行管道中顯著更高效的執(zhí)行。如果要求與遇到命令的一致性，并且distinct()在并行管道中遇到性能不佳或內(nèi)存利用率較低的問題，則切換到順序執(zhí)行BaseStream.sequential()可能會提高性能。
      返回：
      新的流

    • sorted

      Stream < T > sorted（） 返回由此流的元素組成的流，按照自然順序排序。如果這個流的元素不是?Comparable，java.lang.ClassCastException執(zhí)行終端操作時可能會拋出a?。

      對于有序的流，排序是穩(wěn)定的。對于無序流，沒有穩(wěn)定性保證。

      這是一個有狀態(tài)的中間操作。

      返回：
      新的流

    • sorted

      Stream<T>?sorted(Comparator<? super T>?comparator) 返回由該流的元素組成的流，按照提供的順序進行排序Comparator。

      對于有序的流，排序是穩(wěn)定的。對于無序流，沒有穩(wěn)定性保證。

      這是一個有狀態(tài)的中間操作。

      參數(shù)：
      comparator-?用于比較流元素的無干擾，?無狀態(tài)?Comparator
      返回：
      新的流

    • peek

      Stream < T > peek（Consumer <？super T > action） 返回由此流的元素組成的流，另外對每個元素執(zhí)行提供的操作，因為元素將從結(jié)果流中消耗。

      這是一個中間操作。

      對于并行流管線，可以在任何時間和任何線程中通過上游操作來調(diào)用該操作。如果操作修改共享狀態(tài)，則負責提供所需的同步。

      API注意：
      此方法主要用于支持調(diào)試，您希望在元素流經(jīng)管道中的某個點時看到這些元素： Stream.of("one", "two", "three", "four").filter(e -> e.length() > 3).peek(e -> System.out.println("Filtered value: " + e)).map(String::toUpperCase).peek(e -> System.out.println("Mapped value: " + e)).collect(Collectors.toList());
      參數(shù)：
      action-?從流中消耗的對元素執(zhí)行的無干擾操作
      返回：
      新的流

    • limit

      Stream<T>?limit(long?maxSize) 返回由此流的元素組成的流，截斷的maxSize長度不得超過。

      這是一個短路狀態(tài)中間操作。

      API注意：
      雖然limit()在順序流管道上通常是一個便宜的操作，但是在有序并行流水線上，特別是對于大數(shù)值，這可能是非常昂貴的maxSize，因為limit(n)?不僅要返回任何n個元素，還要返回遇到順序中的?前n個元素。如果您的情況的語義允許，使用無序的流源（如generate(Supplier)）或刪除排序約束BaseStream.unordered()可能會導致limit()并行管道的顯著加速。如果要求與遇到命令的一致性，并且limit()在并行管道中遇到性能不佳或內(nèi)存利用率?較低的問題，則切換到順序執(zhí)行BaseStream.sequential()可能會提高性能。
      參數(shù)：
      maxSize?- 流應(yīng)該被限制的元素的數(shù)量
      返回：
      新的流
      拋出：
      IllegalArgumentException- 如果maxSize是消極的

    • skip

      Stream < T > skip（long n） 丟棄流的第一個n元素后，返回包含此流的其余元素的流。如果這個流包含少于n元素，那么將返回一個空的流。

      這是一個有狀態(tài)的中間操作。

      API注意：
      雖然skip()在順序流管線上通常是一個便宜的操作，但對于有序的并行流水線，特別是對于大數(shù)值，這可能是非常昂貴的n，因為skip(n)?被約束不僅跳過任何n個元素，而且還跳過遇到次序中的?前n個元素。如果您的情況的語義允許，使用無序的流源（如generate(Supplier)）或刪除排序約束BaseStream.unordered()可能會導致skip()并行管道的顯著加速。如果要求與遇到命令的一致性，并且skip()在并行管道中遇到性能不佳或內(nèi)存利用率?較低的問題，則切換到順序執(zhí)行BaseStream.sequential()可能會提高性能。
      參數(shù)：
      n?- 要跳過的主要元素的數(shù)量
      返回：
      新的流
      拋出：
      IllegalArgumentException- 如果n是消極的

    • forEach

      void forEach（Consumer <？super T > action） 對此流的每個元素執(zhí)行操作。

      這是一個終端操作。

      這個操作的行為顯然是不確定的。對于并行流管道，這個操作并不能?保證尊重流的相遇順序，因為這樣做會犧牲并行的利益。對于任何給定的元素，該動作可以在任何時間和在圖書館選擇的任何線程中執(zhí)行。如果操作訪問共享狀態(tài)，則負責提供所需的同步。

      參數(shù)：
      action-?對元素執(zhí)行的無干擾行為

    • forEachOrdered

      void forEachOrdered（Consumer <？super T > action） 為流的每個元素執(zhí)行操作，如果流具有已定義的遇到順序，則按流的遇到順序執(zhí)行操作。

      這是一個終端操作。

      這個操作一次處理一個元素，如果存在的話，按照順序處理。執(zhí)行一個元素的動作?發(fā)生在?為后續(xù)元素執(zhí)行動作之前，但是對于任何給定的元素，動作可以在庫選擇的任何線程中執(zhí)行。

      參數(shù)：
      action-?對元素執(zhí)行的無干擾行為
      也可以看看：
      forEach(Consumer)

    • toArray

      Object [] toArray（） 返回包含此流的元素的數(shù)組。

      這是一個終端操作。

      返回：
      包含此流的元素的數(shù)組

    • toArray

      <A>?A[]?toArray(IntFunction<A[]>?generator) 返回包含此流的元素的數(shù)組，使用提供的generator函數(shù)分配返回的數(shù)組，以及分區(qū)執(zhí)行或調(diào)整大小時可能需要的其他數(shù)組。

      這是一個終端操作。

      API注意：
      生成器函數(shù)采用一個整數(shù)，它是所需數(shù)組的大小，并生成所需大小的數(shù)組。這可以用一個數(shù)組構(gòu)造器引用來簡潔地表示： Person[] men = people.stream().filter(p -> p.getGender() == MALE).toArray(Person[]::new);
      類型參數(shù)：
      A?- 結(jié)果數(shù)組的元素類型
      參數(shù)：
      generator?- 一個產(chǎn)生所需類型和提供長度的新數(shù)組的函數(shù)
      返回：
      包含此流中元素的數(shù)組
      拋出：
      ArrayStoreException?- 如果從數(shù)組生成器返回的數(shù)組的運行時類型不是該流中每個元素的運行時類型的超類型

    • reduce

      T?reduce(T?identity,BinaryOperator<T>?accumulator) 使用提供的標識值和關(guān)聯(lián)?累積函數(shù)執(zhí)行此流的元素?縮減，并返回縮小的值。這相當于： T result = identity;for (T element : this stream)result = accumulator.apply(result, element)return result; 但不限制順序執(zhí)行。

      該identity值必須是累加器函數(shù)的標識。這意味著，所有t，?accumulator.apply(identity, t)等于t。該accumulator函數(shù)必須是一個?關(guān)聯(lián)函數(shù)。

      這是一個終端操作。

      API注意：
      總和，最小值，最大值，平均值和字符串連接都是特殊的縮減情況。總結(jié)一串數(shù)字可以表示為： Integer sum = integers.reduce(0, (a, b) -> a+b); 要么： Integer sum = integers.reduce(0, Integer::sum);

      雖然這可能看起來是一個更簡單的方法來執(zhí)行聚合，而不是簡單地將循環(huán)中的運行總量進行變異，但是減少操作可以更加平滑地進行并行處理，而不需要額外的同步，并且大大降低了數(shù)據(jù)競爭的風險。

      參數(shù)：
      identity?- 積累函數(shù)的標識值
      accumulator-?用于組合兩個值的關(guān)聯(lián)，?無干擾，?無狀態(tài)函數(shù)
      返回：
      減少的結(jié)果

    • reduce

      Optional<T>?reduce(BinaryOperator<T>?accumulator) 使用關(guān)聯(lián)累積函數(shù)執(zhí)行此流的元素?縮減，并返回描述縮小的值（如果有的話）。這相當于：?Optional boolean foundAny = false;T result = null;for (T element : this stream) {if (!foundAny) {foundAny = true;result = element;}elseresult = accumulator.apply(result, element);}return foundAny ? Optional.of(result) : Optional.empty(); 但不限制順序執(zhí)行。

      該accumulator函數(shù)必須是一個?關(guān)聯(lián)函數(shù)。

      這是一個終端操作。

      參數(shù)：
      accumulator-?用于組合兩個值的關(guān)聯(lián)，?無干擾，?無狀態(tài)函數(shù)
      返回：
      一個Optional描述減少的結(jié)果
      拋出：
      NullPointerException?- 如果減少的結(jié)果為空
      也可以看看：
      reduce(Object, BinaryOperator)，?min(Comparator)，?max(Comparator)

    • reduce

      <U>?U?reduce(U?identity,BiFunction<U,? super T,U>?accumulator,BinaryOperator<U>?combiner) 使用提供的身份，積累和組合功能，執(zhí)行此流的元素縮減。這相當于： U result = identity;for (T element : this stream)result = accumulator.apply(result, element)return result; 但不限制順序執(zhí)行。

      該identity值必須是組合函數(shù)的標識。這意味著，所有u，combiner(identity, u)?等于u。此外，該combiner功能必須與該accumulator功能兼容;?對于所有?u和t，以下必須持有：

      combiner.apply(u, accumulator.apply(identity, t)) == accumulator.apply(u, t)

      這是一個終端操作。

      API注意：
      許多減少使用這種形式可以更簡單地通過明確的組合map和reduce操作來表示。該accumulator函數(shù)作為一個融合的映射器和累加器，有時比單獨的映射和減少更有效率，比如知道以前減少的值可以避免一些計算。
      類型參數(shù)：
      U?- 結(jié)果的類型
      參數(shù)：
      identity?- 組合函數(shù)的標識值
      accumulator-一個締合，?非干擾性，?無狀態(tài)?用于將一個額外的元件到結(jié)果函數(shù)
      combiner-一個締合，?非干擾，?無狀態(tài)?功能用于組合兩個值，它必須與蓄能器功能兼容
      返回：
      減少的結(jié)果
      也可以看看：
      reduce(BinaryOperator)，?reduce(Object, BinaryOperator)

    • collect

      <R>?R?collect(Supplier<R>?supplier,BiConsumer<R,? super T>?accumulator,BiConsumer<R,R>?combiner) 對此流的元素執(zhí)行可變減少操作。一個可變的約簡是減少的值是一個可變的結(jié)果容器，比如一個ArrayList，通過更新結(jié)果的狀態(tài)而不是通過替換結(jié)果來結(jié)合元素。這產(chǎn)生了等同于下面的結(jié)果： R result = supplier.get();for (T element : this stream)accumulator.accept(result, element);return result;

      就像reduce(Object, BinaryOperator)，collect操作可以并行，而不需要額外的同步。

      這是一個終端操作。

      API注意：
      JDK中有許多現(xiàn)有的類，它們的簽名非常適合用作方法引用作為參數(shù)collect()。例如，以下內(nèi)容將把字符串累加到ArrayList： List<String> asList = stringStream.collect(ArrayList::new, ArrayList::add,ArrayList::addAll);

      以下內(nèi)容將獲取一串字符串并將它們連接成一個字符串：

      String concat = stringStream.collect(StringBuilder::new, StringBuilder::append,StringBuilder::append).toString();
      類型參數(shù)：
      R?- 結(jié)果的類型
      參數(shù)：
      supplier?- 一個創(chuàng)建一個新的結(jié)果容器的函數(shù)。對于并行執(zhí)行，可能會多次調(diào)用此函數(shù)，并且每次都必須返回一個新值。
      accumulator-一個締合，?非干擾性，?無狀態(tài)?用于將一個額外的元件到結(jié)果函數(shù)
      combiner-一個締合，?非干擾，?無狀態(tài)?功能用于組合兩個值，它必須與蓄能器功能兼容
      返回：
      減少的結(jié)果

    • collect

      <R,A>?R?collect(Collector<? super T,A,R>?collector) 使用a對此流的元素執(zhí)行可變減少操作?Collector。A?Collector?將用作參數(shù)的函數(shù)封裝起來?collect(Supplier, BiConsumer, BiConsumer)，從而允許重用收集策略和收集操作的組合，例如多級分組或分區(qū)。

      如果流是平行的，并且Collector?是concurrent，并且或者流是無序或集電極是?unordered，那么將執(zhí)行一個并發(fā)減少（見Collector用于并發(fā)還原細節(jié)）。

      這是一個終端操作。

      當并行執(zhí)行時，可以實例化，填充和合并多個中間結(jié)果，以保持可變數(shù)據(jù)結(jié)構(gòu)的隔離。因此，即使與非線程安全的數(shù)據(jù)結(jié)構(gòu)（如ArrayList）并行執(zhí)行，并行還原也不需要額外的同步。

      API注意：
      以下將把字符串累加到ArrayList中： List<String> asList = stringStream.collect(Collectors.toList());

      以下將按Person城市對對象進行分類：

      Map<String, List<Person>> peopleByCity= personStream.collect(Collectors.groupingBy(Person::getCity));

      以下將按Person州和城市分類對象，將兩個對象級聯(lián)Collector在一起：

      Map<String, Map<String, List<Person>>> peopleByStateAndCity= personStream.collect(Collectors.groupingBy(Person::getState,Collectors.groupingBy(Person::getCity)));
      類型參數(shù)：
      R?- 結(jié)果的類型
      A?- 的中間積累類型?Collector
      參數(shù)：
      collector-?Collector描述減少
      返回：
      減少的結(jié)果
      也可以看看：
      collect(Supplier, BiConsumer, BiConsumer)，?Collectors

    • min

      Optional<T>?min(Comparator<? super T>?comparator) 根據(jù)提供的返回此流的最小元素?Comparator。這是減少的特殊情況?。

      這是一個終端操作。

      參數(shù)：
      comparator- 一個無干擾，?無狀態(tài)?Comparator的比較這個流的元素
      返回：
      一個Optional描述該流的最小元素，或空Optional如果流是空
      拋出：
      NullPointerException?- 如果最小元素為null

    • max

      Optional<T>?max(Comparator<? super T>?comparator) 根據(jù)提供的內(nèi)容返回此流的最大元素?Comparator。這是減少的特殊情況?。

      這是一個終端操作。

      參數(shù)：
      comparator- 一個無干擾，?無狀態(tài)?Comparator的比較這個流的元素
      返回：
      一個Optional描述該流的最大元素，或空Optional如果流是空
      拋出：
      NullPointerException?- 如果最大元素為空

    • count

      long count（） 返回此流中元素的數(shù)量。這是一個特殊的情況下降低，等同于： return mapToLong(e -> 1L).sum();

      這是一個終端操作。

      返回：
      這個流中元素的數(shù)量

    • anyMatch

      boolean?anyMatch(Predicate<? super T>?predicate) 返回此流的任何元素是否與提供的謂詞匹配。如果不需要確定結(jié)果，則不能評估所有元素的謂詞。如果流是空的，則?false返回并且不評估謂詞。

      這是一個短路終端操作。

      API注意：
      這種方法評估流的元素上謂詞的存在量化（對于一些x P（x））。
      參數(shù)：
      predicate-?適用于這個流的元素的一個無干擾，?無狀態(tài)的謂詞
      返回：
      true?如果流的任何元素與提供的謂詞匹配，否則?false

    • allMatch

      boolean?allMatch(Predicate<? super T>?predicate) 返回此流的所有元素是否與提供的謂詞匹配。如果不需要確定結(jié)果，則不能評估所有元素的謂詞。如果流是空的，則true返回并且不評估謂詞。

      這是一個短路終端操作。

      API注意：
      這種方法評估流的元素的謂詞的通用量化（對于所有x P（x））。如果流是空的，量化被認為是真實的滿足，并且總是true（不管P（x））。
      參數(shù)：
      predicate-?適用于這個流的元素的一個無干擾，?無狀態(tài)的謂詞
      返回：
      true?如果流的所有元素都匹配提供的謂詞，或者流是空的，否則?false

    • noneMatch

      boolean?noneMatch(Predicate<? super T>?predicate) 返回此流的元素是否與提供的謂詞匹配。如果不需要確定結(jié)果，則不能評估所有元素的謂詞。如果流是空的，則true返回并且不評估謂詞。

      這是一個短路終端操作。

      API注意：
      這種方法評估流元素上的否定謂詞的通用量化（對于所有x?P（x））。如果流是空的，則量化被認為是真實地滿足，并且總是true，不管P（x）如何。
      參數(shù)：
      predicate-?適用于這個流的元素的一個無干擾，?無狀態(tài)的謂詞
      返回：
      true?如果流的任何元素都不匹配提供的謂詞，或者流是空的，否則?false

    • findFirst

      Optional<T>?findFirst() 返回Optional描述此流的第一個元素，Optional如果流為空，則返回空。如果流沒有遇到命令，則可以返回任何元素。

      這是一個短路終端操作。

      返回：
      一個Optional描述該流的第一個元素，或空Optional如果流是空
      拋出：
      NullPointerException?- 如果選擇的元素為空

    • findAny

      Optional<T>?findAny() 返回Optional描述流的某個元素，Optional如果流為空，則返回一個空元素。

      這是一個短路終端操作。

      這個操作的行為是明確的不確定的;?它可以自由選擇流中的任何元素。這是為了在并行操作中實現(xiàn)最高性能。成本是多個調(diào)用在同一來源可能不會返回相同的結(jié)果。（如果需要穩(wěn)定的結(jié)果，請findFirst()改用。）

      返回：
      一個Optional描述該流的某些元件，或者一個空Optional如果流是空
      拋出：
      NullPointerException?- 如果選擇的元素為空
      也可以看看：
      findFirst()

    • builder

      static?<T>?Stream.Builder<T>?builder() 返回一個生成器Stream。 類型參數(shù)：
      T?- 元素的類型
      返回：
      一個流建設(shè)者

    • empty

      static <T>? Stream <T> empty（） 返回一個空的順序Stream。 類型參數(shù)：
      T?- 流元素的類型
      返回：
      一個空的順序流

    • of

      static?<T>?Stream<T>?of(T?t) 返回Stream包含單個元素的順序。 類型參數(shù)：
      T?- 流元素的類型
      參數(shù)：
      t?- 單個元素
      返回：
      一個單一的順序流

    • of

      @SafeVarargs static?<T>?Stream<T>?of(T...?values) 返回一個順序排列的流，其元素是指定的值。 類型參數(shù)：
      T?- 流元素的類型
      參數(shù)：
      values?- 新流的元素
      返回：
      新的流

    • iterate

      static <T>? Stream <T> iterate（T seed，UnaryOperator <T> f） 返回一個無限連續(xù)有序Stream通過函數(shù)的迭代應(yīng)用產(chǎn)生f為初始元素seed，產(chǎn)生Stream包括seed，f(seed)，?f(f(seed))，等。

      第一個元素（位置0）Stream將會是提供的seed。為n > 0，在位置上的元素?n，將是將所述函數(shù)的結(jié)果f在位置到元件n - 1。

      類型參數(shù)：
      T?- 流元素的類型
      參數(shù)：
      seed?- 最初的元素
      f?- 應(yīng)用于前一個元素以生成新元素的函數(shù)
      返回：
      一個新的順序?Stream

    • generate

      static <T>? Stream <T> generate（Supplier <T> s） 返回無限順序無序流，其中每個元素由提供的生成Supplier。這適用于生成恒定流，隨機元素流等。 類型參數(shù)：
      T?- 流元素的類型
      參數(shù)：
      s-?Supplier生成的元素
      返回：
      一個新的無限順序無序?Stream

    • concat

      static <T>? Stream <T> concat（Stream <？extends T> a，Stream <？extends T> b） 創(chuàng)建一個延遲連接的流，其元素是第一個流的所有元素，后跟第二個流的所有元素。如果兩個輸入流都是有序的，則生成的流是有序的;如果任意一個輸入流是并行的，則生成的流是并行的。當結(jié)果流關(guān)閉時，調(diào)用兩個輸入流的關(guān)閉處理程序。 實施說明：
      從重復(fù)連接構(gòu)造流時要小心。訪問深度級聯(lián)流的元素可能會導致深度調(diào)用鏈，甚至導致深度調(diào)用鏈StackOverflowException。
      類型參數(shù)：
      T?- 流元素的類型
      參數(shù)：
      a?- 第一個流
      b?- 第二個流
      返回：
      兩個輸入流的連接

總結(jié)

以上是生活随笔為你收集整理的java8新特新：接口流-Stream()接口和所有方法（map,foreach,filter,count,distinct,limit,collect,skip,sorted)的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。