• 前言：

講Stream之前，先來用個(gè)小需求帶入本文。畢竟代碼看的最清楚。

• 正文：

項(xiàng)目某個(gè)頁面有個(gè)需求，將關(guān)鍵詞和集合比對(duì)，判斷是否存在關(guān)鍵詞，這種需求想必是再普通不過，最簡單的就是循環(huán)迭代了。
上來就干，普通for循環(huán)，判斷：

 for (int i = 0; i < airPortModels1.size(); i++) {
                    if (airPortModels1.get(i).getAirport().contains(searchWord)) {
                        searchList.add(airPortModels1.get(i).getAirport());
                        searchAirPort.add(airPortModels1.get(i));
                    }
                }```
要么就用增強(qiáng)型for循環(huán)

for (SkiModel skiModel : airPortModels1) {
if (skiModel.getPark().equals(searchWord)) {
searchList.add(skiModel.getPark());
searchAirPort.add(skiModel);
}
}```
都是遍歷每個(gè)元素，進(jìn)行比對(duì)，而集合內(nèi)所有元素都是存儲(chǔ)于內(nèi)存中，如果集合比較大，則比較耗費(fèi)內(nèi)存，那么可以使用Stream
利用Stream：

                    airPortModels1
                            .stream()
                            .filter(skiModel -> skiModel.getPark().equals(searchWord))
                            .forEach(skiModel -> {
                                searchList.add(skiModel.getPark());
                                searchAirPort.add(skiModel);
                            });```


- #####Stream，源碼分析：

A sequence of elements supporting sequential and parallel aggregate operations
一個(gè)集合流，支持順序和并行聚合操作```
Stream理解起來就是高級(jí)的迭代器，普通迭代器就是遍歷元素，然后逐一進(jìn)行某個(gè)操作；而Stream可以根據(jù)一些特定條件，對(duì)元素進(jìn)行操作，例如過濾Value小于5的元素，獲取首字母為大寫的元素，都可以交給Stream來進(jìn)行。
還是以例子來說明：( 后面都會(huì)通過這個(gè)例子來講解)

  List<Integer> list = Arrays.asList(2, 3, 4, 55, -1, 0, null);
  list.stream().filter(integer -> integer > 0).count();///過濾出所有大于0的元素，最后得到個(gè)數(shù)。```
Stream在這里主要做了兩件事情。
第一、把所有元素獲取到
第二、把大于0的元素過濾出來。
**我們最后調(diào)用count()就是獲取結(jié)果，相當(dāng)于獲取新的List的size。只是相當(dāng)于，僅僅為了利于我們理解方便，實(shí)際上，Stream并沒有new一個(gè)新List。我們要做的事情就是，獲取到Stream，告訴Stream我們要做什么，然后問Stream要結(jié)果。**
來分析Stream的語法：
將  list.stream().filter(integer -> integer > 0).count()分為三部分，
**list.stream()**   ---------先創(chuàng)建Stream
**filter(integer -> integer > 0)** --------------轉(zhuǎn)換Stream，將創(chuàng)建的Stream進(jìn)行轉(zhuǎn)換，返回新的Stream，可以進(jìn)行多次轉(zhuǎn)換
**count()**---------處理Stream，將轉(zhuǎn)換后的Stream進(jìn)行匯聚，得到想要的結(jié)果
**而且最后.count()也是必不可少的，如果不向Stream索取結(jié)果，沒有需求，它什么都不會(huì)干的，就像項(xiàng)目經(jīng)理向你提需求一樣**
所以講解Stream也分為這三個(gè)步驟：
##### 1.創(chuàng)建Stream：
###### 1.1通過Collection的stream()方法，Collection對(duì)象轉(zhuǎn)換成Stream，也就是例子中的方法
list.stream();

default Stream<E> stream() {
return StreamSupport.stream(spliterator(), false);
}```

1.2 通過Stream的靜態(tài)方法創(chuàng)建：

1.2.1 Stream的of方法，共有兩個(gè)方法，一個(gè)接受變長參數(shù)，一個(gè)固定參數(shù)

public static<T> Stream<T> of(T t) {
        return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
    }

  @SafeVarargs
@SuppressWarnings("varargs") // Creating a stream from an array is safe
public static<T> Stream<T> of(T... values) {
        return Arrays.stream(values);
    }```
例如：

