JAVA8给我带了什么——流（入门）

时间 2019-12-04

标签 java8 java 什么入门栏目 Java 繁體版

原文原文链接

JAVA8有一个新功能——流。笔者简单的看一下流。而后默默的闭上眼睛。感叹一声：这不是.NET里面的Linq吗？若是大家当中有谁作过.NET程序员的话，对于流的学习其实帮助是很大的。可是要明白你如今是在学JAVA的流。虽然他们的概念是有一点像。但是这也只是对你在理解流上面有必定的帮助。由于JAVA实现的方式却完成不同子（不入流程序员的我的理解）。java

好吧。那么流是什么呢？若是用书里面的方式解释的话，笔者可能也看不懂。作过开发的人员通常都会知道一些SQL语句吧，SELECT语句这个功能。相信你们必定都熟悉吧——SELECT是对数据库的数据进行操做。一样子JAVA也有数据啊。好比集合、数组。那么为何JAVA不可能实现一套代码式的数据操做。若是这样子不知道你们会不会明白呢？（固然这不是官方，是不入流的程序员这样了理解的）
SQL语句里面有什么——SELECT、FORM、WHERE、ORDER BY、GROUP BY。这些都是对数据库里面数据操做的常规动做。JAVA8的流呢？即然是流。那么说明必须把对应的数据变成一个流才行。关键方法stream()就是这个做用。举例子来讲明吧。笔者有一组字符数组，笔者相要查找出有含有 r 的字符。程序员

 1 package com.aomi;
 2 
 3 import java.util.Arrays;
 4 import java.util.List;
 5 
 6 public class Main {
 7 
 8     public static void main(String[] args) {
 9         // TODO Auto-generated method stub
10 
11         List<String> datas = Arrays.asList("red", "green", "bule");
12 
13         datas
14         .stream()
15         .filter(s -> s.contains("r"))
16         .forEach(s -> System.out.println(s));
17     }
18 
19 }

运行结果：数据库

让咱们想一想若是是之前的话，要什么样子去实现呢？数组

 1 package com.aomi;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Arrays;
 5 import java.util.List;
 6 
 7 public class Main {
 8 
 9     public static void main(String[] args) {
10         // TODO Auto-generated method stub
11 
12         List<String> datas = Arrays.asList("red", "green", "bule");
13 
14 //        datas
15 //        .stream()
16 //        .filter(s -> s.contains("r"))
17 //        .forEach(s -> System.out.println(s));
18 
19         List<String> vDatas = new ArrayList<>();
20 
21         for (String str : datas) {
22             if (str.contains("r")) {
23                 vDatas.add(str);
24             }
25         }
26 
27         for (String str : vDatas) {
28             System.out.println(str);
29         }
30 
31     }
32 
33 }

相对之前来说很直观表现代码的意思。同时代码量又小不少。app

filter：用于过滤数据的，从下面的代码就能够明白，返回一个boolean型类的结果。

Stream<T> filter(Predicate<? super T> predicate);

forEach：循环遍历回来的结果集合。代码看完就知道什么样子用了。

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

JAVA的代不少都是很人性化的，因此只要从名字就能够明白他大概的功能了。函数

好了，笔者忽然有一个想法——想要把时面的‘r’字符变成‘o’字符。学习

 1 package com.aomi;
 2 
 3 import java.util.Arrays;
 4 import java.util.List;
 5 
 6 public class Main {
 7 
 8     public static void main(String[] args) {
 9         // TODO Auto-generated method stub
10 
11         List<String> datas = Arrays.asList("red", "green", "bule");
12 
13         datas.stream()
14         .map(s -> s.replace('r', 'o'))
15         .forEach(s -> System.out.println(s));
16 
17     }
18 
19 }

笔者去掉了filter方法，用了map。运行结果：this

map:至关于SQL中的 SELECT关键字有一点像。用于把结果变成你但愿的样子。看一下代码

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

是一个function的函数式接口。函数描述符：T -> R。
显示这样子的例子有一点简单。在实际的开发过程当中咱们每每都是一大波数据对象。这样子笔者定义一个学生类。spa

