java8的Stream特性是什么

本篇內容介紹了“java8的Stream特性是什么”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

java.util.Stream 表示能應用在一組元素上一次執行的操作序列。Stream 操作分為中間操作或者最終操作兩種，最終操作返回一特定類型的計算結果，而中間操作返回Stream本身，這樣就可以將多個操作依次串起來。Stream 的創建需要指定一個數據源，比如 java.util.Collection的子類，List或者Set， Map不支持。Stream的操作可以串行stream()執行或者并行parallelStream()執行。

一、簡介

     java8新添加了一個特性：流Stream。Stream讓開發者能夠以一種聲明的方式處理數據源（集合、數組等），它專注于對數據源進行各種高效的聚合操作（aggregate operation）和大批量數據操作 (bulk data operation)。

    Stream API將處理的數據源看做一種Stream（流），Stream（流）在Pipeline（管道）中傳輸和運算，支持的運算包含篩選、排序、聚合等，當到達終點后便得到最終的處理結果。

幾個關鍵概念：

1. 元素 Stream是一個來自數據源的元素隊列，Stream本身并不存儲元素。

2. 數據源（即Stream的來源）包含集合、數組、I/O channel、generator（發生器）等。

3. 聚合操作 類似SQL中的filter、map、find、match、sorted等操作

4. 管道運算 Stream在Pipeline中運算后返回Stream對象本身，這樣多個操作串聯成一個Pipeline，并形成fluent風格的代碼。這種方式可以優化操作，如延遲執行(laziness)和短路( short-circuiting)。

5. 內部迭代 不同于java8以前對集合的遍歷方式（外部迭代），Stream API采用訪問者模式（Visitor）實現了內部迭代。

6. 并行運算 Stream API支持串行（stream() ）或并行（parallelStream() ）的兩種操作方式。

Stream API的特點：

1. Stream API的使用和同樣是java8新特性的 lambda表達式 密不可分，可以大大提高編碼效率和代碼可讀性。

2. Stream API提供串行和并行兩種操作，其中并行操作能發揮多核處理器的優勢，使用fork/join的方式進行并行操作以提高運行速度。

3. Stream API進行并行操作無需編寫多線程代碼即可寫出高效的并發程序，且通常可避免多線程代碼出錯的問題。

二、簡單示例

    我們來看一個簡單的示例，統計整數數組中正數的個數：

1. 在java8之前：

    public static void main(String[] args)
    {  
        List<Integer> numbers = Arrays.asList(-1, -2, 0, 4, 5);
        
        long count = 0;
        
        for(Integer number: numbers)
        {
            if(number > 0)
            {
                count++;
            }
        }
        
        System.out.println("Positive count: " + count);
    }

1. 在java8之后：

    public static void main(String[] args)
    {  
        List<Integer> numbers = Arrays.asList(-1, -2, 0, 4, 5);
      
        long count = numbers.parallelStream().filter(i -> i>0).count();
        
        System.out.println("Positive count: " + count);
    }

可以看到，上例中，使用filter()方法對數組進行了過濾，使用count()方法對過濾后的數組進行了大小統計，且使parallelStream()方法為集合創建了并行流，自動采用并行運算提高速度。在更復雜的場景，還可以用forEach()、map()、limit()、sorted()、collect()等方法進行進一步的流運算。

三、典型接口詳解

    本節以典型場景為例，列出Stream API常用接口的用法，并附上相應代碼。
    需要說明的是，Stream API中存在很多方法重載，同名方法本文中可能僅列舉一個，請讀者注意~

3.1  Stream的生成

    java8 Stream API支持串行或并行的方式，可以簡單看下jdk1.8 Collection接口的源碼(注釋只截取部分)：

    /**
     * @return a sequential {@code Stream} over the elements in this collection
     * @since 1.8
     */
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

    /**
     * @return a possibly parallel {@code Stream} over the elements in this collection
     * @since 1.8
     */
    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }

