1. JSONObject JSONArray 使用方法类似于map 直接转化成String

        
		
		JSONObject indexData = new JSONObject();
        indexData.put("assetId", assetId);
        indexData.put("assetType", assetType);
        indexData.put("indexValue", indexValue);
        indexData.put("indexCode", MONITOR_INDEX_OFF_LINE);//摄像机离线指标
        indexData.put("dataFrom", "asset-hub");
        JSONArray indexDataList = new JSONArray();
        indexDataList.add(indexData);
		

amq消息队列

//发送                                                  频道                          内容
publisher.doPublish(Message.builder().channel("asset_hub_addDeviceInfo").content(indexData.toJSONString()).build());
//接收                         监听频道 可多个
    @SubscribeMapping("asset_hub_addDeviceInfo") 
    public void addDeviceInfo(Message message) {
        if (StringUtils.isNotBlank(message.getContent())) {
            JSONArray.parseArray(message.getContent())
                    .forEach(asset -> {
                        Map assetInfo = (JSONObject) asset;
                        gdpsProxyService.handleAsset(assetInfo);
                    });
        }
    }

feign

feign旨在使编写 java Http客户端变得更容易
在Feign的实现下，我们只需要创建一个接口并使用注解的方式来配置他
在公司的大项目中，通常会写一个公共模块，在公共项目中写好各模块的提供的服务接口，供其他服务调用。
如图:

如上图是一个公共模块下的fegin模块
其中service中的是各个模块提供的给其他模块可调用的接口，entity中的是接口返回值所需要用到的包装类；
资产模块下的提供的可调用的接口

1.提供fegin

//fengin
@AuthorizedFeignClient(name = "asset-hub")  //指定接口在的服务
public interface AssetHubFeignService {
    @RequestMapping(value = "/deviceInfo/getAssetById", method = RequestMethod.GET)
    BaseGduiDTO<?> getAssetById(@RequestParam("id") Long id);

    @RequestMapping(value = "/deviceInfo/updateDeviceInfo", method = RequestMethod.POST)
    BaseGduiDTO<?> updateDeviceInfo(@RequestParam("map") Map<String, String> map);
    }

2.在想用的类中注入

public class UserserviceImpl implements Userservice {
    @Autowired
    private AssetHubFeignService assetHubFeignService;

    private List<Map<String, Object>> fetchAlarmAssetTypeTop4(List<AlarmDO> alarmListByRecently) {
        List<Map<String, Object>> maps = new ArrayList<>();
        Map<String, String> assetTypeMap = new HashMap<>();
        List<AssetTypeDO> allAssetType = assetHubFeignService.updateDeviceInfo(); //调用
        allAssetType.forEach(type -> assetTypeMap.put(type.getId().toString(), type.getTypeName()));
        Map<Integer, List<AlarmDO>> collect = alarmListByRecently.stream().collect(Collectors.groupingBy(s -> s.getAssetTypeId()));
        for (Map.Entry<Integer, List<AlarmDO>> c : collect.entrySet()) {
            Map<String, Object> map = new HashMap<>();
            map.put("name", assetTypeMap.get(c.getKey().toString()));
            map.put("id", c.getKey());
            map.put("num", c.getValue().size());
            maps.add(map);
        }
        Collections.sort(maps, new AlarmComparable());
        return maps.subList(0, maps.size() > 4 ? 4 : maps.size());
    }
}

导入导出

EasyExcel
导出：
1.定义实体类

@Data
public class DemoData {
    @ExcelProperty("字符串标题")
    private String string;
    @ExcelProperty("日期标题")
    private Date date;
    @ExcelProperty("数字标题")
    private Double doubleData;
    /**
     * 忽略这个字段
     */
    @ExcelIgnore
    private String ignore;
}

2.写出

    /**
     * 最简单的写
     * <p>1. 创建excel对应的实体对象 参照{@link DemoData}
     * <p>2. 直接写即可
     */
    @Test
    public void simpleWrite() {
        // 写法1
        String fileName = TestFileUtil.getPath() + "simpleWrite" + System.currentTimeMillis() + ".xlsx";
        // 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
        // 如果这里想使用03 则 传入excelType参数即可
        EasyExcel.write(fileName, DemoData.class).sheet("模板").doWrite(data());

        // 写法2
        fileName = TestFileUtil.getPath() + "simpleWrite" + System.currentTimeMillis() + ".xlsx";
        // 这里 需要指定写用哪个class去写
        ExcelWriter excelWriter = null;
        try {
            excelWriter = EasyExcel.write(fileName, DemoData.class).build();
            WriteSheet writeSheet = EasyExcel.writerSheet("模板").build();
            excelWriter.write(data(), writeSheet);
        } finally {
            // 千万别忘记finish 会帮忙关闭流
            if (excelWriter != null) {
                excelWriter.finish();
            }
        }
    }




    /**
     * 根据参数只导出指定列
     * <p>
     * 1. 创建excel对应的实体对象 参照{@link DemoData}
     * <p>
     * 2. 根据自己或者排除自己需要的列
     * excludeColumnFiledNames   指定排除某些列
     * includeColumnFiledNames   指定导出某些列
     * <p>
     * 3. 直接写即可
     *
     * @since 2.1.1
     */
    @Test
    public void excludeOrIncludeWrite() {
        String fileName = TestFileUtil.getPath() + "excludeOrIncludeWrite" + System.currentTimeMillis() + ".xlsx";

        // 根据用户传入字段 假设我们要忽略 date
        Set<String> excludeColumnFiledNames = new HashSet<String>();
        excludeColumnFiledNames.add("date");
        // 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
        EasyExcel.write(fileName, DemoData.class).excludeColumnFiledNames(excludeColumnFiledNames).sheet("模板")
            .doWrite(data());

        fileName = TestFileUtil.getPath() + "excludeOrIncludeWrite" + System.currentTimeMillis() + ".xlsx";
        // 根据用户传入字段 假设我们只要导出 date
        Set<String> includeColumnFiledNames = new HashSet<String>();
        includeColumnFiledNames.add("date");
        // 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
        EasyExcel.write(fileName, DemoData.class).includeColumnFiledNames(includeColumnFiledNames).sheet("模板")
            .doWrite(data());
    }

