Stream类全路径为：java.util.stream.Stream

Stream简介

Java 8 中的 Stream 是对（Collection）集合对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作
或大批量数据操作。Stream API 借助于同样新出现的 Lambda 表达式，极大的提高编程效率和程序可读性。

Stream原理

这种编程风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选，排序，聚合等。
元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的
结果。

Stream优点

（1）速度更快
（2）代码更少（增加了新的语法Lambda表达式）
（3）强大的Stream API
（4）便于并行
（5）最大化减少了空指针异常Optional

Stream的操作三个步骤：

（1）创建Stream，一个数据源（如：集合、数组），获取一个流；
（2）中间操作，一个中间操作链，对数据源的数据进行处理；
（3）终止操作，一个终止操作，执行中间操作链，并产生结果。

集合有两种方式生成流：

stream() − 为集合创建串行流。

parallelStream() − 为集合创建并行流

-Stream的的中间操作（intermediate）和最终操作（terminal）都包含的方法:

1.中间操作（intermediate）主要有以下方法（此类型的方法返回的都是Stream对象）：

2.终端操作（terminal）主要有以下方法：

方法演示

中间操作（intermediate）

1.filter : 通过设置条件来过滤元素。

List<String> list = Arrays.asList("aaa","ddd","bbb","ccc","a2a","d2d","b2b","c2c","a3a","d3d","b3b","c3c");
list.stream().filter((s)->s.contains("a")).forEach(s -> System.out.println(s));

以上代码使用filter方法过滤出只包含”a”的元素，然后通过forEach将满足条件的元素遍历出来。输出如下：

aaa 
a2a 
a3a

2.map : 就是将对应的元素使用给定方法进行转换。

List<String> list = Arrays.asList("aaa","ddd","bbb","ccc","a2a","d2d","b2b","c2c","a3a","d3d","b3b","c3c");
list.stream().filter((s)->s.contains("a")).map((s)-> s + "---map").forEach(s -> System.out.println(s));

在filter的基础上，给每个元素后面添加字符串”—map”，输出如下：

aaa—map 
a2a—map 
a3a—map

3.flatMap：如果流的元素为数组或者Collection，flatMap就是将每个Object[]元素或Collection<Object>元素都转换为Object元素。

List<String[]> setList =  new ArrayList<>();
setList.add(new String[]{"aa","bb"});
setList.add(new String[]{"cc","dd"});
setList.add(new String[]{"ee","ff"});
//使用map方法
setList.stream().map(s->Arrays.stream(s)).forEach(s-> System.out.println("map==" + s));
//使用flatMap方法
setList.stream().flatMap(s->Arrays.stream(s)).forEach(s-> System.out.println("flatMap==" + s));

输出如下：

map==java.util.stream.ReferencePipeline&Head@50040f0c 
map==java.util.stream.ReferencePipeline&Head@2dda6444 
map==java.util.stream.ReferencePipeline&Head@5e9f23b4 
flatMap==aa 
flatMap==bb 
flatMap==cc 
flatMap==dd 
flatMap==ee 
flatMap==ff

map就是将数组流直接返回，flatMap是将数组流中的每个元素都返回。

4.distinct：将集合中的元素去重。

List<String> disList = Arrays.asList("aaa","ddd","bbb","ddd","aaa");
disList.stream().distinct().forEach(s-> System.out.println(s));

输出如下：

aaa 
ddd 
bbb

5.sorted：将集合中的元素排序。

List<Integer> integerList = Arrays.asList(2,4,1,3);
integerList.stream().sorted().forEach(s-> System.out.println(s));

输出如下：

1 
2 
3 
4

可以按照自定义排序：

List<Integer> integerList = Arrays.asList(2,4,1,3);
integerList.stream().sorted((s1,s2)->s2.compareTo(s1)).forEach(s-> System.out.println(s));

输出如下：

4 
3 
2 
1

6.peek：生成一个包含原Stream的所有元素的新Stream，同时会提供一个消费函数即引用的方法A，当Stream每个元素被消费的时候都会先
执行新Stream给定的方法A。peek是中间操作，如果peek后没有最终操作，则peek不会执行。

List<Integer> integerList = Arrays.asList(1,2,3,4);
integerList.stream().peek(s-> System.out.println("peek = "+s)).forEach(s-> System.out.println("forEach = "+s));

输出如下：

peek = 1 
forEach = 1 
peek = 2 
forEach = 2 
peek = 3 
forEach = 3 
peek = 4 
forEach = 4

7.limit：返回Stream的前n个元素。

List<Integer> integerList = Arrays.asList(1,2,3,4);
integerList.stream().limit(2).forEach(s-> System.out.println(s));

输出为：

1
2

8.skip：删除Stream的前n个元素。

List<Integer> integerList = Arrays.asList(1,2,3,4);
integerList.stream().skip(2).forEach(s-> System.out.println(s));

输出如下：

3 
4

终端操作（terminal）

1.forEach：遍历Stream中的每个元素，前面每个例子都有使用，此处不再演示。

List<Integer> integerList = Arrays.asList(1,2,3,4);
integerList.stream().skip(2).forEach(s-> System.out.println(s));

输出为：

1
2
3
4

