Jdk8中Stream流的使用，讓你脫離for循環

學習要求：
知道一點兒函數式接口和Lambda表達式的基礎知識，有利於更好的學習。

1.先體驗一下Stream的好處

需求：給你一個ArrayList用來保存學生的成績，讓你打印出其中大於60的成績。

public static void main(String[] args) {
        ArrayList<Integer> arrList = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            arrList.add((int) (Math.random() * 100));
        }

        printValue1(arrList);

    }

解決方案一：
固然就是遍歷這個ArrayList，而後使用if判斷一下，若是其大於60，就將其輸出，代碼以下：

private static void printValue1(ArrayList<Integer> arrList) {
        for (Integer i : arrList) {
            if (i > 60) {
                System.out.printf("%d ",i);
            }
        }
    }

解決方案二：
使用Stream流操做，只須要一行代碼

/**
     * 使用Stream操做
     *
     * @param arrList
     */
    private static void printValue2(ArrayList<Integer> arrList) {
        arrList.stream().filter(i -> i > 60).forEach(System.out::println);
    }

2.什麼是Stream流？

在Jdk1.8中引入了stream流的概念，這個「流」並不一樣於IO中的輸入和輸出流，它是Jdk中的一個類，具體位置在：java.util.stream.Stream
關於它的操做主要分爲三種：獲取流、中間操做、最終操做

2.1 如何獲取流？

所謂獲取流，就是將其餘對象（非Stream對象）轉爲Stream對象。只有兩類對象可能轉化爲Stream對象，分別是：

• 數組（這個數組中的元素必須是引用類型）

Integer[] iArr = {12, 14, 15, 15, 17, 19, 22};
   Stream<Integer> stream1 = Stream.of(iArr);

• 集合

List<T> list = new ArrayList<T>();
Stream<T> stream = list.stream();

2.2 中間操做(返回的是一個新的Stream對象)

從上邊獲取這個流對象時，咱們就能夠這個Stream對象進行操做，在執行結束操做前，能夠無限次的執行這個操做。在開發工具中能夠看到這個類的源碼，它的主要有如下幾種操做：

細心的話，你會發現，這個類的大多數方法中的參數全都是一個函數式接口（具體能夠看上一篇文章），因此這就是爲何可使用Lambda表達式的緣由

• map 將一種類型的值轉換成另一種類型，並返回一個新的Stream

// 將集合中的字符串裝換成大寫形式
        Stream<String> stream0 = Stream.of("a", "b", "hello")
                .map(new Function<String, String>() {
                    @Override
                    public String apply(String s) {
                        return s.toUpperCase();
                    }
                });
        //上邊的代碼可使用Lambda表達式簡寫爲以下格式
        Stream<String> stream = Stream.of("a", "b", "hello")
                .map(s -> s.toUpperCase());

因此，請必定要懂得Lambda表達式的操做

• filter 遍歷數據並檢查、過濾其中的元素

// 過濾字符串集合中長度大於1的數據

Stream<String> stream1 = Stream.of("a", "abc", "abcdefg")
                .filter(value -> value.length() > 1);

• flatMap 可用Stream替換值，而後將多個Stream鏈接成一個Stream，會將以前生成Stream流的每個元素更換爲一個新的Stream對象。

Stream<Integer> stream2 = Stream.of(1, 2)
                .flatMap(numbers -> Stream.of(5, 6, 6, 7, 8));

上邊代碼會生成的Stream中，會將1,2替換爲5,6,7,8,5,6,7,8

• 其餘的常見操做還有：

stream.limit(5) //限制，只取前幾個元素
                .skip(1) //跳過,表示跳過前幾個元素
                .distinct() //去重
                .sorted() //天然排序
                .sorted(Integer::compareTo)//自定義排序

2.3 最終操做

最終操做就是達到咱們想要的結果，包括打印、轉爲其餘對象（主要是集合，還有函數式接口的子類對象）等。只能執行一次，執行完閉後，不能再執行其餘操做。

• reduce 通常用於計算累加的，以下代碼

// 獲取累加的值，reduce第一個參數是初始值
        Integer count = Stream.of(1, 2, 3)
                .reduce(0, (o1, o2) -> o1 + o2);
        System.out.println(count);//6

• collect 將流轉換爲其餘形式。參數是傳入Collectors的一些靜態方法，好比如下：

Set<Integer> collect = stream.collect(Collectors.toSet());
List<Integer> collect2 = stream.collect(Collectors.toList());
HashSet<Integer> collect1 = stream.collect(Collectors.toCollection(HashSet::new));

List<Integer> list = Stream.of(1, 2)
                .collect(Collectors.toList());

• forEach 遍歷這個流對象中的元素

Stream.of(1, 2).forEach(i -> System.out.print(i));
        System.out.println();
        //上邊格式可使用靜態方法引用的方法簡化
        Stream.of(1, 2).forEach(System.out::print);

最後，寫一個簡單的例子，比較一下，咱們使用以前的遍歷操做和使用Stream流操做的簡潔性與性能問題
代碼地址
去掉最大和最小差值，相比之下 ，Stream流的操做要比使用迭代器操做慢一點兒，可是這是很小的差異