3.结合注解使用

@Data
public class ConverterData {
    /**
     * 我想所有的 字符串起前面加上"自定义："三个字
     */
    @ExcelProperty(value = "字符串标题", converter = CustomStringStringConverter.class)
    private String string;
    /**
     * 我想写到excel 用年月日的格式
     */
    @DateTimeFormat("yyyy年MM月dd日HH时mm分ss秒")
    @ExcelProperty("日期标题")
    private Date date;
    /**
     * 我想写到excel 用百分比表示
     */
    @NumberFormat("#.##%")
    @ExcelProperty(value = "数字标题")
    private Double doubleData;
}

导入

// 有个很重要的点 DemoDataListener 不能被spring管理，要每次读取excel都要new,然后里面用到spring可以构造方法传进去
public class DemoDataListener extends AnalysisEventListener<DemoData> {
    private static final Logger LOGGER = LoggerFactory.getLogger(DemoDataListener.class);
    /**
     * 每隔5条存储数据库，实际使用中可以3000条，然后清理list ，方便内存回收
     */
    private static final int BATCH_COUNT = 5;
    List<DemoData> list = new ArrayList<DemoData>();
    /**
     * 假设这个是一个DAO，当然有业务逻辑这个也可以是一个service。当然如果不用存储这个对象没用。
     */
    private DemoDAO demoDAO;
    public DemoDataListener() {
        // 这里是demo，所以随便new一个。实际使用如果到了spring,请使用下面的有参构造函数
        demoDAO = new DemoDAO();
    }
    /**
     * 如果使用了spring,请使用这个构造方法。每次创建Listener的时候需要把spring管理的类传进来
     *
     * @param demoDAO
     */
    public DemoDataListener(DemoDAO demoDAO) {
        this.demoDAO = demoDAO;
    }
    /**
     * 这个每一条数据解析都会来调用
     *
     * @param data
     *            one row value. Is is same as {@link AnalysisContext#readRowHolder()}
     * @param context
     */
    @Override
    public void invoke(DemoData data, AnalysisContext context) {
        LOGGER.info("解析到一条数据:{}", JSON.toJSONString(data));
        list.add(data);
        // 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
        if (list.size() >= BATCH_COUNT) {
            saveData();
            // 存储完成清理 list
            list.clear();
        }
    }
    /**
     * 所有数据解析完成了 都会来调用
     *
     * @param context
     */
    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        // 这里也要保存数据，确保最后遗留的数据也存储到数据库
        saveData();
        LOGGER.info("所有数据解析完成！");
    }
    /**
     * 加上存储数据库
     */
    private void saveData() {
        LOGGER.info("{}条数据，开始存储数据库！", list.size());
        demoDAO.save(list);
        LOGGER.info("存储数据库成功！");
    }
}

/**
 * 假设这个是你的DAO存储。当然还要这个类让spring管理，当然你不用需要存储，也不需要这个类。
 **/
public class DemoDAO {
    public void save(List<DemoData> list) {
        // 如果是mybatis,尽量别直接调用多次insert,自己写一个mapper里面新增一个方法batchInsert,所有数据一次性插入
    }
}

    /**
     * 最简单的读
     * <p>1. 创建excel对应的实体对象 参照{@link DemoData}
     * <p>2. 由于默认一行行的读取excel，所以需要创建excel一行一行的回调监听器，参照{@link DemoDataListener}
     * <p>3. 直接读即可
     */
    @Test
    public void simpleRead() {
        // 有个很重要的点 DemoDataListener 不能被spring管理，要每次读取excel都要new,然后里面用到spring可以构造方法传进去
        // 写法1：
        String fileName = TestFileUtil.getPath() + "demo" + File.separator + "demo.xlsx";
        // 这里 需要指定读用哪个class去读，然后读取第一个sheet 文件流会自动关闭
        EasyExcel.read(fileName, DemoData.class, new DemoDataListener()).sheet().doRead();

        // 写法2：
        fileName = TestFileUtil.getPath() + "demo" + File.separator + "demo.xlsx";
        ExcelReader excelReader = null;
        try {
            excelReader = EasyExcel.read(fileName, DemoData.class, new DemoDataListener()).build();
            ReadSheet readSheet = EasyExcel.readSheet(0).build();
            excelReader.read(readSheet);
        } finally {
            if (excelReader != null) {
                // 这里千万别忘记关闭，读的时候会创建临时文件，到时磁盘会崩的
                excelReader.finish();
            }
        }
    }