Stream<Integer> list= Stream.of(0,-3,9,20,2); //固定長度
Stream<String> list1= Stream.of("fdsfdas","sdfadd"); //變長參數(shù)```
1.2.2 Stream的generator方法 可以生成一個(gè)無限長度的Stream，但是 Android N之后才可以使用Generate方法

  public static<T> Stream<T> generate(Supplier<T> s) {
        Objects.requireNonNull(s);
        return StreamSupport.stream(
                new StreamSpliterators.InfiniteSupplyingSpliterator.OfRef<>(Long.MAX_VALUE, s), false);
    }```
例如:  

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) { //Android N之后才可以使用Generate方法
Stream.generate(new Supplier<Integer>() {
@Override
public Integer get() {
return (int) Math.random().forEach(System.out::print); //隨機(jī)生成無限長度的Stream
}
});
}```
或者 lambda表達(dá)式

 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            Stream.generate(() -> (int) Math.random()).forEach(System.out::print); //隨機(jī)生成無限長度的Stream
        }```
如果想要限制Stream的長度，可以使用limit()，后面會(huì)講到

Stream.generate(new Supplier<Integer>() {
@Override
public Integer get() {
return (int) Math.random();
}
}).limit(10).forEach(System.out::print);//生成長度為10的Stream，并打印```
1.2.3 創(chuàng)建一個(gè)規(guī)律數(shù)據(jù)的Stream

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            Stream.iterate(1, new UnaryOperator<Integer>() {
                @Override
                public Integer apply(Integer integer) {
                    return integer+1;  //打印1到10的數(shù)列
                }
            }).limit(10).forEach(System.out::print);
        }```

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {//打印11個(gè)hello字符串
        Stream.iterate("hello",UnaryOperator.identity()).limit(11).forEach(System.out::print);
    }```

2.轉(zhuǎn)換Stream：(為了更清晰理解每個(gè)方法的含義，每個(gè)方法都附帶一個(gè)例子)

1.filter 過濾操作
對(duì)Stream中元素使用給定的條件進(jìn)行過濾，生成只包含符合條件的元素的Stream；

List<Integer> list = Arrays.asList(2, 3, 4, 55, -1, 0, null);   
list.stream().filter(integer -> integer>0).count();//過濾掉不大于0的元素```
**2.map**  轉(zhuǎn)換操作

Arrays.asList("a","b","c","d")
.stream()
.map(s->s+"a,")
.forEach(System.out::print);
//打印出：aa,ba,ca,da,```
map具體有三個(gè)方法：mapToInt，mapToLong和mapToDouble。見名知意，例如mapToInt就是把原始Stream轉(zhuǎn)換成一個(gè)新的Stream，這個(gè)新生成的Stream中的元素都是int類型
例如:

        List<Integer> list = Arrays.asList(2, 3, 4, 55, -1, 0, 12);
        list.stream().mapToDouble(new ToDoubleFunction<Integer>() {
            @Override
            public double applyAsDouble(Integer value) {
                return value.doubleValue();  //返回所有元素都為Double類型的Stream
            }
        });```
**3.flatMap**   將高緯度變?yōu)榈途暥?

private static void flatMapStream() {
String [] s1 = {"a1","a2","a3"};
String [] s2 = {"b1","b2","b3"};
String [] s3 = {"c1","c2","c3"};
Arrays.asList(s1,s2,s3)
.stream()
.flatMap(str -> Stream.of(str))
.map(s -> s+"/")
.forEach(System.out::print); //打印出a1/a2/a3/b1/b2/b3/c1/c2/c3
}```
和map類似，也有flatMapToInt、flatMapToLong 、flatMapToDouble三個(gè)方法，不同的是flatmap中每個(gè)元素轉(zhuǎn)換后得到的是Stream對(duì)象，會(huì)把子Stream中的元素壓縮到父集合中；
例如：

   List<Integer> list = Arrays.asList(2, 3, 4, 55, -1, 0, null);
   if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            list.stream().flatMapToInt(new Function<Integer, IntStream>() {
                @Override
                public IntStream apply(Integer integer) {
                    return IntStream.of(integer);
                }
            });
        }```
**4.distinct** 去重
對(duì)Stream中的元素進(jìn)行去重操作，生成的Stream中沒有重復(fù)的元素；
例如：

    List<Integer> list = Arrays.asList(2, 3, 4, 55, -1, 0, null);
    long count = list.stream().distinct().count();```

5.sorted 排序
對(duì)Stream中元素進(jìn)行排序，得到排序之后的Stream,有空參和有參兩種方法

        //空參
        List<Integer> list = Arrays.asList(2, 3, 4, 55, -1, 0, 1);
        List<Integer> list1 = list.stream().sorted().collect(Collectors.toList());//排序得到新的集合``` 

    //有參
    List<Integer> list = Arrays.asList(2, 3, 4, 55, -1, 0, 1);
    list.stream().sorted(new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return Integer.compare(o1.intValue(), o2.intValue());
        }
    }).forEach(System.out::print); //按元素大小排序```

