JAVA高效编程四（流编程实战案例）

查找

package com.imooc.zhangxiaoxi.stream.cases;

import lombok.AllArgsConstructor;
import lombok.Data;
import org.junit.Before;
import org.junit.Test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 类名称：CaseOne
 * ********************************
 * <p>
 * 类描述：案例一
 * 重点讲解：anyMatch的使用方式
 *
 * @author zhangxiaoxi
 * @date 下午9:22
 */
public class CaseOne {

    /**
     * 考试成绩模型
     */
    @Data
    @AllArgsConstructor
    class ExamStudentScore {
        /**
         * 学生姓名
         */
        private String studentName;
        /**
         * 成绩
         */
        private Integer scoreValue;
        /**
         * 科目
         */
        private String subject;
    }

    /**
     * 学生考试成绩
     */
    Map<String, List<ExamStudentScore>> studentMap;

    @Before
    public void init() {
        studentMap = new HashMap<>();

        List<ExamStudentScore> zsScoreList = new ArrayList<>();
        zsScoreList.add(
                new ExamStudentScore(
                        "张三",
                        30,
                        "CHINESE"));
        zsScoreList.add(
                new ExamStudentScore(
                        "张三",
                        40,
                        "ENGLISH"));
        zsScoreList.add(
                new ExamStudentScore(
                        "张三",
                        50,
                        "MATHS"));
        studentMap.put("张三", zsScoreList);

        List<ExamStudentScore> lsScoreList = new ArrayList<>();
        lsScoreList.add(
                new ExamStudentScore(
                        "李四",
                        80,
                        "CHINESE"));
        lsScoreList.add(
                new ExamStudentScore(
                        "李四",
                        null,
                        "ENGLISH"));
        lsScoreList.add(
                new ExamStudentScore(
                        "李四",
                        100,
                        "MATHS"));
        studentMap.put("李四", lsScoreList);

        List<ExamStudentScore> wwScoreList = new ArrayList<>();
        wwScoreList.add(
                new ExamStudentScore(
                        "王五",
                        null,
                        "CHINESE"));
        wwScoreList.add(
                new ExamStudentScore(
                        "王五",
                        null,
                        "ENGLISH"));
        wwScoreList.add(
                new ExamStudentScore(
                        "王五",
                        70,
                        "MATHS"));
        studentMap.put("王五", wwScoreList);
    }

    @Test
    public void findStudent() {

        studentMap.forEach((studentName, scoreList) -> {

            boolean bool = scoreList.stream()
                    .anyMatch(score -> {
                        // TODO anyMatch找到任意一条符合条件的数据后就停止
//                        System.out.println(score);

                        return score.getScoreValue() == null;
                    });

            if (bool) {
                System.out.println("此学生[ " + studentName + " ]有缺考情况！");
            }
        });
    }
}

去重

package com.imooc.zhangxiaoxi.stream.cases;

import com.google.common.collect.Lists;
import lombok.AllArgsConstructor;
import lombok.Data;
import org.junit.Before;
import org.junit.Test;

import java.util.List;

/**
 * 类名称：CaseTwo
 * ********************************
 * <p>
 * 类描述：案例二
 * 重点讲解：filter和distinct的使用方式
 *
 * @author zhangxiaoxi
 * @date 下午9:39
 */
public class CaseTwo {

    /**
     * 用户请求的创建标签模型
     */
    @Data
    @AllArgsConstructor
    class TagReqDTO {
        /**
         * 标签名字
         */
        private String name;
        /**
         * 标签值：年龄
         */
        private Integer age;
    }

    /**
     * 从DB中查询出来的已经存在的标签名
     */
    List<String> tagListFromDB;
    /**
     * 用户请求的标签列表
     */
    List<TagReqDTO> tagListFromReq;

    @Before
    public void init() {
        // 数据库中存在的标签名列表
        tagListFromDB = Lists.newArrayList(
                "李四", "王五", "赵六");

        // 用户提交的
        tagListFromReq = Lists.newArrayList(
                new TagReqDTO("张三", 10),
                new TagReqDTO("李四", 30),
                new TagReqDTO("张三", 11));
    }


    @Test
    public void distinctTag() {

        tagListFromReq.stream()

                // TODO true:通过测试，数据不过滤；false:未通过测试，数据被过滤
                .filter(tag -> !tagListFromDB.contains(tag.getName()))

                // TODO 使用equals对元素进行比较
                .distinct()
                .forEach(tag -> System.out.println(tag));

    }

}

扁平化

package com.imooc.zhangxiaoxi.stream.cases;

import com.google.common.collect.Lists;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.junit.Before;
import org.junit.Test;

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

/**
 * 类名称：CaseThree
 * ********************************
 * <p>
 * 类描述：案例三
 * 重点讲解：flatMap的使用方式
 *
 * @author zhangxiaoxi
 * @date 下午9:50
 */
public class CaseThree {

    /**
     * 角色
     */
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    class Role {
        /**
         * 权限列表
         */
        private List<Permission> permissions;
    }
    /**
     * 权限
     */
    @Data
    @AllArgsConstructor
    class Permission {
        /**
         * 权限名称
         */
        private String name;
    }

    /**
     * 用户角色列表
     */
    List<Role> roleList;

    @Before
    public void init() {
        roleList = new ArrayList();

        Role adminRole = new Role();
        List<Permission> adminPermissionList = Lists.newArrayList(
                new Permission("删除"),
                new Permission("查看"),
                new Permission("导出"));
        adminRole.setPermissions(adminPermissionList);

        Role userRole = new Role();
        List<Permission> userPermissionList = Lists.newArrayList(
                new Permission("新建"),
                new Permission("修改"),
                new Permission("删除"),
                new Permission("查看"));
        userRole.setPermissions(userPermissionList);

        roleList.add(adminRole);
        roleList.add(userRole);
    }

