MyUtil

package com.zkml.common.util;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;

import java.math.BigDecimal;
import java.util.*;

/**
 * @Description : 自定义工具类（逐步完善）
 * @Author :Unknow
 * @Time :2018-04-20
 */
public final class MyUtil {

    /**
     * 判断是否为空
     *
     * @param value
     * @return
     */
    public static boolean isBlank(Object value) {
        return isObjectBlank(value);
    }

    /**
     * 判断是否不为空
     *
     * @param value
     * @return
     */
    public static boolean isNotBlank(Object value) {
        return !isObjectBlank(value);
    }

    /**
     * 将list中的标示抽出来组装成map，方便数据组装  Map<Object,Object>
     *
     * @param list
     * @param id
     * @return
     */
    public static Map listToMap(List list, String id) {
        Map map = Maps.newHashMap();
        for (int i = 0; i < list.size(); i++) {
            Object object = list.get(i);
            Object value = ReflectUtil.getMethod(id, object);
            if (isNotBlank(value))
                map.put(value, object);
        }
        return map;
    }

    /**
     * 将list中的标示抽出来组装成map，方便数据组装(有多个数据有相同标示，则组装成list)  Map<Object,List>
     *
     * @param list
     * @param id
     * @return
     */
    public static Map listToMapList(List list, String id) {
        Map<Object, List> map = Maps.newHashMap();
        for (int i = 0; i < list.size(); i++) {
            Object object = list.get(i);
            Object value = ReflectUtil.getMethod(id, object);
            if (isNotBlank(value)) {
                List paramsList = null;
                if (map.containsKey(value)) {
                    paramsList = map.get(value);
                } else {
                    paramsList = Lists.newArrayList();
                }
                paramsList.add(object);
                map.put(value, paramsList);
            }
        }
        return map;
    }

    /**
     * list对象里面抽调某一个属性单独组装成list
     *
     * @param list
     * @param fieldName
     * @return
     */
    public static List listByField(List list, String fieldName) {
        List result = Lists.newArrayList();
        for (int i = 0; i < list.size(); i++) {
            Object ob = list.get(i);
            Object value = ReflectUtil.getMethod(fieldName, ob);
            if (isNotBlank(value) && !result.contains(value))
                result.add(value);
        }
        return result;
    }

    /**
     * 获取枚举中的name集合
     *
     * @param baseEnums
     * @return
     */
    public static List<String> getEnumNameList(Enum[] baseEnums) {
        List<String> list = Lists.newArrayList();
        for (Enum baseEnumTem : baseEnums) {
            list.add(ReflectUtil.getMethod("name", baseEnumTem).toString());
        }
        return list;
    }

    /**
     * 获取枚举中的value集合
     *
     * @param baseEnums
     * @return
     */
    public static List<String> getEnumValueList(Enum[] baseEnums) {
        List<String> list = Lists.newArrayList();
        for (Enum baseEnumTem : baseEnums) {
            list.add(ReflectUtil.getMethod("value", baseEnumTem).toString());
        }
        return list;
    }

    /**
     * 小数点后保留length位小数（默认是2位）
     *
     * @param digits null 或 数值
     * @param length 小数后保留位数 默认为2位
     * @return BigDecimal
     */
    public static BigDecimal translateDigits(Object digits, Integer length) {
        if (isBlank(digits)) {
            return new BigDecimal("0.00");
        }
        if (isBlank(length) || length < 0) {
            length = 2;
        }
        return new BigDecimal(digits.toString()).setScale(length, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * BigDecimal数据智能切割成只包含有效数字，仅能处理小数点后2为数字
     * 例：1、传入0.00，处理后返回0 ；2、传入0.20则返回0.2；3、传入20则返回20
     *
     * @param digits null 或 数值
     * @return String 处理后的数字字符串
     */
    public static String cutSignificantDigits(BigDecimal digits) {
        if (isBlank(digits)) {
            return "0";
        }
        // 转换成字符串
        String digitsStr = digits.toString();
        if (!digitsStr.contains(".")) {
            return digitsStr;
        }
        // 切割成“.”前后字符串
        String[] digitsStrArray = digitsStr.split("\\.");
        // 获取小数点后的数字尾部去O后剩余部分
        digitsStrArray[1] = endsWithNonzero(digitsStrArray[1]);
        if ("".equals(digitsStrArray[1])) {
            return digitsStrArray[0];
        }
        // 重组数字，不以0结尾
        return digitsStrArray[0] + "." + digitsStrArray[1];
    }

    /**
     * 判断数字是否大于0
     *
     * @param object
     * @return boolean true,不为空或者0
     */
    public static boolean isDigitsExceedZero(Object object) {
        //如果为空，则返回false
        if (MyUtil.isBlank(object)) {
            return false;
        }
        try {
            BigDecimal digits = new BigDecimal(object.toString());
            //如果比对大于0，返回true
            if (digits.compareTo(new BigDecimal(0)) > 0) {
                return true;
            }
        } catch (RuntimeException r) {
            throw new RuntimeException("不合法的数字类型");
        }
        return false;
    }

    /**
     * 小数点后的数字，截取成绝对不以0结尾
     *
     * @param digitsStr 小数点后的数字
     * @return
     */
    private static String endsWithNonzero(String digitsStr) {
        if (digitsStr.length() == 1 && "0".equals(digitsStr)) {
            return "";
        }
        if ("0".equals(digitsStr.substring(digitsStr.length() - 1, digitsStr.length()))) {
            return endsWithNonzero(digitsStr.substring(0, digitsStr.length() - 1));
        }
        return digitsStr;
    }

    /**
     * 对象判空
     *
     * @param ob 对象
     * @return true=空 / false=非空
     */
    private static boolean isObjectBlank(Object ob) {
        if (ob == null) {
            return true;
        }
        if (ob instanceof Collection) {
            return ((Collection) ob).isEmpty();
        }
        if (ob instanceof Map) {
            return ((Map) ob).isEmpty();
        }
        if (ob.toString().trim().equals("") || ob.toString().trim().toLowerCase().equals("null")) {
            return true;
        }
        return false;
    }
}