Java 函數式編程（三）流（Stream）

本文已受權"後端技術精選"獨家發佈。

流使程序猿能夠在抽象層上對集合進行操做。

從外部迭代到內部迭代

什麼是外部迭代和內部迭代呢？

我的認爲，外和內是相對集合代碼而言。

若是迭代的業務執行在應用代碼中，稱之爲外部迭代。

反之，迭代的業務執行在集合代碼中，稱爲內部迭代（函數式編程）。

語言描述可能有點抽象，下面看實例。

1. 外部迭代

調用itrator方法，產生一個新的Iterator對象，進而控制整個迭代過程。

for (Student student:list){
    if (student.getAge()>18){
        result++;
    }
}
複製代碼

咱們都知道，for其實底層使用的迭代器：

Iterator<Student> iterator = list.iterator();
while (iterator.hasNext()){
    Student student = iterator.next();
    if (student.getAge()>18){
        result++;
    }
}
複製代碼

上面的迭代方法就是外部迭代。

外部迭代缺點：

1. 很難抽象出複雜操做
2. 本質上講是串行化操做。

2. 內部迭代

返回內部迭代中的響應接口：Stream

long count = list.stream().filter(student -> student.getAge() > 18).count();
複製代碼

整個過程被分解爲：過濾和計數。

要注意：返回的Stream對象不是一個新集合，而是建立新集合的配方。

2.1 惰性求值和及早求值

像filter這樣值描述Stream，最終不產生新集合的方法叫作惰性求值。 像count這樣最終會從Stream產生值的方法叫作及早求值。

判斷一個操做是惰性操做仍是及早求值，只需看它的返回值。若是返回值是Stream，那麼是惰性求值；若是返回值是另外一個值或者爲空，那就是及早求值。這些操做的理想方式就是造成一個惰性求值的鏈，最後用一個及早求值的操做返回想要的結果。

整個過程跟建造者模式很像，使用一系列的操做後最後調用build方法才返回真正想要的對象。設計模式快速學習（四）建造者模式

那這個過程有什麼好處呢：能夠在集合類上級聯多種操做，但迭代只須要進行一次。

3. 經常使用操做

3.1 collect(toList()) 及早求值

collect(toList())方法由Stream裏的值生成一個列表，是一個及早求值操做。

List<String> collect = Stream.of("a", "b", "c").collect(Collectors.toList());
複製代碼

Stream.of("a", "b", "c")首先由列表生成一個Stream對象，而後collect(Collectors.toList())生成List對象。

3.2 map

map能夠將一種類型的值轉換成另外一種類型。

List<String> streamMap = Stream.of("a", "b", "c").map(String -> String.toUpperCase()).collect(Collectors.toList());
複製代碼

map(String -> String.toUpperCase())將返回全部字母的大寫字母的Stream對象，collect(Collectors.toList())返回List。

3.3 filter過濾器

遍歷並檢查其中的元素時，可用filter

List<String> collect1 = Stream.of("a", "ab", "abc")
        .filter(value -> value.contains("b"))
        .collect(Collectors.toList());
複製代碼

3.4 flatMap

若是有一個包含了多個集合的對象但願獲得全部數字的集合，咱們能夠用flatMap

List<Integer> collect2 = Stream.of(asList(1, 2), asList(3, 4))
        .flatMap(Collection::stream)
        .collect(Collectors.toList());
複製代碼

Stream.of(asList(1, 2), asList(3, 4))將每一個集合轉換成Stream對象，而後.flatMap處理成新的Stream對象。

3.5 max和min

看名字就知道，最大值和最小值。

Student student1 = list.stream()
        .min(Comparator.comparing(student -> student.getAge()))
        .get();
複製代碼

