Stream流

在Java 8中猎莲，得益于Lambda所帶來的函數(shù)式編程，引入了一個全新的Stream概念胸嘴，用于解決已有集合類庫既有的弊端辑奈。
Java 8的Lambda讓我們可以更加專注于做什么（What），而不是怎么做（How）
for循環(huán)的語法就是“怎么做”
for循環(huán)的循環(huán)體才是“做什么”
為什么使用循環(huán)之宿？因為要進行遍歷族操。但循環(huán)是遍歷的唯一方式嗎？遍歷是指每一個元素逐一進行處理比被，而并不是從第一個到最后一個順次處理的循環(huán)色难。前者是目的，后者是方式等缀。
Stream的更優(yōu)寫法:將本該寫三個循環(huán)來實現(xiàn)的方法用Stream流來完成

public static void main(String[] args) {
        //創(chuàng)建一個List集合,存儲姓名
        List<String> list = new ArrayList<>();
        list.add("張無忌");
        list.add("周芷若");
        list.add("趙敏");
        list.add("張強");
        list.add("張三豐");

        //對list集合中的元素進行過濾,只要以張開頭的元素,存儲到一個新的集合中
        //對listA集合進行過濾,只要姓名長度為3的人,存儲到一個新集合中
        //遍歷listB集合
        list.stream()
                .filter(name->name.startsWith("張"))
            .filter(name->name.length()==3)
            .forEach(name-> System.out.println(name));
}

流式思想概述

Stream（流）是一個來自數(shù)據(jù)源的元素隊列

元素是特定類型的對象枷莉，形成一個隊列。 Java中的Stream并不會存儲元素尺迂，而是按需計算笤妙。
數(shù)據(jù)源流的來源。可以是集合噪裕，數(shù)組等蹲盘。

和以前的Collection操作不同， Stream操作還有兩個基礎(chǔ)的特征：

Pipelining: 中間操作都會返回流對象本身膳音。這樣多個操作可以串聯(lián)成一個管道召衔，如同流式風(fēng)格（?uent style）。這樣做可以對操作進行優(yōu)化祭陷，比如延遲執(zhí)行(laziness)和短路( short-circuiting)苍凛。
內(nèi)部迭代：以前對集合遍歷都是通過Iterator或者增強for的方式, 顯式的在集合外部進行迭代趣席，這叫做外部迭代。 Stream提供了內(nèi)部迭代的方式醇蝴，流可以直接調(diào)用遍歷方法宣肚。

當(dāng)使用一個流的時候，通常包括三個基本步驟：獲取一個數(shù)據(jù)源（source）→ 數(shù)據(jù)轉(zhuǎn)換→執(zhí)行操作獲取想要的結(jié) 果悠栓，每次轉(zhuǎn)換原有 Stream 對象不改變霉涨，返回一個新的 Stream 對象（可以有多次轉(zhuǎn)換），這就允許對其操作可以像鏈條一樣排列闸迷，變成一個管道嵌纲。

獲取流

java.util.stream.Stream<T>是Java 8新加入的最常用的流接口。（這并不是一個函數(shù)式接口腥沽。）
獲取一個流非常簡單逮走，有以下幾種常用的方式：

所有的Collection集合(單列集合)都可以通過stream默認方法獲取流；
default Stream<E> stream?()
Stream接口的靜態(tài)方法of可以獲取數(shù)組對應(yīng)的流今阳。
static <T> Stream<T> of?(T... values)
參數(shù)是一個可變參數(shù),那么我們就可以傳遞一個數(shù)組

public static void main(String[] args) {
        //把集合轉(zhuǎn)換為Stream流
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();

        Set<String> set = new HashSet<>();
        Stream<String> stream2 = set.stream();

        Map<String,String> map = new HashMap<>();
        //獲取鍵,存儲到一個Set集合中
        Set<String> keySet = map.keySet();
        Stream<String> stream3 = keySet.stream();

        //獲取值,存儲到一個Collection集合中
        Collection<String> values = map.values();
        Stream<String> stream4 = values.stream();

        //獲取鍵值對(鍵與值的映射關(guān)系 entrySet)
        Set<Map.Entry<String, String>> entries = map.entrySet();
        Stream<Map.Entry<String, String>> stream5 = entries.stream();

        //把數(shù)組轉(zhuǎn)換為Stream流
        Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5);
        //可變參數(shù)可以傳遞數(shù)組
        Integer[] arr = {1,2,3,4,5};
        Stream<Integer> stream7 = Stream.of(arr);
        String[] arr2 = {"a","bb","ccc"};
        Stream<String> stream8 = Stream.of(arr2);
    }

常用方法

流模型的操作很豐富师溅，這里介紹一些常用的API。這些方法可以被分成兩種：

