Java 8函数式编程Stream替代for循环案例

package com.ruoyi.web.controller.platform;


import com.ruoyi.system.domain.SysDept;
import com.ruoyi.system.domain.SysUser;
import org.apache.commons.lang3.StringUtils;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Collectors;


@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ForAndStream.class)
public class ForAndStream {
    private final static Logger logger = LoggerFactory.getLogger(ForAndStream.class);

    /**
     * 我想找出所有 长度>=5的字符串，并且忽略大小写、去除重复字符串，然后按字母排序，最后用“爱心❤”连接成一个字符串输出！
     */
    @Test
    public void test1() {
        String[] strarr = {"1", "2", "bilibili", "of", "codesheep", "5", "at", "BILIBILI", "codesheep", "23", "CHEERS", "6"};
        String str = StringUtils.join(strarr, ",");
        logger.info(">>>>>>>>>>>>>>>>>>>>str:{}>>>>>>>>>>>>>>>>>>>>", str);
    }

    /**
     * 首先我写一个函数，判断输入字符串到底是字母还是数字
     *
     * @param str
     * @return
     */
    public static Boolean isNum(String str) {
        for (int i = 0; i < str.length(); i++) {
            if (!Character.isDigit(str.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    @Test
    public void test2() {
        String[] strarr = {"1", "2", "bilibili", "of", "codesheep", "5", "at", "BILIBILI", "codesheep", "23", "CHEERS", "6"};
        List<String> list = Arrays.asList(strarr);
        String result = list.stream() //首先将列表转化为Stream流
                .filter(i -> !isNum(i)) //首先筛选出字母型字符串
                .filter(i -> i.length() >= 5) //其次筛选出长度>=5的字符串
                .map(i -> i.toLowerCase()) //字符串统一转小写
                .distinct() //去重操作来一下
                .sorted(Comparator.naturalOrder()) //字符串排序来一下
                .collect(Collectors.joining("❤")); //连词成句来一下，完美！
        logger.info("不使用for循环,使用Stream流得到的最后结果:{}", result);
        //不使用for循环,使用Stream流得到的最后结果:bilibili❤cheers❤codesheep
    }

    /**
     * Java 8函数式编程范式
     * Stream接口
     * Consumer接口
     * Optional接口
     * Function接口
     */
    /**
     * Consumer接口
     * 顾名思义，它是“消费者的含义”，接受参数而不返回值，举个最最常见的样子：
     * 平时我们打印字符串，本质也是接受一个参数并打印出来，我们一般想都不想，会这样写：
     */
    @Test
    public void test3() {
        System.out.println("hello world");
        System.out.println("hello codesheep");
        System.out.println("bilibili cheers");
        System.out.println("----------------------------------");
        //一旦你用了 Consumer之后，总感觉更加优雅一些
        Consumer c = System.out::println;
        c.accept("hello world");
        c.accept("hello codesheep");
        c.accept("bilibili cheers");
        System.out.println("----------------------------------");
        //而且 Consumer还可以用联用，达到多重处理的效果，比如：
        c.andThen(c).andThen(c).accept("hello world");
    }

    /**
     * Function接口
     * Function接口代表的含义是“函数”，其实和上面的 Consumer有点像，
     * 不过 Function既有输入，也有输出，使用更加灵活，举例：
     * 比如我想对一个整数先乘以 2，再计算平方值
     * 3*2=6  6的平方为36
     */
    @Test
    public void test4() {
        Function<Integer, Integer> f1 = i -> i + i; //乘以2功能
        Function<Integer, Integer> f2 = i -> i * i; //平方功能
        Consumer c = System.out::println;
        c.accept(f1.andThen(f2).apply(3));

    }


    /**
     * 传统写法
     * 我们想写一个获取某个用户的部门信息：getSysDept()
     *
     * @return
     */
    public String getSysDept(SysUser user) {
        if (user != null) {
            SysDept dept = user.getDept();
            if (dept != null) {
                return dept.getDeptName();
            }
        }
        return null;
    }

    /**
     * Optional接口
     * Optional本质是个容器，你可以将你的变量交由它进行封装，
     * 这样我们就不用显式对原变量进行 null值检测，防止出现各种空指针异常。举例：
     * 我们想写一个获取某个用户的部门信息：getSysDept()
     * 嵌套的if/else判空灰飞烟灭！
     */
    public String getOptionalSysDept(SysUser user) {
        return Optional.ofNullable(user)
                .map(SysUser::getDept)
                .map(SysDept::getDeptName)
                .orElse(null);
    }

    @Test
    public void test6() {
        SysUser user = new SysUser();
        user.setUserId(Long.valueOf(1));
        SysDept dept = new SysDept();
        dept.setDeptName("研发部");
        user.setDept(dept);
        String result = getOptionalSysDept(user);
        String result1 = getSysDept(user);
        logger.info(">>>>>>getOptionalSysDept 输出结果：{}>>>>>>>>>>>>>>>", result);
        logger.info(">>>>>>getSysDept 输出结果：{}>>>>>>>>>>>>>>>", result1);
    }


}