通用代码工具类java

package com.aiseeding.ase.common.utils;


import com.aiseeding.ase.common.domain.CommonParam;
import com.aiseeding.ase.common.domain.PageObject;
import com.aiseeding.ase.common.domain.PageParam;
import org.apache.commons.lang3.StringUtils;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 通用代码逻辑封装
 */
public class CommonFunctionUtil {
    /**
     * 批量插入,如果为空 则不执行任何动作
     * @param rows 每次插入多少条
     * @param target 插入的对象
     * @param consumer 执行插入的方法
     * @param <T>
     */
    public static <T>void batchInsert(int rows, List<T> target, Consumer<List<T>> consumer){
        if(CollectionUtils.isEmpty(target)){
            return;
        }
        int size = target.size();
        int i = 0;
        for (; i < size / rows; i++) {
            consumer.accept( target.subList(i*rows,(i+1)*rows) );
        }

        List<T> left = target.subList(i * rows, target.size());
        if(left.isEmpty())
            return;

        consumer.accept(left);
    }
    /**
     * 批量插入,如果为空 则不执行任何动作,默认1w条数据
     * @param target 插入的对象
     * @param consumer 执行插入的方法
     * @param <T>
     */
    public static <T>void batchInsert(List<T> target, Consumer<List<T>> consumer){
        batchInsert(10000,target,consumer);
    }

    public static <T> PageParam<List<T>> pagination(List<T> target, int row, int pageNo){
        PageParam<List<T>> result = new PageParam<>();
        result.setCount(target.size());
        int pages = result.getCount() / row;
        pages = result.getCount() % row == 0 ? pages : pages + 1;
        result.setPages(pages);

        if(pageNo>pages){
            pageNo = 1;
        }
        result.setPageNo(pageNo);
        int fromIndex = (pageNo - 1) * row;
        int endIndex = fromIndex+ row;
        if(endIndex>target.size()){
            endIndex =  target.size();
        }
        result.setResult(target.subList(fromIndex,endIndex));
        return result;
    }
    public static <T> PageObject<T> page(List<T> target, int row, int pageNo){
        PageObject<T> result = new PageObject<>();
        result.setCount(target.size());
        int pages = result.getCount() / row;
        pages = result.getCount() % row == 0 ? pages : pages + 1;
        result.setPages(pages);
        if(pageNo>pages){
            pageNo = 1;
        }
        result.setPageNo(pageNo);
        int fromIndex = (pageNo - 1) * row;
        int endIndex = fromIndex+ row;
        if(endIndex>target.size()){
            endIndex =  target.size();
        }
        result.setResult(target.subList(fromIndex,endIndex));
        return result;
    }

    /**
     * 通用分组
     * @param keyMapper 分组key
     * @param target 分组目标
     * @param <T>
     * @param <R>
     * @return
     */
    public static <T,R> Map<R,List<T>> listGroupBy(List<T> target, Function<T,R> keyMapper){
        return target.stream().collect(Collectors.groupingBy(keyMapper));
    }

    /**
     * 通用分组
     * @param keyMapper 分组key
     * @param valueMapper value处理逻辑
     * @param target 分组对象
     * @param <T>
     * @param <R1>
     * @param <R2>
     * @return
     */
    public static <T,R1,R2> Map<R1,List<R2>> listGroupBy(List<T> target, Function<T,R1> keyMapper, Function<T,R2> valueMapper){
        return target.stream().collect(Collectors.groupingBy(keyMapper, Collectors.mapping(valueMapper,Collectors.toList())));
    }

    public static <K,V,T> Map<K,V> listToMap(List<T> target, Function<T,K> keyMapper, Function<T,V> valueMapper){
        return target.stream().collect(Collectors.toMap(keyMapper,valueMapper,(o,n)->o));
    }
    public static <K,T>Map<K,T>listToMap(List<T> target, Function<T,K> keyMapper){
        return target.stream().collect(Collectors.toMap(keyMapper,e->e));
    }
    public static Integer planTimeUnitToMinuets(Integer planTimeUnit){
        return planTimeUnit == 1?15:
                planTimeUnit==2?30:
                        60;
    }
    public static Integer planTimeUnitToCount(Integer planTimeUnit){
        return planTimeUnit == 1?96:
                planTimeUnit==2?48:
                        24;
    }
    public static void convertToLong(String target, Consumer<Long> onSuccess, Consumer<Exception> onError){
        try {
            if(StringUtils.isBlank(target))
                return;

            onSuccess.accept(Long.parseLong(target));
        } catch (NumberFormatException e) {
            onError.accept(e);
        }
    }

    public static Set<String> stringToSet(String target, String separator){
        if (StringUtils.isBlank(target)) {
            return Collections.emptySet();
        }
        return Arrays.stream(target.split(separator)).collect(Collectors.toSet());
    }
    public static Set<String> stringToSet(String target){
        return stringToSet(target,",");
    }

    private CommonFunctionUtil() {
    }

    /**
     * 向上取整
     * @param a 待取整的数值
     * @param number 取整的基数
     * @return
     */
    public static int ceilNumber(int a,int number){
        return (int) Math.ceil((a+0.0)/number) * number;
    }
}

@Data
public class PageParam<T> {
    //总记录数
    int count;
    //当前页码
    int pageNo;
    //总页数
    int pages;
    //数据
    T result;
}

public class PageObject<T> {
    public static final PageObject emptyObject = new PageObject<>(Collections.emptyList());
    //总记录数
    int count;
    //当前页码
    int pageNo;
    //总页数
    int pages;
    //数据
    List<T> result;

    public PageObject(List<T> result) {
        this.result = result;
    }

    public PageObject() {
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public int getPageNo() {
        return pageNo;
    }

    public void setPageNo(int pageNo) {
        this.pageNo = pageNo;
    }

    public int getPages() {
        return pages;
    }

    public void setPages(int pages) {
        this.pages = pages;
    }

    public List<T> getResult() {
        return result;
    }

    public void setResult(List<T> result) {
        this.result = result;
    }

    public <S>PageObject<S> map(Function<T,S> mapper){
        PageObject<S> pageObject = new PageObject<>();

        List<S> newResult = result.stream().map(mapper).collect(Collectors.toList());
        pageObject.setResult(newResult);
        pageObject.setPageNo(pageNo);
        pageObject.setCount(count);
        pageObject.setPages(pages);

        return pageObject;
    }

    public static <T>PageObject<T> emptyObject(){
        return emptyObject;
    }
}