延遲方法：返回值類型仍然是 Stream 接口自身類型的方法盾舌，因此支持鏈?zhǔn)秸{(diào)用墓臭。（除了終結(jié)方法外，其余方法均為延遲方法妖谴。）
終結(jié)方法：返回值類型不再是 Stream 接口自身類型的方法窿锉，因此不再支持類似 StringBuilder 那樣的鏈?zhǔn)秸{(diào) 用。本小節(jié)中膝舅，終結(jié)方法包括 count 和 forEach 方法嗡载。

1.逐一處理：forEach:

Stream流中的常用方法：forEach
void forEach(Consumer<? super T> action);
該方法接收一個Consumer接口函數(shù)，會將每一個流元素交給該函數(shù)進行處理仍稀。
Consumer接口是一個消費型的函數(shù)式接口,可以傳遞Lambda表達式,消費數(shù)據(jù)

簡單記:
forEach方法,用來遍歷流中的數(shù)據(jù)
是一個終結(jié)方法,遍歷之后就不能繼續(xù)調(diào)用Stream流中的其他方法

    public static void main(String[] args) {
        //獲取一個Stream流
        Stream<String> stream = Stream.of("張三", "李四", "王五", "趙六", "田七");
        //使用Stream流中的方法forEach對Stream流中的數(shù)據(jù)進行遍歷
        stream.forEach((String name)->{
            System.out.println(name);
        });
        //簡化
        stream.forEach(name->System.out.println(name));
    }

2.過濾：?lter

Stream流中的常用方法：filter:用于對Stream流中的數(shù)據(jù)進行過濾
Stream<T> filter(Predicate<? super T> predicate);
filter方法的參數(shù)Predicate是一個函數(shù)式接口,所以可以傳遞Lambda表達式,對數(shù)據(jù)進行過濾
Predicate中的抽象方法:
boolean test(T t);

    public static void main(String[] args) {
        //創(chuàng)建一個Stream流
        Stream<String> stream = Stream.of("張三豐", "張翠山", "趙敏", "周芷若", "張無忌");
        //對Stream流中的元素進行過濾,只要姓張的人
        Stream<String> stream2 = stream.filter((String name)->{return name.startsWith("張");});
        //遍歷stream2流
        stream2.forEach(name-> System.out.println(name));

Stream流屬于管道流,只能被消費(使用)一次
第一個Stream流調(diào)用完畢方法,數(shù)據(jù)就會流轉(zhuǎn)到下一個Stream上
而這時第一個Stream流已經(jīng)使用完畢,就會關(guān)閉了
所以第一個Stream流就不能再調(diào)用方法了
IllegalStateException: stream has already been operated upon or closed

3.映射：map

Stream流中的常用方法：map:用于類型轉(zhuǎn)換
如果需要將流中的元素映射到另一個流中洼滚，可以使用map方法.
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
該接口需要一個Function函數(shù)式接口參數(shù)，可以將當(dāng)前流中的T類型數(shù)據(jù)轉(zhuǎn)換為另一種R類型的流技潘。
Function中的抽象方法:
R apply(T t);

     public static void main(String[] args) {
        //獲取一個String類型的Stream流
        Stream<String> stream = Stream.of("1", "2", "3", "4");
        //使用map方法,把字符串類型的整數(shù),轉(zhuǎn)換(映射)為Integer類型的整數(shù)
        Stream<Integer> stream2 = stream.map((String s)->{
            return Integer.parseInt(s);
        });
        //遍歷Stream2流
        stream2.forEach(i-> System.out.println(i));
    }

4.統(tǒng)計個數(shù)：count

Stream流中的常用方法_count:用于統(tǒng)計Stream流中元素的個數(shù)
long count();
count方法是一個終結(jié)方法,返回值是一個long類型的整數(shù)
所以不能再繼續(xù)調(diào)用Stream流中的其他方法了

    public static void main(String[] args) {
        //獲取一個Stream流
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        Stream<Integer> stream = list.stream();
        long count = stream.count();
        System.out.println(count);//7
    }

5.取用前幾個：limit

Stream流中的常用方法_limit:用于截取流中的元素
limit方法可以對流進行截取遥巴，只取用前n個。方法簽名：
Stream<T> limit(long maxSize);
參數(shù)是一個long型享幽，如果集合當(dāng)前長度大于參數(shù)則進行截炔；否則不進行操作
limit方法是一個延遲方法,只是對流中的元素進行截取,返回的是一個新的流,所以可以繼續(xù)調(diào)用Stream流中的其他方法

    public static void main(String[] args) {
        //獲取一個Stream流
        String[] arr = {"美羊羊","喜羊羊","懶羊羊","灰太狼","紅太狼"};
        Stream<String> stream = Stream.of(arr);
        //使用limit對Stream流中的元素進行截取,只要前3個元素
        Stream<String> stream2 = stream.limit(3);
        //遍歷stream2流
        stream2.forEach(name-> System.out.println(name));
    }

6.跳過前幾個：skip

Stream流中的常用方法_skip:用于跳過元素
如果希望跳過前幾個元素值桩，可以使用skip方法獲取一個截取之后的新流：
Stream<T> skip(long n);
如果流的當(dāng)前長度大于n迹炼，則跳過前n個；否則將會得到一個長度為0的空流颠毙。

    public static void main(String[] args) {
        //獲取一個Stream流
        String[] arr = {"美羊羊","喜羊羊","懶羊羊","灰太狼","紅太狼"};
        Stream<String> stream = Stream.of(arr);
        //使用skip方法跳過前3個元素
        Stream<String> stream2 = stream.skip(3);
        //遍歷stream2流
        stream2.forEach(name-> System.out.println(name));
    }

組合：concat

Stream流中的常用方法_concat:用于把流組合到一起
如果有兩個流斯入，希望合并成為一個流，那么可以使用Stream接口的靜態(tài)方法concat
static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)

    public static void main(String[] args) {
        //創(chuàng)建一個Stream流
        Stream<String> stream1 = Stream.of("張三豐", "張翠山", "趙敏", "周芷若", "張無忌");
        //獲取一個Stream流
        String[] arr = {"美羊羊","喜羊羊","懶羊羊","灰太狼","紅太狼"};
        Stream<String> stream2 = Stream.of(arr);
        //把以上兩個流組合為一個流
        Stream<String> concat = Stream.concat(stream1, stream2);
        //遍歷concat流
        concat.forEach(name-> System.out.println(name));
    }

day06(1)Stream流