可以看出，在集合類的接口（Collection）中，分別用兩種方式來生成：

        1. 串行流 ： stream()
        2. 并行流 ： parallelStream()

應該注意的是，使用parallelStream()生成并行流后，對集合元素的遍歷是無序的。

3.2  forEach()方法

    簡單看下forEach()方法的源碼(注釋只截取部分)：

    /**
     * Performs an action for each element of this stream.
     */
    void forEach(Consumer<? super T> action);

forEach()方法的參數為一個Consumer（消費函數，一個函數式接口）對象，forEach()方法用來迭代流中的每一個數據，例如：

    public static void main(String[] args)
    {  
        List<Integer> numbers = Arrays.asList(-1, -2, 0, 4, 5);
        
        numbers.stream().forEach(n ->  System.out.println("List element: " + n));
    }

上例中，對數組的每個元素進行串行遍歷，并打印每個元素的值。

ps:
    集合的頂層接口Iterable中也投forEach方法，可以直接對數組元素進行遍歷：

    public static void main(String[] args)
    {  
        List<Integer> numbers = Arrays.asList(-1, -2, 0, 4, 5);
        
        numbers.forEach(n ->  System.out.println("List element: " + n));
    }

當然用Strem API的好處不僅僅是遍歷~~~

3.3  map()方法

    簡單看下map()方法的源碼(注釋只截取部分)：

    /**
     * Returns a stream consisting of the results of applying the given function to the elements of this stream.
     * @param <R> The element type of the new stream
     * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,
     *               <a href="package-summary.html#Statelessness">stateless</a>
     *               function to apply to each element
     * @return the new stream
     */
    <R> Stream<R> map(Function<? super T, ? extends R> mapper);

map()方法的參數為Function（函數式接口）對象，map()方法將流中的所有元素用Function對象進行運算，生成新的流對象（流的元素類型可能改變）。舉例如下：

    public static void main(String[] args)
    {  
        List<Integer> numbers = Arrays.asList(-1, -2, 0, 4, 5);
        
        numbers.stream().map( n -> Math.abs(n)).forEach(n ->  System.out.println("Element abs: " + n));
    }

上例中，用map()方法計算了所有數組元素的絕對值并生成了一個新的流，然后再用forEach()遍歷打印。

3.4  flatMap()方法

    簡單看下flatMap()方法的源碼(省略注釋)：

 <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

顯然，跟map()方法不同的是，Function函數的返回值類型是Stream<? extends R>類型，而不是R類型，即Function函數返回一個Stream流，這樣flatMap()能夠將一個二維的集合映射成一個一維的集合，比map()方法擁有更高的映射深度（此處可能有一點繞，可結合例子理解），作個簡單示例如下：

有一個字符串數組:

List<String> list = Arrays.asList("1 2", "3 4", "5 6");

其有三個元素，每個元素有兩個數組并用空格隔開，如果每個元素以空格分割成2個元素，并遍歷打印這6個元素，

用flatMap()方法如下：

list.stream().flatMap(item -> Arrays.stream(item.split(" "))).forEach(System.out::println);

而用map()方法：

 list.stream().map(item -> Arrays.stream(item.split(" "))).forEach(n ->n.forEach(System.out::println));

可見，用map()方法，返回了一個“流中流”，需要在每個Stream元素遍歷時，再加一層forEach進行遍歷。

3.5  filter()方法

    簡單看下filter()方法的源碼(注釋只截取部分)：

    /**
     * Returns a stream consisting of the elements of this stream that match the given predicate.
     *
     * <p>This is an <a href="package-summary.html#StreamOps">intermediate operation</a>.
     *
     * @param predicate a <a href="package-summary.html#NonInterference">non-interfering</a>,
     *                  <a href="package-summary.html#Statelessness">stateless</a>
     *                  predicate to apply to each element to determine if it  should be included
     * @return the new stream
     */
    Stream<T> filter(Predicate<? super T> predicate);