注解

@ExcelProperty(value="字段值",index=1) //index指定该字段在第几个列表展示   
@ExcelIgnore  忽略某个字段
@DateTimeFormat()  日期格式  比如 ：yyyy-MM-dd

测试类

添加注解
@SpringBootTest(classes = MonitorHubApplication.class)
@RunWith(SpringRunner.class)

stream

        List<User> users= Arrays.asList(
               new User(1, "1111","1111","wang1","男","济南","19999",1),
               new User(2, "1111","1111","wang2","男","济南","1999",2),
               new User(3, "3333","1111","wang3","男","威海","1999",1),
               new User(4, "4444","1111","wang4","男","青岛","1999",3),
               new User(5, "5555","1111","wang5","女","烟台","1999",null)
       );

常用的stream三种创建方式

• 集合 Collection.stream()
• 静态方法 Stream.of
• 数组 Arrays.stream

//1.集合
Stream<Student> stream = list.stream();
//2.静态方法
Stream<String> stream2 = Stream.of("a", "b", "c");
//3.数组
String[] arr = {"a","b","c"};
Stream<String> stream3 = Arrays.stream(arr);

Stream的终止操作

1. foreach(Consumer c) 遍历操作
2. collect(Collector) 将流转化为其他形式
3. max(Comparator) 返回流中最大值
4. min(Comparator) 返回流中最小值
5. count 返回流中元素综述

映射

Map