    @Test
    public void findPermission() {
        roleList.stream()

                // TODO 扁平化MAP 获取对象中的集合类属性，组成一个新的流
　　　　　　　　　　// 注意flatMap和map方法的区别,flatMap是组成一个新的流，而map仅仅是映射成另外一个对象
　　　　　　　　　　// 此处如果是用的是map(role -> role.getPermission())，得到的是Stream<List<Permission>>，
　　　　　　　　　　// 如果用的是map(role -> role.getPermisson().stream()),得到是Stream<Stream<List<Permission>>>
　　　　　　　　　  // 如果用的是flatMap(role -> role.getPermission().stream()),得到的是Stream<Permission>
                .flatMap(role -> role.getPermissions().stream())

                // peek 与 forEach 类似，区别是用在中间过程中，后面可以接其他操作
                .peek(permission ->
                        System.out.println("新的流元素：" + permission))

                .distinct()
//                .forEach(permission -> System.out.println(permission));
                .collect(Collectors.toList());
    }
}

分组

package com.imooc.zhangxiaoxi.stream.cases;

import com.alibaba.fastjson.JSON;
import com.google.common.collect.Lists;
import lombok.AllArgsConstructor;
import lombok.Data;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * 类名称：CaseFour
 * ********************************
 * <p>
 * 类描述：案例四
 * 重点讲解：group的使用方式
 *
 * @author zhangxiaoxi
 * @date 下午8:39
 */
public class CaseFour {

    @Data
    @AllArgsConstructor
    class Order {
        /**
         * 订单编号
         */
        private Integer orderId;
        /**
         * 账户编号
         */
        private String accountId;
    }

    /**
     * 模拟数据库查询
     * @param accountIds
     * @return
     */
    public List<Order> selectFromDB(List<String> accountIds) {
        List<Order> orderList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            orderList.add(
                    new Order(i,
                            accountIds.get(i % accountIds.size())));
        }
        return orderList;
    }

    /**
     * 接口
     * @param accountIds
     * @return
     */
    public Map<String, List<Order>> queryOrderByAccountIds(
            List<String> accountIds) {

        return Optional.ofNullable(selectFromDB(accountIds))
                .map(List::stream)
                .orElseGet(Stream::empty)

                // TODO group分组功能
                .collect(Collectors.groupingBy(
                        order -> order.getAccountId()));
    }

    @Test
    public void test() {
        Map<String, List<Order>> orders =
                queryOrderByAccountIds(
                        Lists.newArrayList("张三", "李四", "王五"));

        System.out.println(JSON.toJSONString(orders, true));
    }
}

排序

package com.imooc.zhangxiaoxi.stream.cases;

import com.alibaba.fastjson.JSON;
import lombok.AllArgsConstructor;
import lombok.Data;
import org.junit.Before;
import org.junit.Test;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 类名称：CaseFive
 * ********************************
 * <p>
 * 类描述：案例五
 * 重点讲解：sort和compare的使用方式
 *
 * @author zhangxiaoxi
 * @date 下午10:32
 */
public class CaseFive {

    /**
     * 交易实体模型
     */
    @Data
    @AllArgsConstructor
    class Trade {
        // 下单价格
        private BigDecimal price;
        // 下单时间
        private LocalDateTime time;
        // 下单量
        private Integer count;
        // 下单类型：机构 / 个人
        private String type;
    }

    /**
     * 一段时间内的交易申请
     */
    List<Trade> trades;

    @Before
    public void init() {
        trades = new ArrayList<>();

        trades.add(new Trade(new BigDecimal(100),
                // 在当前时间的基础上添加 1 秒
                LocalDateTime.now().plusSeconds(1),
                500, "机构"));
        trades.add(new Trade(new BigDecimal(101),
                LocalDateTime.now().plusSeconds(2),
                1, "个人"));
        trades.add(new Trade(new BigDecimal(101),
                LocalDateTime.now().plusSeconds(1),
                1, "个人"));
        trades.add(new Trade(new BigDecimal(100),
                LocalDateTime.now().plusSeconds(1),
                500, "个人"));
        trades.add(new Trade(new BigDecimal(100),
                LocalDateTime.now().plusSeconds(0),
                2, "个人"));
        trades.add(new Trade(new BigDecimal(100),
                LocalDateTime.now().plusSeconds(0),
                100, "机构"));
    }

    @Test
    public void sortTrade() {

        System.out.println("排序前数据~~~\n" + JSON.toJSONString(trades, true));

        List<Trade> sorted = trades.stream()
                .sorted(
                        Comparator
                                // 首先按照价格排序
                                .comparing(
                                        Trade::getPrice,
                                        // TODO 进行排序调整，将自然排序翻转
                                        Comparator.reverseOrder())

                                // 时间先后进行排序，自然排序
                                .thenComparing(Trade::getTime)

                                // 交易量排序，自然排序翻转
                                .thenComparing(
                                        Trade::getCount,
                                        Comparator.reverseOrder())

                                // 自定义排序规则
                                .thenComparing(
                                        // 要排序的字段值
                                        Trade::getType,

                                        // 自定义排序规则
                                        (type1, type2) -> {
                                            if ("机构".equals(type1) && "个人".equals(type2)) {
                                                // -1:type1在先， type2在后
                                                return -1;
                                            } else if ("个人".equals(type1) && "机构".equals(type2)) {
                                                return 1;
                                            } else {
                                                return 0;
                                            }
                                        }))
                .collect(Collectors.toList());

        System.out.println("排序后结果~~~\n" + JSON.toJSONString(sorted, true));
    }
}