filter()方法的參數為Predicate（函數式接口）對象，再lambda表達式的講解中我們提到過這個接口，一般用它進行過濾。正如第二章中示例：

    public static void main(String[] args)
    {  
        List<Integer> numbers = Arrays.asList(-1, -2, 0, 4, 5);
      
        long count = numbers.parallelStream().filter(i -> i>0).count();
        
        System.out.println("Positive count: " + count);
    }

用filter方法很容易過濾出整數數組中的自然數。

3.6  reduce()方法

    reduce操作又稱為折疊操作，用于將流中的所有值合成一個。reduce()方法的源碼（不提供計算初始值的reduce方法）（省略注釋）：

Optional<T> reduce(BinaryOperator<T> accumulator);

reduce()方法參數為BinaryOperator類型的累加器（它接受兩個類型相同的參數，返回值類型跟參數類型相同），返回一個Optional對象。
　實際上，Stream API中的mapToInt()方法返回的IntStream接口有類似的 average()、count()、sum()等方法就是做reduce操作，類似的還有mapToLong()、mapToDouble() 方法。當然，我們也可以用reduce()方法來自定義reduce操作。例如我們用reduce()方法來進行整數數組求和操作：

    public static void main(String[] args)
    {
        List<Integer> numbers = Arrays.asList(-1, -2, 0, -1, 4, 5, 1);
        
        Integer total = numbers.stream().reduce((t, n) -> t + n).get();
        
        System.out.println("Total: " + total);
    }

上例中利用reduce()方法結合lambda表達式輕易的實現了數組的求和功能。

3.7  collect()方法

    簡單看下collect()方法的源碼(注釋只截取部分)：

    /**
     * @param <R> the type of the result
     * @param <A> the intermediate accumulation type of the {@code Collector}
     * @param collector the {@code Collector} describing the reduction
     * @return the result of the reduction
     */
    <R, A> R collect(Collector<? super T, A, R> collector);

collect()方法的參數為一個java.util.stream.Collector類型對象，可以用java.util.stream.Collectors工具類提供的靜態方法來生成，Collectors類實現很多的歸約操作，如Collectors.toList()、Collectors.toSet()、Collectors.joining()（joining適用于字符串流）等。看一個簡單示例：

    public static void main(String[] args)
    {  
        List<Integer> numbers = Arrays.asList(-1, -2, 0, 4, 5);
        
        List<Integer> abss = numbers.stream().map( n -> Math.abs(n)).collect(Collectors.toList());
        
        System.out.println("Abs list: " + abss);
    }

上例中，用map()方法生成新的流，再用collect()方法返回原數組的絕對值數組。

3.8  summaryStatistics()方法進行數值統計

    其實summaryStatistics()方法并不是Stream接口的方法，而是Stream API采用mapToInt()、mapToLong()、mapToDouble()三個方法分別生成IntStream 、LongStream 、DoubleStream 三個接口類型的對象，這個方法的參數分別為3個函數式接口ToIntFunction、ToLongFunction、ToDoubleFunction，使用時可以用lambda表達式計算返回對應的int、long、double類型即可，簡單看下這三個方法的源碼(省略注釋)：

    IntStream mapToInt(ToIntFunction<? super T> mapper);

    LongStream mapToLong(ToLongFunction<? super T> mapper);

    DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);

IntStream 、LongStream 、DoubleStream 三個接口類型都有一個summaryStatistics()方法，其中，

1. IntStream 的方法是：

 IntSummaryStatistics summaryStatistics();

1. LongStream 的方法是：

 LongSummaryStatistics summaryStatistics();

1. DoubleStream 的方法是：

 DoubleSummaryStatistics summaryStatistics();