package com.aomi;

public class Student {
    private String name;
    private int Sex;
    private String phone;
    private int score;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getSex() {
        return Sex;
    }
    public void setSex(int sex) {
        Sex = sex;
    }
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
    
    
}

在来写一个数据源吧。3d

 1 package com.aomi;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Arrays;
 5 import java.util.List;
 6 
 7 public class Main {
 8 
 9     public static List<Student> getSources()
10     {
11         List<Student> students =new ArrayList<>();
12         
13         Student stu1 = new Student();
14         
15         stu1.setName("lucy");
16         stu1.setSex(0);
17         stu1.setPhone("13700227892");
18         stu1.setScore(9);
19         
20         Student stu2 = new Student();
21         stu2.setName("lin");
22         stu2.setSex(1);
23         stu2.setPhone("15700227122");
24         stu2.setScore(9);
25         
26         Student stu3 = new Student();
27         stu3.setName("lili");
28         stu3.setSex(0);
29         stu3.setPhone("18500227892");
30         stu3.setScore(8);
31         
32         Student stu4 = new Student();
33         
34         stu4.setName("dark");
35         stu4.setSex(1);
36         stu4.setPhone("16700555892");
37         stu4.setScore(6);
38         
39         
40         students.add(stu1);
41         students.add(stu2);
42         students.add(stu3);
43         students.add(stu4);
44         
45         return students;
46     }
47 
48 }

笔者定义了四个学生。这样子时候笔者想看看学分（Score）大于6同窗的名字有哪一些。从上面代码咱们能够看到除了第四个同窗drak以后，其余都是合格的。让咱们看一下代码

 1 package com.aomi;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 import static java.util.stream.Collectors.toList;
 6 
 7 public class Main {
 8 
 9     public static void main(String[] args) {
10         // TODO Auto-generated method stub
11 
12         List<Student> stus = getSources();
13 
14         List<String> names = stus.stream()
15                 .filter(stu -> stu.getScore() > 6)
16                 .map(stu -> stu.getName())
17                 .collect(toList());
18 
19         for (String name : names) {
20             System.out.println(name);
21         }
22 
23     }
24 
25     public static List<Student> getSources() {
26         List<Student> students = new ArrayList<>();
27 
28         Student stu1 = new Student();
29 
30         stu1.setName("lucy");
31         stu1.setSex(0);
32         stu1.setPhone("13700227892");
33         stu1.setScore(9);
34 
35         Student stu2 = new Student();
36         stu2.setName("lin");
37         stu2.setSex(1);
38         stu2.setPhone("15700227122");
39         stu2.setScore(9);
40 
41         Student stu3 = new Student();
42         stu3.setName("lili");
43         stu3.setSex(0);
44         stu3.setPhone("18500227892");
45         stu3.setScore(8);
46 
47         Student stu4 = new Student();
48 
49         stu4.setName("dark");
50         stu4.setSex(1);
51         stu4.setPhone("16700555892");
52         stu4.setScore(6);
53 
54         students.add(stu1);
55         students.add(stu2);
56         students.add(stu3);
57         students.add(stu4);
58 
59         return students;
60     }
61 
62 }

运行结果：

当咱们看到这个例子的时候，咱们就能够肯定map是作什么。就是用于最后肯定返回数据类型。在这个代码中。笔者又用到了一个叫collect的方法。

collect:用于收集数据的功能。便是把相关的数据汇总成为另外一种数据。

笔者传入是toList()方法。把最后数据变成一个集合。这个方法是Collectors类的一个静态方法。固然Collectors类里面有不少静态方法。若是大家去看一下他的代码。你就会发现他的方法名字好像都是在对数据操做的样子。没有错。之后咱们开发过程都会用到Collectors类的方法集。
记得引用下面代码

import static java.util.stream.Collectors.toList;

从上面的几个例子来看。让笔者感受以下

stream相关于SQL里面的FROM
filter至关于SQL里面的WHERE.
map至关于SQL里面的SELECT

那么其余呢？好比 order by或 group by 。让咱们接着看吧。

如今笔者想在按学分（Score）高到低排序而且只显示学生名和学分呢？

