Steam<T>?

接口流

• 類型參數：
  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>。我們通過創建一個Widget對象流Collection.stream()，對其進行過濾以產生只包含紅色小部件的流，然后將其轉換為int代表每個紅色小部件權重的值流。然后將這個流加起來產生總重量。

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

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

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

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

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

  • 必須是無干擾的?（他們不會修改流源）;?和
  • 在大多數情況下，它們必須是無狀態的?（它們的結果不應該依賴于在流管道執行期間可能會改變的任何狀態）。

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

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

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

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

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

• • 嵌套類摘要

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

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

  • 方法摘要

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

    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對此流的元素執行可變減少操作?Collector。
    <R>?R	collect(Supplier<R>?supplier,?BiConsumer<R,? super?T>?accumulator,?BiConsumer<R,R>?combiner) 對此流的元素執行可變減少操作。
    static <T>?Stream<T>	concat(Stream<? extends T>?a,?Stream<? extends T>?b) 創建一個延遲連接的流，其元素是第一個流的所有元素，后跟第二個流的所有元素。
    long	count() 返回此流中元素的數量。
    Stream<T>	distinct() 返回Object.equals(Object)由此流的不同元素（根據?）組成的流。
    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) 返回一個流，該流包含將此流的每個元素替換為通過將所提供的映射函數應用于每個元素而生成的映射流的內容的結果。
    DoubleStream	flatMapToDouble(Function<? super?T,? extends?DoubleStream>?mapper) 返回一個DoubleStream包含將此流的每個元素替換為通過將所提供的映射函數應用于每個元素而生成的映射流的內容的結果。
    IntStream	flatMapToInt(Function<? super?T,? extends?IntStream>?mapper) 返回一個IntStream包含將此流的每個元素替換為通過將所提供的映射函數應用于每個元素而生成的映射流的內容的結果。
    LongStream	flatMapToLong(Function<? super?T,? extends?LongStream>?mapper) 返回一個LongStream包含將此流的每個元素替換為通過將所提供的映射函數應用于每個元素而生成的映射流的內容的結果。
    void	forEach(Consumer<? super?T>?action) 對此流的每個元素執行操作。
    void	forEachOrdered(Consumer<? super?T>?action) 為流的每個元素執行操作，如果流具有已定義的遇到順序，則按流的遇到順序執行操作。
    static <T>?Stream<T>	generate(Supplier<T>?s) 返回無限順序無序流，其中每個元素由提供的生成Supplier。
    static <T>?Stream<T>	iterate(T?seed,?UnaryOperator<T>?f) 返回一個無限連續有序Stream通過函數的迭代應用產生f為初始元素seed，產生Stream包括seed，f(seed)，?f(f(seed))，等。
    Stream<T>	limit(long?maxSize) 返回由此流的元素組成的流，截斷的maxSize長度不得超過。
    <R>?Stream<R>	map(Function<? super?T,? extends R>?mapper) 返回由將給定函數應用于此流的元素的結果組成的流。
    DoubleStream	mapToDouble(ToDoubleFunction<? super?T>?mapper) 返回DoubleStream由給定函數應用于此流的元素的結果組成的結果。
    IntStream	mapToInt(ToIntFunction<? super?T>?mapper) 返回IntStream由將給定函數應用于此流的元素的結果組成的結果。
    LongStream	mapToLong(ToLongFunction<? super?T>?mapper) 返回LongStream由給定函數應用于此流的元素的結果組成的結果。
    Optional<T>	max(Comparator<? super?T>?comparator) 根據提供的內容返回此流的最大元素?Comparator。
    Optional<T>	min(Comparator<? super?T>?comparator) 根據提供的返回此流的最小元素?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) 返回由此流的元素組成的流，另外對每個元素執行提供的操作，因為元素將從結果流中消耗。
    Optional<T>	reduce(BinaryOperator<T>?accumulator) 使用關聯累積函數執行此流的元素?縮減，并返回描述縮小的值（如果有的話）。Optional
    T	reduce(T?identity,?BinaryOperator<T>?accumulator) 使用提供的標識值和關聯?累積函數執行此流的元素?縮減，并返回縮小的值。
    <U>?U	reduce(U?identity,?BiFunction<U,? super?T,U>?accumulator,?BinaryOperator<U>?combiner) 使用提供的身份，積累和組合功能，執行此流的元素縮減。
    Stream<T>	skip(long?n) 丟棄流的第一個n元素后，返回包含此流的其余元素的流。
    Stream<T>	sorted() 返回由此流的元素組成的流，按照自然順序排序。
    Stream<T>	sorted(Comparator<? super?T>?comparator) 返回由該流的元素組成的流，按照提供的順序進行排序Comparator。
    Object[]	toArray() 返回包含此流的元素的數組。
    <A>?A[]	toArray(IntFunction<A[]>?generator) 返回包含此流的元素的數組，使用提供的generator函數分配返回的數組，以及分區執行或調整大小時可能需要的其他數組。

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

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