在IntSummaryStatistics、LongSummaryStatistics 、DoubleSummaryStatistics 三個接口類型（位于java.util包下）中，都有諸如統計數量、最大值、最小值、求和、平均值等方法（方法名和返回類型可能不同），利用這些方法我們可以方便的進行數值統計。以IntSummaryStatistics工具包 為例：

    public static void main(String[] args)
    {
        List<Integer> numbers = Arrays.asList(-1, -2, 0, 4, 5);
        
        IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();
        
        System.out.println("Max : " + stats.getMax());
        System.out.println("Min : " + stats.getMin());
        System.out.println("Sum : " + stats.getSum());
        System.out.println("Average : " + stats.getAverage());
        System.out.println("Count : " + stats.getCount());
    }

3.9  其它方法

    Stream API還有一些其它的方法，比如：
　　　　limit()　　　 獲取指定數量的流
　　　　sorted()　 　對流進行排序
　　　　distinct()　　去重
　　　　skip()　　　　跳過指定數量的元素
　　　　peek()　　　生成一個包含原Stream的所有元素的新Stream，并指定消費函數
　　　　count()　　　計算元素數量
　　　　......

四、注意事項

Stream中的操作從概念上講分為中間操作和終端操作：

• 中間操作：例如peek()方法提供Consumer（消費）函數，但執行peek()方法時不會執行Consumer函數，而是等到流真正被消費時（終端操作時才進行消費）才會執行，這種操作為中間操作；

• 終端操作：例如forEach()、collect()、count()等方法會對流中的元素進行消費，并執行指定的消費函數（peek方法提供的消費函數在此時執行），這種操作為終端操作。

要理解中間操作和終端操作的概念，防止埋坑~

14個常用Stream：

1. forEach 循環

@Test
public void forEach(){
    // 你不鳥我,我也不鳥你
    List<String> list = Arrays.asList("you", "don't", "bird", "me", ",", 
                                       "I", "don't", "bird", "you");

    // 方式一：JDK1.8之前的循環方式
    for (String item: list) {
        System.out.println(item);
    }

    // 方式二：使用Stream的forEach方法
    // void forEach(Consumer<? super T> action)
    list.stream().forEach(item -> System.out.println(item));

    // 方式三：方式二的簡化方式
    // 由于方法引用也屬于函數式接口，所以方式二Lambda表達式也可以使用方法引用來代替
    // 此種方式就是方式一、方式二的簡寫形式
    list.stream().forEach(System.out::println);
}

2. filter 過濾

public class User {
    private Long id;
    private String phone;
    private Integer age;

    public User(){}
    public User(Long id, String username, Integer age) {
        this.id = id;
        this.username = username;
        this.age = age;
    }
    // Getter & Setter & toString
}


@Test
public void filter(){
    List<User> users = Arrays.asList(
            new User(1L, "mengday", 28),
            new User(2L, "guoguo", 18),
            new User(3L, "liangliang", 17)
    );

    // Stream<T> filter(Predicate<? super T> predicate);
    users.stream().filter(user -> user.getAge() > 18).forEach(System.out::println);
}

3. map 映射

@Test
public void map(){
    List<String> list = Arrays.asList("how", "are", "you", "how", "old", "are", "you", "?");
    // <R> Stream<R> map(Function<? super T, ? extends R> mapper);
    list.stream().map(item -> item.toUpperCase()).forEach(System.out::println);
}

4. flatMap

@Test
public void flatMap(){
    List<Integer> a = Arrays.asList(1, 2, 3);
    List<Integer> b = Arrays.asList(4, 5, 6);

    // <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)
    List<List<Integer>> collect = Stream.of(a, b).collect(Collectors.toList());
    // [[1, 2, 3], [4, 5, 6]] 
    System.out.println(collect);

    // 將多個集合中的元素合并成一個集合
    List<Integer> mergeList = Stream.of(a, b).flatMap(list -> list.stream()).collect(Collectors.toList());
    // [1, 2, 3, 4, 5, 6]
    System.out.println(mergeList);

    // 通過Builder模式來構建
    Stream<Object> stream = Stream.builder().add("hello").add("hi").add("byebye").build();
}

5. sorted 排序