2.forEachOrdered:遍历Stream中的每个元素。
区别： 在串行流（stream）中没有区别，在并行流（parallelStream）中如果数据源是有序集合，forEachOrdered输出顺序与数据源中顺序
一致，forEach则是乱序。

List<Integer> integerList = Arrays.asList(1,2,3,4);
integerList.parallelStream().forEachOrdered(s-> System.out.println(s));

输出（测试多次，每次都是这个结果，与integerList中的元素顺序一致）：

1
2
3
4

3.toArray：将流转换为Object[]或者指定类型的数组。

List<Integer> integerList = Arrays.asList(1,2,3,4);
Object[] array = integerList.stream().toArray();
String[] strArr = integerList.stream().toArray(String[]::new);

Stream中的toArray普通情况下和集合中的toArray没什么区别,但是Stream中的toArray转换为指定类型的数组。

4.reduce：将集合中的每个元素聚合成一条数据。有三种情况：

reduce(BinaryOperator accumulator)：此处需要一个参数，返回Optional对象：

Optional<Integer> reduce = integerList.stream().reduce((a, b) -> a + b);

reduce(T identity, BinaryOperator accumulator)：此处需要两个参数，第一个参数为起始值，第二个参数为引用的方法。从起始值开始，
每个元素执行一次引用的方法（方法引用的中的两个参数：第一个参数为上个元素执行方法引用的结果，第二个参数为当前元素）。

List<Integer> integerList = Arrays.asList(1,2,3,4);
int integer = integerList.stream().reduce(5,(a, b) -> a + b);
System.out.println(integer);

输出为：

15

此例中使用起始值为5，对集合中每个元素求和，可以理解为：5+1+2+3+4=15。

reduce：此处需要三个参数。此方法用在
并发流（parallelStream）中，启动多个子线程使用accumulator进行并行计算，最终使用combiner对子线程结果进行合并，返回identity类
型的数据。

5.collect：将流转换成集合或聚合元素。有两种情况。接受一个参数和接受三个参数（三个参数在并发流parallelStream中使用），此处介绍一个参数的情况，单个参数接受的参数类型为Collector，Collectors 类实现了很多归约操作

List<Integer> integerList = Arrays.asList(2,4,1,3);
List<Integer> integers = integerList.stream().filter(s -> s > 1).collect(Collectors.toList());
System.out.println(integers.toString());

此处统计集合中大于1的元素并最终返回list。输出如下：

[2, 4, 3]

6.min:获取集合中最小值。

List<Integer> integerList = Arrays.asList(2,4,1,3);
Integer min = integerList.stream().min(Integer::compareTo).get();
System.out.println(min);

输出为：

1

7.max：获取集合中最大值。

List<Integer> integerList = Arrays.asList(2,4,1,3);
Integer max = integerList.stream().max(Integer::compareTo).get();
System.out.println(max);

8.count：获取集合中元素个数

List<Integer> integerList = Arrays.asList(2,4,1,3);
long count = integerList.stream().count();
System.out.println(count);

输出为：

4

---------------------------------------- ----- CJZ ------ ------------------------------------------

举例

设有一组用户信息(userInfo:包含 姓名(name) 性别(sex) 年龄(age)),将这些用户信息分成 男和女 存入Map(key:sex values:List<userInfo>)中.

准备数据

UserInfo实体类

class UserInfo {
    private String name;
    private String sex;
    private Integer age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "UserInfo{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                '}';
    }
}       

获取用户信息

public List<UserInfo> buildUserInfoList(){
    Random ra =new Random();
    List<UserInfo> userInfoList = new ArrayList<>();
    String first="赵钱孙李周吴郑王冯陈褚卫蒋沈韩杨朱秦尤许何吕施张孔";
    String boy="伟刚勇毅俊峰强军平保东文辉力明永健世广志义兴良海山仁";
    for (int i=0; i<10;i++){
        UserInfo userInfo = new UserInfo();
        int sum1 = ra.nextInt(first.length());
        int sum2 = ra.nextInt(boy.length());
        userInfo.setName(first.substring(sum1,sum1+1)+boy.substring(sum2,sum2+1));
        userInfo.setSex(sum1%2==0 ? "男":"女");
        userInfo.setAge(ra.nextInt(100));
        userInfoList.add(userInfo);
    }
    return userInfoList;
}

代码实现

普通实现方式

public void userInfoClassify(){
    List<UserInfo> userInfoList = buildUserInfoList();
    Map<String, List<UserInfo>> map = new HashMap();
    List<UserInfo> male =new ArrayList<>();
    List<UserInfo> female =new ArrayList<>();
    for (UserInfo userInfo:userInfoList){
        if("女".equals(userInfo.getSex())){
            female.add(userInfo);
        }else  ("男".equals(userInfo.getSex())){
            male.add(userInfo);
        }
    }
    map.put("男",male);
    map.put("女",female);    
}   

stream实现方式

public void userInfoClassifyStream() {
    List<UserInfo> userInfoList = buildUserInfoList();
    Map<String, List<UserInfo>> collect = userInfoList.stream().collect(Collectors.groupingBy(UserInfo::getSex));
}       

map 推荐遍历方式

for (Map.Entry<String, List<UserInfo>> entry : map.entrySet()) {
        System.out.println("key:"+entry.getKey()+",value:"+entry.getValue());
}