1.什么是流Stream

书面语言：Stream是java api的新成员，以声明式的方式处理数据集合。
简单来说可以想象成集合迭代器的高级用法；另一方面有一些特性和我们熟知的io流比较像，比如把一个list集合转化为一个stream流 list.stream()
可以理解为把文件读取为输入流，但不会对原list集合产生影响，可以对新产生的stream对象进行各种各样的操作。
更通俗的讲，现在经常说的流媒体，刷抖音，都可以理解为大家看的是视频流，而集合就是原来的视频。

2.说明

本文主要是对stream常用用法进行整理，以便大家学习或者直接使用，持续更新，环境jdk1.8

3.代码

初始化listUser集合

@Slf4j
public class Mode1 {
    List<User> listUser = new ArrayList<>();
    
    @Before
    public void initList() {
        listUser = this.getListUsers();
    }
    
    private List<User> getListUsers() {
        List<User> listUser = new ArrayList<User>();
        for (int i = 0; i < 10; i++) {
            listUser.add(new User("user" + i, i));
        }
        return listUser;
    }
    
   }

User对象

package com.huajie.Lambda;

import lombok.Data;

@Data
public class User implements Comparable<User> {
    private String name;
    private Integer age;

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    
    @Override
    public int compareTo(User o) {
        int i = -(this.getAge() - o.getAge());
        if (i == 0) {
            return -(this.age - o.getAge());
        }
        return i;
    }
}

collect 说明

将stream转换为其他形式，在本文章将流转化为列表

3.1 forEach

    /**
     * 循环
     */
    @Test
    public void test1() {
        //原写法
        for (User user : listUser) {
            log.info(user.getName());
        }
        log.info("jdk1.8===============分割线");
        //stream写法
        listUser.stream().forEach(user -> log.info(user.getName()));
    }

执行结果

3.2 filter

    /**
     * filter过滤
     */
    @Test
    public void test2() {
        List<User> newlist = new ArrayList<>();
        //原写法
        for (User user : listUser) {
            if(user.getAge()>5){
                newlist.add(user);
            }
        }
        newlist.forEach(user -> log.info(user.getName()));

        log.info("jdk1.8===============分割线");
        //stream写法
        List<User> list = listUser.stream().filter(user -> user.getAge() > 5).collect(toList());
        list.forEach(user -> log.info(user.getName()));
    }

执行结果

3.3 map

将元素转换成其他形式进行提取 Lambda user -> user.getName()

    /**
     * map
     */
    @Test
    public void test3() {
        List<String> newlist = new ArrayList<>();
        //原写法
        for (User user : listUser) {
                newlist.add(user.getName());
        }
        newlist.forEach(name -> log.info(name));

        log.info("jdk1.8===============分割线");
        //stream写法
        List<String> list = listUser.stream().map(User::getName).collect(toList());
        list.forEach(name -> log.info(name));
    }

执行结果

3.4 limit

这一部分和sql比较像 Limit 取集合的前多少个

     /**
     * Limit
     */
    @Test
    public void test4() {
        //这一部分和sql比较像 Limit 取集合的前多少个
        log.info("jdk1.8===============分割线");
        //stream写法
        List<String> list = listUser.stream().map(User::getName).limit(2).collect(toList());
        list.forEach(name -> log.info(name));
    }

执行结果

3.5 skip

和limit相反，跳过前多少个

    /**
     * skip
     */
    @Test
    public void testSkip() {
        //和limit相反，跳过前多少个
        log.info("jdk1.8===============分割线");
        //stream写法
        List<String> list = listUser.stream().map(User::getName).skip(2).collect(toList());
        list.forEach(name -> log.info(name));
    }

执行结果

3.6 distinct

这一部分和sql比较像 distinct 去除重复

    /**
     * Distinct
     */
    @Test
    public void test5() {
        //这一部分和sql比较像 distinct 去除重复
        log.info("jdk1.8===============分割线");
        //stream写法
        List<String> list = listUser.stream().map(user->user.getName().substring(0,4)).distinct().collect(toList());
        list.forEach(name -> log.info(name));
    }

执行结果

3.7 count

这一部分和sql比较像 Count 统计数量

    /**
     * Count
     */
    @Test
    public void test6() {
        //这一部分和sql比较像 Count 统计数量
        log.info("jdk1.8===============分割线");
        //stream写法
        long count = listUser.stream().count();
        log.info(String.valueOf(count));
    }

执行结果

3.8 sorted

    /**
     * Sorted
     */
    @Test
    public void test7() {
        //原写法 user对象要实现Comparable<User>接口
        Collections.sort(listUser);
        log.info("jdk1.8===============分割线");
        //stream写法
        List<User> list = listUser.stream().sorted(comparing(User::getAge)).collect(toList());
        list.forEach(user -> log.info(user.getName()));
    }

执行结果