@Test
public void sort(){
    List<String> list = Arrays.asList("c", "e", "a", "d", "b");
    // Stream<T> sorted(Comparator<? super T> comparator);
    // int compare(T o1, T o2);
    list.stream().sorted((s1, s2) -> s1.compareTo(s2)).forEach(System.out::println);
}

6. distinct 去重復

@Test
public void distinct(){
    // 知之為知之,不知為不知
    Stream<String> stream = Stream.of("know", "is", "know", "noknow", "is", "noknow");
    stream.distinct().forEach(System.out::println); // know is noknow
}

7. count 總數量

@Test
public void count(){
    Stream<String> stream = Stream.of("know", "is", "know", "noknow", "is", "noknow");
    long count = stream.count();
    System.out.println(count);
}

8. min、max

@Test
public void min(){
    List<String> list = Arrays.asList("1", "2", "3", "4", "5");
    // Optional<T> min(Comparator<? super T> comparator);
    Optional<String> optional = list.stream().min((a, b) -> a.compareTo(b));
    String value = optional.get();
    System.out.println(value);
}

9. skip、limit

@Test
public void skip(){
    List<String> list = Arrays.asList("a", "b", "c", "d", "e");
    // Stream<T> skip(long n)
    list.stream().skip(2).forEach(System.out::println);  // c、d、e
}

@Test
public void limit(){
    List<String> list = Arrays.asList("a", "b", "c", "d", "e");
    list.stream().skip(2).limit(2).forEach(System.out::println);    // c、d
}

10. collect

@Test
public void collect(){
    List<String> list = Arrays.asList("a", "b", "c", "d", "e");
    // Stream -> Collection
    List<String> collect = list.stream().collect(Collectors.toList());

    // Stream -> Object[]
    Object[] objects = list.stream().toArray();
}

11. concat

@Test
public void concat(){
    List<String> list = Arrays.asList("a", "b");
    List<String> list2 = Arrays.asList("c", "d");
    Stream<String> concatStream = Stream.concat(list.stream(), list2.stream());
    concatStream.forEach(System.out::println);
}

12. anyMatch、allMatch

@Test
public void match(){
    // 你給我站住
    List<String> list = Arrays.asList("you", "give", "me", "stop");
    // boolean anyMatch(Predicate<? super T> predicate);
    // parallelStream可以并行計算，速度比stream更快
    boolean result = list.parallelStream().anyMatch(item -> item.equals("me"));
    System.out.println(result);
}

/**
* anyMatch偽代碼
 * 如果集合中有一個元素滿足條件就返回true
 * @return
 */
public  boolean anyMatch() {
    List<String> list = Arrays.asList("you", "give", "me", "stop");
    for (String item : list) {
        if (item.equals("me")) {
            return true;
        }
    }

        return false;
    }

13. reduce 歸納

@Test
public void reduce(){
    Stream<String> stream = Stream.of("you", "give", "me", "stop");
    // Optional<T> reduce(BinaryOperator<T> accumulator);
    Optional<String> optional = stream.reduce((before, after) -> before + "," + after);
    optional.ifPresent(System.out::println);    // you,give,me,stop
}

BigDecimal求和

public static void main(String[] args) {
    List<BigDecimal> list = Arrays.asList(
            new BigDecimal("11.11"),
            new BigDecimal("22.22"),
            new BigDecimal("33.33")
    );
    // 66.66
    BigDecimal sum = list.stream().reduce(BigDecimal.ZERO, BigDecimal::add);
    System.out.println(sum);
}

14. findFirst、findAny

@Test
public void findFirst(){
    Stream<String> stream = Stream.of("you", "give", "me", "stop");
    String value = stream.findFirst().get();
    System.out.println(value);
}

@Test
public void findAny(){
    Stream<String> stream = Stream.of("you", "give", "me", "stop");
    String value2 = stream.findAny().get();
    System.out.println(value2);
}

“java8的Stream特性是什么”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！