java8提供了一個Comparator靜態方法，能夠藉助它實現一個方便的比較器。其中Comparator.comparing(student -> student.getAge()能夠換成Comparator.comparing(Student::getAge)成爲更純粹的lambda。max同理。

3.6 reduce

reduce操做能夠實現從一組值中生成一個值，在上述例子中用到的count、min、max方法事實上都是reduce操做。

Integer reduce = Stream.of(1, 2, 3).reduce(0, (acc, element) -> acc + element);
System.out.println(reduce);

6
複製代碼

上面的例子使用reduce求和，0表示起點，acc表示累加器，保存着當前累加結果（每一步都將stream中的元素累加至acc），element是當前元素。

4. 操做整合

1. collect(toList())方法由Stream裏的值生成一個列表
2. map能夠將一種類型的值轉換成另外一種類型。
3. 遍歷並檢查其中的元素時，可用filter
4. 若是有一個包含了多個集合的對象但願獲得全部數字的集合，咱們能夠用flatMap
5. max和min
6. reduce（不經常使用）

5. 鏈式操做實戰

List<Student> students = new ArrayList<>();
students.add(new Student("Fant.J",18));
students.add(new Student("小明",19));
students.add(new Student("小王",20));
students.add(new Student("小李",22));
List<Class> classList = new ArrayList<>();
classList.add(new Class(students,"1601"));
classList.add(new Class(students,"1602"));
複製代碼

static class Student{
        private String name;
        private Integer age;
        getter and setter ...and construct ....
    }

    static class Class{
        private List<Student> students;
        private String className;
        getter and setter ...and construct ....
    }
複製代碼

這是咱們的數據和關係--班級和學生，如今我想要找名字以小開頭的學生，用stream鏈式操做：

List<String> list= students.stream()
                            .filter(student -> student.getAge() > 18)
                            .map(Student::getName)
                            .collect(Collectors.toList());
複製代碼

[小明, 小王, 小李]
複製代碼

這是一個簡單的students對象的Stream的鏈式操做實現，那若是我想要在許多個class中查找年齡大於18的對象呢？

6. 實戰提高

在許多個class中查找年齡大於18的名字並返回集合。

原始代碼：

List<String> nameList = new ArrayList<>();
        for (Class c:classList){
            for (Student student:c.getStudents()){
                if (student.getAge()>18){
                    String name = student.getName();
                    nameList.add(name);
                }
            }
        }

        System.out.println(nameList);
複製代碼

鏈式流代碼： 若是讓你去寫，你可能會classList.stream().forEach(aClass -> aClass.getStudents().stream())....去實現？

我剛開始就是這樣無腦幹的，後來我緩過神來，想起foreach是一個及早求值操做，並且返回值是void，這樣的開頭就註定了沒有結果，而後仔細想一想，flatMap不是用來處理不是一個集合的流嗎，好了，就有了下面的代碼。

List<String> collect = classList.stream()
        .flatMap(aclass -> aclass.getStudents().stream())
        .filter(student -> student.getAge() > 18)
        .map(Student::getName)
        .collect(toList());
複製代碼

原始代碼和流鏈式調用相比，有如下缺點：

1. 代碼可讀性差，隱匿了真正的業務邏輯
2. 須要設置無關變量來保存中間結果
3. 效率低，每一步都及早求值生成新集合
4. 難於並行化處理

7. 高階函數及注意事項

高階函數是指接受另一個函數做爲參數，或返回一個函數的函數。若是函數的函數裏包含接口或返回一個接口，那麼該函數就是高階函數。

Stream接口中幾乎全部的函數都是高階函數。好比：Comparing 接受一個函數做爲參數，而後返回Comparator接口。

Student student = list.stream().max(Comparator.comparing(Student::getAge)).get();

public interface Comparator<T> {}
複製代碼

foreach方法也是高階函數：

void forEach(Consumer<? super T> action);

public interface Consumer<T> {}
複製代碼

除了以上還有一些相似功能的高階函數外，不建議將lambda表達式傳給Stream上的高階函數，由於大部分的高階函數這樣用會有一些反作用：給變量賦值。局部變量給成員變量賦值，致使很難察覺。

這裏拿ActionEvent舉例子：