• • 方法細節

    • filter

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

      這是一個中間操作。

      參數：
      predicate-?適用于每個元素的非干擾，?無狀態謂詞，以確定是否應該包含它
      返回：
      新的流

    • map

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

      這是一個中間操作。

      類型參數：
      R?- 新流的元素類型
      參數：
      mapper-一個無干擾，?無狀態的?功能應用到每個元素
      返回：
      新的流

    • mapToInt

      IntStream ?mapToInt（ToIntFunction <？super T > mapper） 返回IntStream由將給定函數應用于此流的元素的結果組成的結果。

      這是一個?中間操作。

      參數：
      mapper-一個無干擾，?無狀態的?功能應用到每個元素
      返回：
      新的流

    • mapToLong

      LongStream ?mapToLong（ToLongFunction <？super T > mapper） 返回LongStream由給定函數應用于此流的元素的結果組成的結果。

      這是一個中間操作。

      參數：
      mapper-一個無干擾，?無狀態的?功能應用到每個元素
      返回：
      新的流

    • mapToDouble

      DoubleStream ?mapToDouble（ToDoubleFunction <？super T > mapper） 返回DoubleStream由給定函數應用于此流的元素的結果組成的結果。

      這是一個中間操作。

      參數：
      mapper-一個無干擾，?無狀態的?功能應用到每個元素
      返回：
      新的流

    • flatMap

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

      這是一個中間操作。

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

      例子。

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

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

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

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

    • flatMapToInt

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

      這是一個中間操作。

      參數：
      mapper-一個非干擾，?無狀態?功能應用到其產生新的值的流的每個元素
      返回：
      新的流
      也可以看看：
      flatMap(Function)

    • flatMapToLong

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

      這是一個中間操作。

      參數：
      mapper-一個非干擾，?無狀態?功能應用到其產生新的值的流的每個元素
      返回：
      新的流
      也可以看看：
      flatMap(Function)

    • flatMapToDouble

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

      這是一個中間操作。

      參數：
      mapper-一個非干擾，?無狀態?功能應用到其產生新的值的流的每個元素
      返回：
      新的流
      也可以看看：
      flatMap(Function)

    • distinct

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

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

      這是一個有狀態的中間操作。

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

    • sorted

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

      對于有序的流，排序是穩定的。對于無序流，沒有穩定性保證。

      這是一個有狀態的中間操作。

      返回：
      新的流

    • sorted

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

      對于有序的流，排序是穩定的。對于無序流，沒有穩定性保證。

      這是一個有狀態的中間操作。

      參數：
      comparator-?用于比較流元素的無干擾，?無狀態?Comparator
      返回：
      新的流

    • peek

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

      這是一個中間操作。

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

      API注意：
      此方法主要用于支持調試，您希望在元素流經管道中的某個點時看到這些元素： 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());
      參數：
      action-?從流中消耗的對元素執行的無干擾操作
      返回：
      新的流

    • limit

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

      這是一個短路狀態中間操作。

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

    • skip

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

      這是一個有狀態的中間操作。

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

    • forEach

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

      這是一個終端操作。

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

      參數：
      action-?對元素執行的無干擾行為

    • forEachOrdered

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

      這是一個終端操作。

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

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

    • toArray

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

      這是一個終端操作。

      返回：
      包含此流的元素的數組

    • toArray

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

      這是一個終端操作。

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

    • reduce

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

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

      這是一個終端操作。

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

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

      參數：
      identity?- 積累函數的標識值
      accumulator-?用于組合兩個值的關聯，?無干擾，?無狀態函數
      返回：
      減少的結果

    • reduce

      Optional<T>?reduce(BinaryOperator<T>?accumulator) 使用關聯累積函數執行此流的元素?縮減，并返回描述縮小的值（如果有的話）。這相當于：?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(); 但不限制順序執行。

      該accumulator函數必須是一個?關聯函數。

      這是一個終端操作。

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

    • reduce

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

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

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

      這是一個終端操作。

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

    • collect

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

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

      這是一個終端操作。

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

      以下內容將獲取一串字符串并將它們連接成一個字符串：

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

    • collect

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

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

      這是一個終端操作。

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

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

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

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

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

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

    • min

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

      這是一個終端操作。

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

    • max

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

      這是一個終端操作。

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

    • count

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

      這是一個終端操作。

      返回：
      這個流中元素的數量

    • anyMatch

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

      這是一個短路終端操作。

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

    • allMatch

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

      這是一個短路終端操作。

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

    • noneMatch

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

      這是一個短路終端操作。

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

    • findFirst

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

      這是一個短路終端操作。

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

    • findAny

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

      這是一個短路終端操作。

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

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

    • builder

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

    • empty

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

    • of

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

    • of

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

    • iterate

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

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

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

    • generate

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

    • concat

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

總結

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

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。