java计算百分比

计算百分比

public class MathUtil {
    /**
     * 计算百分比，方法保证返回的map总百分比为100
     * @param map 元数据map，key为数据项，value为该数据项分值
     * @param sum 所有数据项总分值
     * @return 计算后的百分比map，key为数据项，value为对应百分比
     */
    public static HashMap<String, Integer> calcPercentage(Map<String, Integer> map, Integer sum) {
        //在四舍五入处理中四舍的key以及它们的损失数值
        List<Pair<String, Float>> loserList = new ArrayList<>();
        //在四舍五入处理中五入的key以及它们的收益数值
        List<Pair<String, Float>> gainerList = new ArrayList<>();
        HashMap<String, Integer> processedMap = new HashMap<>();
        Iterator<String> iterator = map.keySet().iterator();
        while (iterator.hasNext()) {
            String key = iterator.next();
            Integer value = map.get(key);
            float x = (float) value / (float) sum * 100;
            BigDecimal bigDecimal = new BigDecimal(x);
            //先按照四舍五入规则计算
            processedMap.put(key, bigDecimal.setScale(0, RoundingMode.HALF_UP).intValue());
            float y = x % 1;
            //计算损失或收益，并丢入对应map
            if (y >= 0.5) {
                gainerList.add(Pair.of(key, 1 - y));
            } else {
                loserList.add(Pair.of(key, y));
            }
        }
        //四舍五入处理后百分比数的和
        int processedSum = 0;
        for (Integer i : processedMap.values()) {
            processedSum += i;
        }
        //如果四舍五入处理后百分比数的和不足100，则对亏损者们依据亏损大到小依次进位
        if (processedSum < 100) {
            //需要处理的个数
            int dealCount = 100 - processedSum;
            Comparator<Pair<String, Float>> loserComparator = (Pair<String, Float> a, Pair<String, Float> b) -> {
                if (Float.compare(a.getRight(), b.getRight()) == 0) {
                    //亏损相同时，初始数值大的优先，先正常比较大小，然后使用0减 是为了实现list从大到小排序
                    return 0 - Integer.compare(map.get(a.getLeft()), map.get(b.getLeft()));
                } else {
                    //使用0减 是为了实现list从大到小排序
                    return 0 - Float.compare(a.getRight(), b.getRight());
                }
            };
            loserList = loserList.stream().sorted(loserComparator).collect(Collectors.toList());
            for (int z = 0; z < dealCount; z++) {
                String loserKey = loserList.get(z).getLeft();
                processedMap.put(loserKey, processedMap.get(loserKey) + 1);
            }
        }
        //如果四舍五入处理后百分比数的和大于100，则对收益者们依据收益小到大依次取消进位处理
        if (processedSum > 100) {
            //需要处理的个数
            int dealCount = processedSum - 100;
            Comparator<Pair<String, Float>> gainerComparator = (Pair<String, Float> a, Pair<String, Float> b) -> {
                if (Float.compare(a.getRight(), b.getRight()) == 0) {
                    //收益相同时，初始数值小的优先进行取消进位
                    return Integer.compare(map.get(a.getLeft()), map.get(b.getLeft()));
                } else {
                    return Float.compare(a.getRight(), b.getRight());
                }
            };
            gainerList = gainerList.stream().sorted(gainerComparator).collect(Collectors.toList());
            for (int z = 0; z < dealCount; z++) {
                String gainerKey = gainerList.get(z).getLeft();
                processedMap.put(gainerKey, processedMap.get(gainerKey) - 1);
            }
        }
        return processedMap;
    }
}