接收流中元素，并且将其映射成为新元素

 List<Map<String, Object>> list1 = users.stream().map(e->{
                 Map<String,Object> map=new HashMap<>();
                 map.put(e.getName(),e.getDept_id());
                 return map;
            }).collect(Collectors.toList());  //生成新的map
            
 list1.forEach(System.out::println);`

flatMap

.flatMap(s -> s.stream()) 一段代码将所有集合打散合成一个流，后续再对流进行中间操作

 List<Integer> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<String> list3 = new ArrayList<>();
        List<User> list4 = new ArrayList<>();
        List<User> list5 = new ArrayList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        list2.add("aa");
        list2.add("bb");
        list2.add("cc");
        list3.add("a");
        list3.add("b");
        list3.add("c");
        list4.add(new User(1,"小红a"));
        list4.add(new User(2,"小明a"));
        list5.add(new User(3,"小红B"));
        list5.add(new User(4,"小明B"));
        //1。将三个list合为一个  
        final List<? extends Serializable> collect = Stream.of(list1, list2, list3).flatMap(s -> s.stream()).collect(Collectors.toList());
        System.out.println(collect.toString());
        //2.将两个List<Integer>合2为一
        List<String> list = Stream.of(list2, list3).flatMap(s -> s.stream()).collect(Collectors.toList());
        System.out.println(list.toString());
        //3.获取两个List<User>中得所有名字name集合
        List<String> collect1 = Stream.of(list4, list5).flatMap(s -> s.stream().map(User::getName)).collect(Collectors.toList());
        System.out.println(collect1.toString());

结果

[1, 2, 3, aa, bb, cc, a, b, c]
[aa, bb, cc, a, b, c]
[小红a, 小明a, 小红B, 小明B]

peek(Consumer c)

获取流中元素，操作流中元素，与foreach不同的是不会截断流，可继续操作流

//将DeptId为空的User变为99
            Map<Integer, List<User>> collect2 = users.stream().peek(e -> {
                if (e.getDeptId() == null) {
                    e.setDeptId(99);
                }
            }).collect(Collectors.groupingBy(User::getDeptId));

分组

            //按部门分组
            Map<Integer, List<User>> collect2 = users.stream().peek(e -> {
                if (e.getDeptId() == null) {
                    e.setDeptId(99);
                }
            }).collect(Collectors.groupingBy(User::getDeptId));
            System.out.println(collect2);
           //每个部门的个数
            Map<Integer, Long> collect = users.stream().peek(e -> {
                if (e.getDeptId() == null) {
                    e.setDeptId(99);
                }
            }).collect(Collectors.groupingBy(User::getDeptId, Collectors.counting()));
            System.out.println(collect);
            //每个部门userid最大的
            Map<Integer, Optional<User>> collect1 = users.stream().peek(e -> {
                if (e.getDeptId() == null) {
                    e.setDeptId(99);
                }
            }).collect(Collectors.groupingBy(User::getDeptId, Collectors.maxBy(Comparator.comparing(User::getUserid))));
            System.out.println(collect1);            

            System.out.println("lamba表达式进行分组");
            Map<String, List<User>> collect3 = users.stream().peek(e -> {
                if (e.getDeptId() == null) {
                    e.setDeptId(99);
                }
            }).collect(Collectors.groupingBy(user -> {
                if (user.getEmail().length() > 4)
                    return "格式不正确";
                else
                    return "格式正确";
            }));
            System.out.println(collect3.get("格式正确"));
            System.out.println(collect3.get("格式不正确"));

结果
按部门分组
{1=[User{id=1, userid='1111', password='1111', name='wang1', sex='男', adress='济南', email='19999', deptId=1}, User{id=3, userid='3333', password='1111', name='wang3', sex='男', adress='威海', email='1999', deptId=1}], 2=[User{id=2, userid='1111', password='1111', name='wang2', sex='男', adress='济南', email='1999', deptId=2}], 99=[User{id=5, userid='5555', password='1111', name='wang5', sex='女', adress='烟台', email='1999', deptId=99}], 3=[User{id=4, userid='4444', password='1111', name='wang4', sex='男', adress='青岛', email='1999', deptId=3}]}
每个部门的个数
{1=2, 2=1, 99=1, 3=1}
每个部门userid最大的
{1=Optional[User{id=3, userid='3333', password='1111', name='wang3', sex='男', adress='威海', email='1999', deptId=1}], 2=Optional[User{id=2, userid='1111', password='1111', name='wang2', sex='男', adress='济南', email='1999', deptId=2}], 99=Optional[User{id=5, userid='5555', password='1111', name='wang5', sex='女', adress='烟台', email='1999', deptId=99}], 3=Optional[User{id=4, userid='4444', password='1111', name='wang4', sex='男', adress='青岛', email='1999', deptId=3}]}
lamba表达式进行分组
[User{id=2, userid='1111', password='1111', name='wang2', sex='男', adress='济南', email='1999', deptId=2}, User{id=3, userid='3333', password='1111', name='wang3', sex='男', adress='威海', email='1999', deptId=1}, User{id=4, userid='4444', password='1111', name='wang4', sex='男', adress='青岛', email='1999', deptId=3}, User{id=5, userid='5555', password='1111', name='wang5', sex='女', adress='烟台', email='1999', deptId=99}]
[User{id=1, userid='1111', password='1111', name='wang1', sex='男', adress='济南', email='19999', deptId=1}]

组内分组

//按照地区分组后再按部门分组
            Map<String, Map<Integer, List<User>>> collect4 = users.stream().peek(e -> {
                if (e.getDeptId() == null) {
                    e.setDeptId(99);
                }
            }).collect(Collectors.groupingBy(User::getAdress, Collectors.groupingBy(User::getDeptId)));
            out.println(collect4);
            Set set = collect4.keySet();
            out.println(set);
            for (Object key : set) {
                out.println(collect4.get(key));
            }
            
            System.out.println("lamba:按照地区分组后再按邮箱是否合格分组");
            Map<String, Map<String, List<User>>> collect5 = users.stream().peek(e -> {
                if (e.getDeptId() == null) {
                    e.setDeptId(99);
                }
            }).collect(Collectors.groupingBy(User::getAdress, Collectors.groupingBy(users -> {
                if (users.getEmail().length() > 4)
                    return "合格";
                else
                    return "不合格";
            })));
            Set set2 = collect5.keySet();
            out.println(set2);
            for (Object key : set2) {
                out.println(collect5.get(key));
            }
            

按照地区分组后再按部门分组
{济南={1=[User{id=1, userid='1111', password='1111', name='wang1', sex='男', adress='济南', email='19999', deptId=1}], 2=[User{id=2, userid='1111', password='1111', name='wang2', sex='男', adress='济南', email='1999', deptId=2}]}, 青岛={3=[User{id=4, userid='4444', password='1111', name='wang4', sex='男', adress='青岛', email='1999', deptId=3}]}, 烟台={99=[User{id=5, userid='5555', password='1111', name='wang5', sex='女', adress='烟台', email='1999', deptId=99}]}, 威海={1=[User{id=3, userid='3333', password='1111', name='wang3', sex='男', adress='威海', email='1999', deptId=1}]}}

[济南, 青岛, 烟台, 威海]

{1=[User{id=1, userid='1111', password='1111', name='wang1', sex='男', adress='济南', email='19999', deptId=1}], 2=[User{id=2, userid='1111', password='1111', name='wang2', sex='男', adress='济南', email='1999', deptId=2}]}
{3=[User{id=4, userid='4444', password='1111', name='wang4', sex='男', adress='青岛', email='1999', deptId=3}]}
{99=[User{id=5, userid='5555', password='1111', name='wang5', sex='女', adress='烟台', email='1999', deptId=99}]}
{1=[User{id=3, userid='3333', password='1111', name='wang3', sex='男', adress='威海', email='1999', deptId=1}]}

lamba:按照地区分组后再按邮箱是否合格分组

[济南, 青岛, 烟台, 威海]

{不合格=[User{id=2, userid='1111', password='1111', name='wang2', sex='男', adress='济南', email='1999', deptId=2}], 合格=[User{id=1, userid='1111', password='1111', name='wang1', sex='男', adress='济南', email='19999', deptId=1}]}
{不合格=[User{id=4, userid='4444', password='1111', name='wang4', sex='男', adress='青岛', email='1999', deptId=3}]}
{不合格=[User{id=5, userid='5555', password='1111', name='wang5', sex='女', adress='烟台', email='1999', deptId=99}]}
{不合格=[User{id=3, userid='3333', password='1111', name='wang3', sex='男', adress='威海', email='1999', deptId=1}]}

            ConcurrentMap<Boolean, List<String>> collect1 = Stream.of(list2, list3)
                    .flatMap(e -> e.stream())
                    .collect(Collectors.groupingByConcurrent(e -> e.length() > 1));

比较器+排序sort

            //按照部门从降序排序
            System.out.println("Comparator函数实现");
            List<User> collect = users.stream()
                    .filter(e -> e.getDeptId() != null)
                    .sorted(Comparator.comparing(User::getDeptId).reversed())
                    .collect(Collectors.toList());
            collect.forEach(System.out::println);

            System.out.println("lamba函数实现");
            List<User> collect1 = users.stream()
                    .filter(e -> e.getDeptId() != null)
                    .sorted((users1, users2) -> -users1.getDeptId().compareTo(users2.getDeptId()))
                    .collect(Collectors.toList());
            collect1.forEach(System.out::println);

            System.out.println("----------------------------------------------------------------------------------------------------------");

            //按照Userid降序排序，按照部门升序排序
            System.out.println("Comparator函数实现");
            List<User> collect2 = users.stream()
                    .filter(e -> e.getDeptId() != null)
                    .sorted(Comparator.comparing(User::getUserid).reversed().thenComparing(User::getDeptId))
                    .collect(Collectors.toList());
            collect2.forEach(System.out::println);

            System.out.println("lamba函数实现");
            List<User> collect3 = users.stream().filter(e -> e.getDeptId() != null).sorted((users1, users2) -> {
                if (users1.getUserid().equals(users2.getUserid()))
                    return users1.getDeptId().compareTo(users2.getDeptId());
                else
                    return -users1.getUserid().compareTo(users2.getUserid());
            }).collect(Collectors.toList());
            collect3.forEach(System.out::println);
        }


 

排序结果：
Comparator函数实现
User{id=4, userid='4444', password='1111', name='wang4', sex='男', adress='青岛', email='1999', deptId=3}
User{id=2, userid='1111', password='1111', name='wang2', sex='男', adress='济南', email='1999', deptId=2}
User{id=1, userid='1111', password='1111', name='wang1', sex='男', adress='济南', email='19999', deptId=1}
User{id=3, userid='3333', password='1111', name='wang3', sex='男', adress='威海', email='1999', deptId=1}
lamba函数实现
User{id=4, userid='4444', password='1111', name='wang4', sex='男', adress='青岛', email='1999', deptId=3}
User{id=2, userid='1111', password='1111', name='wang2', sex='男', adress='济南', email='1999', deptId=2}
User{id=1, userid='1111', password='1111', name='wang1', sex='男', adress='济南', email='19999', deptId=1}
User{id=3, userid='3333', password='1111', name='wang3', sex='男', adress='威海', email='1999', deptId=1}
----------------------------------------------------------------------------------------------------------
Comparator函数实现
User{id=4, userid='4444', password='1111', name='wang4', sex='男', adress='青岛', email='1999', deptId=3}
User{id=3, userid='3333', password='1111', name='wang3', sex='男', adress='威海', email='1999', deptId=1}
User{id=1, userid='1111', password='1111', name='wang1', sex='男', adress='济南', email='19999', deptId=1}
User{id=2, userid='1111', password='1111', name='wang2', sex='男', adress='济南', email='1999', deptId=2}
lamba函数实现
User{id=4, userid='4444', password='1111', name='wang4', sex='男', adress='青岛', email='1999', deptId=3}
User{id=3, userid='3333', password='1111', name='wang3', sex='男', adress='威海', email='1999', deptId=1}
User{id=1, userid='1111', password='1111', name='wang1', sex='男', adress='济南', email='19999', deptId=1}
User{id=2, userid='1111', password='1111', name='wang2', sex='男', adress='济南', email='1999', deptId=2}

去重

按一个字段去重

List<Map<String, Object>> dlist = readbooks.readFile(file.getInputStream());
        //將表格导入的数据去重
        List<Map<String, String>> data = dlist.stream().map(e -> {
            Map<String, String> map1 = new HashMap<>();
            map1.put("0", e.get("0").toString());
            map1.put("1", e.get("1").toString());
            return map1;
        }).collect(Collectors.toList());
      	  data = data.stream()
                .collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(m -> m
                        .get("1")))), ArrayList::new));

按多个字段去重

List<ClassEntity> distinctClass = classEntities.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(o -> o.getProfessionId() + ";" + o.getGrade()))), ArrayList::new));

其他

//根据部门计算数量，总值，最大最小，平均值
  DoubleSummaryStatistics collect2 = users.stream().filter(e -> e.getDeptId() != null).collect(Collectors.summarizingDouble(User::getDeptId));
            out.println(collect2);

//查找最大值
  Optional<User> collect1 = users.stream().filter(e -> e.getDeptId() != null).collect(Collectors.maxBy(Comparator.comparing(User::getDeptId)));
            collect1.ifPresent(out::println);
//查找最小值举例：minby()中放的是自定义比较器（适用于比较条件复杂的情况）
  Optional<User> collect3 = users.stream().collect(Collectors.minBy((users1, users2) -> {
                if (users1.getUserid().equals(users2.getUserid())){
                    System.out.println(users1.getDeptId().compareTo(users2.getDeptId()));
                    return -users1.getDeptId().compareTo(users2.getDeptId());
                }
                else
                    return -users1.getUserid().compareTo(users2.getUserid());
            }));     

DoubleSummaryStatistics{count=4, sum=7.000000, min=1.000000, average=1.750000, max=3.000000}
User{id=4, userid='4444', password='1111', name='wang4', sex='男', adress='青岛', email='1999', deptId=3}
-1
minOptional[User{id=5, userid='5555', password='1111', name='wang5', sex='女', adress='烟台', email='1999', deptId=null}]

匹配

1. booelan allMatch(Predicate) 都符合
2. boolean anyMatch(Predicate) 任一元素符合
3. boolean noneMatch(Predicate) 都不符合

boolean b = basketballClub.stream().allMatch(e -> e.getAge() < 20);
boolean b1 = basketballClub.stream().anyMatch(e -> e.getAge() < 20);
boolean b2 = basketballClub.stream().noneMatch(e -> e.getAge() < 20);

寻找元素

1. findFirst——返回第一个元素
2. findAny——返回当前流中的任意元素

Optional<Student> first = basketballClub.stream().findFirst();
if (first.isPresent()) {   //IsPresent判断对象是否存在
    Student student = first.get();
    System.out.println(student);
}

Optional<Student> any = basketballClub.stream().findAny();
if (any.isPresent()) {
    Student student2 = any.get();
    System.out.println(student2);
}
Optional<Student> any1 = basketballClub.stream().parallel().findAny();
System.out.println(any1);

计数与极值

1. count——返回流中元素的总个数
2. max——返回流中最大值
3. min——返回流中最小值

long count = basketballClub.stream().count();
Optional<Student> max = basketballClub.stream().max(Comparator.comparing(Student::getAge));
if (max.isPresent()) {
    Student student = max.get();
}
Optional<Student> min = basketballClub.stream().min(Comparator.comparingInt(Student::getAge));
if (min.isPresent()) {
    Student student = min.get();
}

逆向工程

    mybatis需要程序员自己编写sql语句，mybatis官方提供逆向工程，可以针对单表自动生成mybatis执行所需要的代码（mapper.java、mapper.xml、pojo…），可以让程序员将更多的精力放在繁杂的业务逻辑上。

    企业实际开发中，常用的逆向工程方式：由数据库的表生成java代码。

    之所以强调单表两个字，是因为Mybatis逆向工程生成的Mapper所进行的操作都是针对单表的，也许你可能会觉得那这就有点鸡肋了，但是在大型项目中，很少有复杂的多表关联查询，所以作用还是很大的

依赖

<!-- SpringBoot - MyBatis -->
<dependency>
  <groupId>org.mybatis.spring.boot</groupId>
  <artifactId>mybatis-spring-boot-starter</artifactId>
  <version>1.3.0</version>
</dependency>
<!-- SpringBoot - MyBatis 逆向工程 -->
<dependency>
  <groupId>org.mybatis.generator</groupId>
  <artifactId>mybatis-generator-core</artifactId>
  <version>1.3.2</version>
</dependency>
 
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.40</version>
</dependency>

插件

build>
        <plugins>
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.5</version>
                <configuration>
                    <!-- 在控制台打印执行日志 -->
                    <verbose>true</verbose>
                    <!-- 重复生成时会覆盖之前的文件-->
                    <overwrite>true</overwrite>
                    <configurationFile>src/main/resources/generatorConfig.xml</configurationFile>
                </configuration>
                <!-- 数据库连接选择8.0以上的，因为用的mysql8.0-->
                <dependencies>
                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>8.0.13</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>

generatorConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <!-- context 是逆向工程的主要配置信息 -->
    <!-- id：起个名字 -->
    <!-- targetRuntime：设置生成的文件适用于那个 mybatis 版本 -->

    <context id="default" targetRuntime="MyBatis3">
        <property name="suppressTypeWarnings" value="true" />
<!--        <plugin type="org.mybatis.generator.plugins.UnmergeableXmlMappersPlugin" />-->
        <plugin type="org.mybatis.generator.plugins.SerializablePlugin" />
        <plugin type="org.mybatis.generator.plugins.CaseInsensitiveLikePlugin" />
        <plugin type="org.mybatis.generator.plugins.RowBoundsPlugin" />
        <plugin type="org.mybatis.generator.plugins.RenameExampleClassPlugin">
            <property name="searchString" value="Example$" />
            <property name="replaceString" value="Criteria" />
        </plugin>
        <!--optional,指在创建class时，对注释进行控制-->
        <commentGenerator>
            <property name="suppressDate" value="true"/>
            <!-- 是否去除自动生成的注释 true：是 ： false:否 -->
            <property name="suppressAllComments" value="true"/>
        </commentGenerator>
        <!--jdbc的数据库连接 wg_insert 为数据库名字-->
        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                        connectionURL="jdbc:mysql://10.10.16.246:3306/vops_asset_hub?useUnicode=true&amp;characeterEncoding=utf-8&amp;serverTimezone=Asia/Shanghai"
                        userId="root"
                        password="goldencis">
            <property name="nullCatalogMeansCurrent" value="true"/>
        </jdbcConnection>
        <!--非必须，类型处理器，在数据库类型和java类型之间的转换控制-->
        <javaTypeResolver>
            <!-- 默认情况下数据库中的 decimal，bigInt 在 Java 对应是 sql 下的 BigDecimal 类 -->
            <!-- 不是 double 和 long 类型 -->
            <!-- 使用常用的基本类型代替 sql 包下的引用类型 -->
            <property name="forceBigDecimals" value="false"/>
        </javaTypeResolver>
        <!-- targetPackage：生成的实体类所在的包 -->
        <!-- targetProject：生成的实体类所在的硬盘位置 -->
        <javaModelGenerator targetPackage="com.example.demo.pojo"
                            targetProject="src/main/java">
            <!-- 是否允许子包 -->
            <property name="enableSubPackages" value="false"/>
            <!-- 是否对modal添加构造函数 -->
            <property name="constructorBased" value="true"/>
            <!-- 是否清理从数据库中查询出的字符串左右两边的空白字符 -->
            <property name="trimStrings" value="true"/>
            <!-- 建立modal对象是否不可改变 即生成的modal对象不会有setter方法，只有构造方法 -->
            <property name="immutable" value="false"/>
        </javaModelGenerator>
        <!-- targetPackage 和 targetProject：生成的 mapper 文件的包和位置 -->
        <sqlMapGenerator targetPackage="mybatis.mapper"
                         targetProject="src/main/resources">
            <property name="enableSubPackages" value="false"/>
        </sqlMapGenerator>
        <!-- targetPackage 和 targetProject：生成的 interface 文件的包和位置 -->
        <javaClientGenerator type="XMLMAPPER"
                             targetPackage="com.example.demo.mapper" targetProject="src/main/java">
            <property name="enableSubPackages" value="false"/>
        </javaClientGenerator>
        <!-- tableName是数据库中的表名，domainObjectName是生成的JAVA模型名，后面的参数不用改，要生成更多的表就在下面继续加table标签 -->
        <table tableName="t_camera" domainObjectName="Camera"
               enableCountByExample="true" enableUpdateByExample="true"
               enableDeleteByExample="true" enableSelectByExample="true"
               selectByExampleQueryId="true"></table>
    </context>
</generatorConfiguration>

启用格式

    CameraCriteria cameraCriteria = new CameraCriteria();
    usersCriteria.or().andXXXX

example增加条件例子

    查询条件1：a=? and (b=? or c=?) ==不支持==
    查询条件2：(a=? And b=?) or (a=? And c=?) ==支持==
 
//想要查询（地址在丰奥家园）并且（部门为1到2或者4到5） 去重并且按照部门升序 
    UsersCriteria usersCriteria = new UsersCriteria();
    usersCriteria.or().andAddressEqualTo("丰奥家园").andDeptIdBetween(1,2);
    usersCriteria.or().andAddressEqualTo("丰奥家园").andDeptIdBetween(4,5);
    usersCriteria.setDistinct(true);
    usersCriteria.setOrderByClause("dept_id  asc");   //desc降序
    
//SQL==
    select distinct  id, userid, passward, name, sex, address, email, dept_id from usertb WHERE ( address = ? and dept_id between ? and ? ) or( address = ? and dept_id between ? and ? ) order by dept_id asc     
    

    IS NULL-表示相关列必须为NULL
    IS NOT NULL-表示相关列不能为NULL
    =（等于）-表示相关列必须等于方法调用中传递的值
    <>（不等于）-表示相关列不得等于方法调用中传递的值
    >（大于）-表示相关列必须大于方法调用中传递的值
    > =（大于或等于）-表示相关列必须大于或等于在方法调用中传递的值
    <（小于）-表示相关列必须小于方法调用中传递的值
    <=（小于或等于）-表示相关列必须小于或等于在方法调用中传递的值
    LIKE-表示相关列必须与方法调用中传递的值“相似”。 该代码未添加必需的’％’，您必须在方法调用中传递的值中自行设置该值。
    不喜欢-意味着相关列必须“不喜欢”方法调用中传递的值。 该代码未添加必需的’％’，您必须在方法调用中传递  的值中自行设置该值。
    BETWEEN-表示相关列必须在方法调用中传递的两个值之间。
    NOT BETWEEN-表示相关列必须在方法调用中传递的两个值之间“不在”之间。
    IN-表示相关列必须是方法调用中传入的值列表之一。
    NOT IN-表示相关列不得为方法调用中传递的值列表之一

分页查询

   int start = (currentPage - 1) * rows;
    //分页查询中的一页数量
    example.setPageSize(rows);   
    //开始查询的位置
    example.setStartRow(start);
    List<User> userList=userMapper.selectByExample(example);
    类似于：select * from user limit start to rows

到此为止，以上这些方法足够对单表进行操作，将所需要的数据取出来之后字啊用stream进行去重，映射，排序等操作；

增：

    int insert(User record);          插入新数据 有null则插入null
    int insertSelective(User record); 只将有值的属性进行插入

两者区别详解

删

    int deleteByExample(UserCriteria example);
    int deleteByPrimaryKey(Integer id);

改：

    int updateByExample(要更新的对象，条件);   根据条件将属性全部更新 
    int updateByExampleSelective(要更新的对象，条件);  根据条件将不为null的属性进行更新
    int updateByPrimaryKey(对象);  将传入的实体对象全部更新
    int updateByPrimaryKeySelective(对象); 将传入的实体对象的不为null的属性进行更新

查

     List<User> selectByExample(UserCriteria example);
     User selectByPrimaryKey(Integer id);

MySQL

case when

关于CASE WHEN的表达方式有两种：“简单CASE函数法“和“CASE搜索函数法”。
“简单CASE函数法”的语法更加简洁，但是只能处理等式的问题；
“CASE搜索函数法”更加灵活好用，可以处理等式问题也可以处理不等式问题。

离散数值与实际业务含义的一一对应

select *,
	case
	when Is_Discount =1 then "享受折扣"
	else "无折扣"
	end Discount_new,# 新列名
	case
	when Pay_Type in (1,3,5,7,10) then "微信支付"
	when Pay_Type in (6,9,12) then "银行卡支付"
	else "支付宝支付"
	end Pay_type_new# 新列名
from goods_orders
limit 5;

根据用户的出生日期将用户划分为60后、70后、80后、90后

select *,
	case
	when year(Birthday) between 1960 and 1969 then "60"
	when year(Birthday) between 1970 and 1979 then "70"
	when year(Birthday) between 1980 and 1989 then "80"
	else "90"
	end "年龄段"
from goods_orders
limit 5;

2018年每月各种支付方式的交易额

select month(Order_Date) as iMonth,# 提取月份
	case
	when Pay_Type in (1,3,5,7,10) then "微信支付"
	when Pay_Type in (6,9,12) then "银行卡支付"
	else "支付宝支付"
	end iType,
	sum(Pay_Amt) as Amt# 交易额
from goods_orders
where year(Order_Date) = 2018
group by month(Order_Date),itype
order by iMonth;

长形统计表转换成宽形统计表

select month(Order_Date) as iMonth,
	sum(case when Pay_Type in (1,3,5,7,10) then Pay_Amt end) as "weixin",
	sum(case when Pay_Type in (6,9,12) then Pay_Amt end) as "yinhangka",
	sum(case when Pay_Type in (2,4,8,11) then Pay_Amt end) as "zhifubao"
from goods_orders
where year(Order_Date) = 2018
group by iMonth
order by iMonth;

公司

//按照WBDW进行分组，并统计每组中SBZT（1：启用中---），总数和WBDQ(时间：已过保，维保到期）的数量
    <select id="getReportLifeCycle" parameterType="map" resultType="map">
        select WBDW,
        COUNT(1) totol,
        SUM(CASE WHEN SBZT = 1 THEN 1 ELSE 0 END) qiyongzhong, ## 每个case都会在结果中重新追加一列
        SUM(CASE WHEN SBZT = 2 THEN 1 ELSE 0 END) weixiu,
        SUM(CASE WHEN SBZT = 3 THEN 1 ELSE 0 END) chaichu,
        SUM(CASE WHEN SBZT = 4 THEN 1 ELSE 0 END) tingyong,
        SUM(CASE WHEN SBZT = 5 THEN 1 ELSE 0 END) daiyanshou,
        SUM(CASE WHEN DATEDIFF(WBDQ,NOW()) &lt;= 30 and DATEDIFF(WBDQ,NOW())&gt;0 THEN 1 ELSE 0 END) lessthrity,
        SUM(CASE WHEN date_format(WBDQ,'%Y-%m-%d') &lt; now() THEN 1 ELSE 0 END) yiguobao
        from    
        (select
        (CASE WHEN WBDW IS NULL THEN "未知单位" ELSE WBDW END ) WBDW,WBDQ,SBZT
        from t_asset_info  where    ## 添加条件
        <if test="assettypes != null and assettypes !='-1'">
            asset_type in (select  t2.id from t_asset_type t1 left join t_asset_type t2 on t1.id=t2.type_parent where t1.id=#{assettypes}) or asset_type=#{assettypes} and
        </if>
         main_show = 1) as c
        GROUP BY WBDW
        ORDER BY WBDW
    </select>