weaver-hrm-salary/src/com/engine/salary/util/SalaryEntityUtil.java

package com.engine.salary.util;

import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.StringUtils;

import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collector;
import java.util.stream.Collectors;

/**
 * @description: 实体类相关
 * @author: xiajun
 * @modified By: xiajun
 * @date: Created in 10/28/21 5:36 PM
 * @version:v1.0
 */
public class SalaryEntityUtil {

    private static final DecimalFormat decimalFormat = new DecimalFormat("#,##0.00");

    /**
     * 千分位格式化
     *
     * @param originMap 原始map
     * @param targetMap 目标map
     */
    public static void thousandthConvert(Map<String, Object> originMap, Map<String, Object> targetMap) {

        if (MapUtils.isNotEmpty(originMap)) {
            originMap.forEach((k, v) -> {
                if (StringUtils.isNotBlank(String.valueOf(v))) {
                    targetMap.put(k, decimalFormat.format(Double.valueOf(String.valueOf(v))));
                }
            });
        }
    }

    /**
     * 千分位格式化
     *
     * @param originString 原始字符串
     * @return 格式化后的字符串
     */
    public static String thousandthConvert(String originString) {
        if (StringUtils.isNotBlank(originString)) {
            return decimalFormat.format(Double.valueOf(originString));
        }
        return "0.00";
    }

    /**
     * 判断对象或对象数组中每一个对象是否为空: 对象为null，字符序列长度为0，集合类、Map为empty
     *
     * @param obj
     * @return
     */
    public static boolean isNullOrEmpty(Object obj) {
        if (obj == null) {
            return true;
        }
        if (obj instanceof CharSequence) {
            return ((CharSequence) obj).length() == 0;
        }
        if (obj instanceof Collection) {
            return ((Collection) obj).isEmpty();
        }
        if (obj instanceof Map) {
            return ((Map) obj).isEmpty();
        }
        if (obj instanceof Object[]) {
            Object[] object = (Object[]) obj;
            if (object.length == 0) {
                return true;
            }
            boolean empty = true;
            for (int i = 0; i < object.length; i++) {
                if (!isNullOrEmpty(object[i])) {
                    empty = false;
                    break;
                }
            }
            return empty;
        }

        return false;
    }

    public static boolean isNotNullOrEmpty(Object obj) {
        return !isNullOrEmpty(obj);
    }

    public static <R, T, A> A properties(Collection<T> objs, Function<T, R> function, Collector<R, ?, A> collectors) {
        return objs.stream().map(function).collect(collectors);
    }

    public static <R, T> Set<R> properties(Collection<T> objs, Function<T, R> function) {
        if (CollectionUtils.isEmpty(objs)) {
            return Sets.newHashSet();
        }
        return properties(objs, function, Collectors.toSet());
    }

    public static <R, T> Map<R, T> convert2Map(Collection<T> objs, Function<T, R> function) {
        if (CollectionUtils.isEmpty(objs)) {
            return Maps.newHashMap();
        }
        return objs.stream().collect(Collectors.toMap(function, Function.identity(), (a, b) -> a));
    }

    public static <T, K, V> Map<K, V> convert2Map(Collection<T> objs, Function<T, K> keyMapper, Function<T, V> valueMapper) {
        if (CollectionUtils.isEmpty(objs)) {
            return Maps.newHashMap();
        }
        return objs.stream()
            .filter(e -> valueMapper.apply(e) != null && keyMapper.apply(e) != null)
            .collect(Collectors.toMap(keyMapper, valueMapper, (a, b) -> a));
    }

    public static <R, T> Map<R, List<T>> group2Map(Collection<T> objs, Function<T, R> function) {
        if (CollectionUtils.isEmpty(objs)) {
            return Maps.newHashMap();
        }
        return objs.stream().collect(Collectors.groupingBy(function));
    }

    public static <T, K, V> Map<K, Set<V>> group2Map(Collection<T> objs, Function<T, K> keyMapper, Function<T, V> valueMapper) {
        if (CollectionUtils.isEmpty(objs)) {
            return Maps.newHashMap();
        }
        return objs.stream()
            .filter(e -> keyMapper.apply(e) != null && valueMapper.apply(e) != null)
            .collect(Collectors.groupingBy(keyMapper,
                Collectors.collectingAndThen(Collectors.toList(), e -> e.stream().map(valueMapper).collect(Collectors.toSet()))));
    }

    public static <T, K, V> Map<K, List<V>> group2ListMap(Collection<T> objs, Function<T, K> keyMapper, Function<T, V> valueMapper) {
        if (CollectionUtils.isEmpty(objs)) {
            return Maps.newHashMap();
        }
        return objs.stream()
            .filter(e -> keyMapper.apply(e) != null && valueMapper.apply(e) != null)
            .collect(Collectors.groupingBy(keyMapper,
                Collectors.collectingAndThen(Collectors.toList(), e -> e.stream().map(valueMapper).collect(Collectors.toList()))));
    }

    public static <T> BigDecimal reduce(Collection<T> objs, Function<T, BigDecimal> function) {
        if (CollectionUtils.isEmpty(objs)) {
            return BigDecimal.ZERO;
        }
        return objs.stream()
            .filter(e -> function.apply(e) != null)
            .map(function)
            .reduce(BigDecimal.ZERO, BigDecimal::add);
    }

    public static BigDecimal empty2Zero(String value) {
        if (StringUtils.isEmpty(value)) {
            return BigDecimal.ZERO;
        }
        try {
            return new BigDecimal(value);
        } catch (Exception e) {
            return BigDecimal.ZERO;
        }
    }
}