使用sorted()這個(gè)方法，要求Stream中的數(shù)據(jù)必須實(shí)現(xiàn)了Comparable接口
6.limit Stream進(jìn)行截?cái)嗖僮?/p>

        List<Integer> list = Arrays.asList(2, 3, 4, 55, -1, 0, 1);
        list.stream().limit(3).forEach(System.out::print);//截取前三個(gè)元素```
**7.skip** 跳過   跳過Stream前的n個(gè)元素，（*如果原Stream中包含的元素個(gè)數(shù)小于N，那么返回空Stream*）

 List<Integer> list = Arrays.asList(2, 3, 4, 55, -1, 0, 1);
list.stream().skip(2).forEach(System.out::print); //跳過前兩個(gè)元素，將剩余元素打印出來    

List<Integer> list = Arrays.asList(2, 3, 4, 55, -1, 0, 1);
list.stream().skip(10).forEach(System.out::print); //元素個(gè)數(shù)小于跳過的個(gè)數(shù)，返回空Stream

**8.peek** 生成一個(gè)包含原Stream的所有元素的新Stream,同時(shí)會(huì)提供一個(gè)消費(fèi)函數(shù)（Consumer實(shí)例），新Stream每個(gè)元素被消費(fèi)的時(shí)候都會(huì)執(zhí)行給定的消費(fèi)函數(shù)；

Stream<Integer> stream = list.stream().peek(new Consumer<Integer>() {
        @Override
        public void accept(Integer integer) {

        }
    });//生成新的Stream,并提供Cunsumer實(shí)例```

9.contact 合并操作，將兩個(gè)Stream合并為一個(gè)，且僅僅可以合并兩個(gè)Stream，

        List<Integer> list = Arrays.asList(2, 3, 4, 55, -1, 0, 1);
        List<String> list1 = Arrays.asList("a", "b","c","d");
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            Stream.concat(list.stream(), list1.stream())
                    .skip(10).forEach(System.out::print); //打印出23455-101abc
        }```
##### 3.處理Stream
    遍歷forEach
    聚合reduce
    Optional類型
    收集collect
**3.1 遍歷** 
forEach
forEachOrdered 兩個(gè)方法
**3.2.聚合** 可以實(shí)現(xiàn)從一組數(shù)據(jù)中生成一個(gè)數(shù)據(jù)(共有三種形式)
```T reduce(T identity, BinaryOperator<T> accumulator);
Optional<T> reduce(BinaryOperator<T> accumulator);
<U> U reduce(U identity,BiFunction<U, ? super T, U> accumulator,BinaryOperator<U> combiner);``` 

List<Integer> list = Arrays.asList(2, 3, 4, 55, -1, 0, 1);
list.stream().skip(4).reduce(1, new BinaryOperator<Integer>() {
@Override
public Integer apply(Integer integer, Integer integer2) {
return integer + integer2; //1和前四個(gè)元素的和
}
});```
3.3 Optional
Optional是一種容器，可以存儲(chǔ)一些值和null。利用這個(gè)類，可以進(jìn)行null的判斷，能夠有效的避免NullPointerException
get()`,可以拿到Optional中的值，沒有值則拋出空指針異常
isPresent(),有非空的值，返回true，否則返回false
ifPresent(),public void ifPresent(Consumer<? super T> consumer)這個(gè)方法中需要一個(gè)Consumer接口。如果有非空的值，就執(zhí)行指定的Consumer的方法來處理這個(gè)非空的值；如果為空，則啥都不做
3.4 收集Stream
可將轉(zhuǎn)換后的Stream轉(zhuǎn)為集合

        List<Integer> list = Arrays.asList(2, 3, 4, 55, -1, 0, 1);
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.N) {
            List<Integer> list1 = list.stream().skip(5).collect(Collectors.toList());
        }```
#### 最后，可以組合使用試試

List<Integer> list = Arrays.asList(2, 3, 4, 55, -1, 0, 1);
Stream<String> list1 = Stream
.of(Arrays.asList("2", "a", "a", "mm", "mm", "sde", "andoid")) //創(chuàng)建Stream
.skip(1) //跳過第一個(gè)元素
.distinct()//去重
.filter(strings -> strings.size() >= 1)//過濾元素小于1的元素
.map(strings -> strings + "hello") //每個(gè)元素加上“hello”字符串
.sorted((o1, o2) -> Integer.compare(o1.length(), o2.length())); //按字符串長度排序
Stream.concat(list1, list.stream()) //合并兩個(gè)Stream
.limit(8) //取前八個(gè)元素
.forEach(System.out::print);``` //處理Stream，打印每個(gè)元素