package com.aomi;

import static java.util.Comparator.comparing;
import static java.util.stream.Collectors.toList;

import java.util.ArrayList;
import java.util.List;

public class SMain {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        List<Student> stus = getSources();

        List<String> names = stus.stream() .sorted(comparing(Student::getScore).reversed()) .map(stu -> "学名："+stu.getName()+"  学分："+stu.getScore()) .collect(toList()); for (String name : names) {
            System.out.println(name);
        }

    }

    public static List<Student> getSources() {
        List<Student> students = new ArrayList<>();

        Student stu1 = new Student();

        stu1.setName("lucy");
        stu1.setSex(0);
        stu1.setPhone("13700227892");
        stu1.setScore(9);

        Student stu2 = new Student();
        stu2.setName("lin");
        stu2.setSex(1);
        stu2.setPhone("15700227122");
        stu2.setScore(9);

        Student stu3 = new Student();
        stu3.setName("lili");
        stu3.setSex(0);
        stu3.setPhone("18500227892");
        stu3.setScore(8);

        Student stu4 = new Student();

        stu4.setName("dark");
        stu4.setSex(1);
        stu4.setPhone("16700555892");
        stu4.setScore(6);

        students.add(stu1);
        students.add(stu2);
        students.add(stu3);
        students.add(stu4);

        return students;
    }
}

运行结果：

关于上面sorted的用法。笔者上面已经讲过了。
如今笔者想看看男女各位的学习状况。又要如何。来分个组吧。

 1 package com.aomi;
 2 
 3 import static java.util.stream.Collectors.groupingBy;
 4 
 5 import java.util.ArrayList;
 6 import java.util.List;
 7 
 8 public class SMain {
 9 
10     public static void main(String[] args) {
11         // TODO Auto-generated method stub
12 
13         List<Student> stus = getSources();
14 
15         stus.stream()
16         .collect(groupingBy(ss -> ss.getSex())).
17         forEach((Integer sex, List<Student> students) -> {
18             System.out.println("sex:" + sex);
19 
20             for (Student student : students) {
21                 System.out.println("name:" + student.getName() + "  score:" + student.getScore());
22             }
23         });
24 
25     }
26 
27 //去掉学生源的方法。太多了影响查看
28 }

结果：

即然都分组了。那就笔者在作一个业务。查看男女个组的人数。

package com.aomi;

import static java.util.stream.Collectors.groupingBy;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class SMain {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        List<Student> stus = getSources();

        stus.stream().collect(groupingBy(ss -> {
            if (ss.getSex() == 0)
                return "女";
            else
                return "男";
        }, Collectors.counting()))
        .forEach((String sex, Long count) -> {
            System.out.println("sex:" + sex + "  count:" + count);

        });

    }
......
.....//去掉数据源
.....

}

运行结果：

在来一个分组以后，男女个组的总分。

package com.aomi;

import static java.util.stream.Collectors.groupingBy;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class SMain {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        List<Student> stus = getSources();

        stus.stream().collect(groupingBy(ss -> {
            if (ss.getSex() == 0)
                return "女";
            else
                return "男";
        }, Collectors.summingLong(t -> t.getScore())))
        .forEach((String sex, Long sum) -> {
            System.out.println("sex:" + sex + "  count:" + sum);

        });

    }

    。。。。。
}

运行结果：

经过这俩个例子，咱们就能够明白一个道理。groupingBy的第二个参数，是一个任何型类的收集器。也就是说分组以后，你能够在进行对分组以后的结果进处理。

好了。大家有没有感受跟SQL语句的功能很像呢？以下

stream相关于SQL里面的FROM
filter至关于SQL里面的WHERE.
map至关于SQL里面的SELECT
sorted至关于SQL里面的Order BY
Collectors.groupingBy至关于SQL里面的GROUP BY
Collectors.summingLong至关于SQL里面的SUM函数。只不过他又加了一步结果转为Long类型
Collectors.counting至关于SQL里面的COUNT函数

理解了上面代码的基础用法的概念以后，咱们接下要一步步去看看JAVA8流的思想。