java 划分double區間練手示例Demo

1. 前期准備：

① 編輯器：Eclipse

② 構建工具：Maven

③ 第三方java開發工具：FastJSON, Guava

2. 全部示例代碼展示：

package com.drew.test;

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;

import com.alibaba.fastjson.JSON;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;

/**
 * @author zero 2019/04/08
 */
public class Java8future {

    public static void main(String[] args) {
        // System.out.println(genRandomRatio(0.75, 0.8, 2));
        // System.out.println(genRandomDoubleList(0.75, 0.8, 2, 2));
        // System.out.println(genRandomRatio(1, 8, 2));
        // System.out.println(genRandomDoubleList(1, 8, 2, 10));
        // System.out.println(genRandomInteger(1, 10));
        // System.out.println(testGenRandomIntegerList());
        // System.out.println(distributeInteger(Arrays.asList(1,2,3,6), 4));
        // testGeneratorDouble();
        // shuffleList();
        // testListSizeIsEqual();
        testRandomDistributeMap(); // MAIN-Test
        // System.out.println(doubleSecToTime(0.0));

    }

    /**
     * （double）秒轉時分秒毫秒（HH:mm:ss:SSS）
     * 
     * @param seconds 秒（雙精度類型的數據）
     * @return string類型的時分秒毫秒（HH:mm:ss:SSS）
     * @author zero 2019/04/11
     */
    public static String doubleSecToTime(double seconds) {
        if (seconds == 0.0) {
            return "0.0";
        }
        // 注意：BigDecimal.ROUND_HALF_UP：四舍五入、BigDecimal.ROUND_CEILING：向上取整
        double d = new BigDecimal(Double.toString(seconds)).setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue();
        int msec = (int)(d * 1000) % 1000;
        // System.out.println(msec);
        int sec = (int)(d * 1000) / 1000;
        // System.out.println(sec);
        int hour = sec / 3600;
        int minute = (sec - hour * 3600) / 60;
        int second = (sec - hour * 3600 - minute * 60);

        StringBuffer sb = new StringBuffer();
        if (hour > 0) {
            sb.append(hour + "h");
        }
        if (minute > 0) {
            sb.append(minute + "m");
        }
        if (second > 0) {
            sb.append(second + "s");
        }
        if (msec != 0) {
            sb.append(msec + "ms");
        }
        return sb.toString();
    }

    public static List<Integer> testGenRandomIntegerList() {
        List<Integer> list = Lists.newArrayList();
        for (int i = 0; i < 20; i++) {
            list.add(genRandomInteger(5, 10));
        }
        return list;
    }

    // ========================↓↓↓ 測試map根據key分區 ↓↓↓==========================
    public static void testRandomDistributeMap() {
        Map<Double, Integer> map = Maps.newLinkedHashMap();
        // 1. 為了測試，隨機生成map數據
        int mapKeyCount = 20;
        // int range = 10; // 每個值的范圍區間
        for (int i = 0; i < mapKeyCount; i++) {
            // double key = new BigDecimal(Math.random() * range).setScale(0, BigDecimal.ROUND_HALF_UP).doubleValue();
            // Integer value = new BigDecimal(Math.random() * range).setScale(0, BigDecimal.ROUND_HALF_UP).intValue();
            double key = genRandomRatio(1, 10, 2);// 每個double類型數據值范圍區間：[1,10]，精確度為2.
            Integer value = (int)genRandomRatio(1, 10, 0);// 每個double類型數據值范圍區間：[1,10]，精確度為0.（是int類型）
            map.put(key, value);
            System.out.print(key + " ");
        }
        System.out.println("\n隨機生成的map：" + map);
        // 2. 對map進行排序：
        Map<Double, Integer> sortedMapByKey = sortByKey(map, false);
        System.out.println("按key↑排map：" + sortedMapByKey);
        Map<Double, Integer> sortedMapByValue = sortByValue(map, true);
        System.out.println("按val↓排map：" + sortedMapByValue);
        // 3. 調用划分區間的方法this.randomDistribute(map,ratio)方法
        double ratio = genRandomRatio(0.75, 0.8, 2);
        System.out.println("隨機生成的比值為：" + ratio);
        Map<String, Integer> result = randomDistribute(sortedMapByValue, ratio);
        // 4. 輸出result數據
        for (String timeNode : result.keySet()) {
            System.out.println(timeNode + "   \t" + result.get(timeNode));
        }
        // 5. 組裝前端所需的數據格式：樹狀圖（同chart數據格式）
        Map<String, Object> needResultFormatterMap = Maps.newHashMap();
        needResultFormatterMap.put("attrDetails", ImmutableMap.of("axis", result.keySet(), "data", result.values(),
            "field", "avg_spent_time", "legend", "平均時長分布"));
        System.out.println(JSON.toJSONString(needResultFormatterMap));
    }

    /**
     * 將map數據按照key分隔區間
     * 
     * @param map key:時刻，value:訪客數（time-visits）
     * @param ratio 比值（重點查看多少比例的數據）
     * @return Map<String, Integer>中，key:時間區間，value：訪問數
     * @author zero 2019/04/10
     */
    public static Map<String, Integer> randomDistribute(Map<Double, Integer> map, double ratio) {
        if (map.isEmpty()) {
            return ImmutableMap.of("No data!", 0);
        }
        Map<String, Integer> result = Maps.newLinkedHashMap();
        double sum = map.values().stream().reduce((a, b) -> a + b).get();// map的value累加求和。
        double dirtributeNode = Math.round(sum * ratio);
        System.out.println("所有訪客數：" + sum + "，划分節點：" + dirtributeNode);
        // 第一次划分區間：（8--2）
        Map<Double, Integer> tMap = Maps.newLinkedHashMap();
        long tmpSum = 0;
        for (Double key : map.keySet()) {
            tmpSum += map.get(key);
            if (tmpSum <= dirtributeNode) {
                tMap.put(key, map.get(key));
            } else {
                tMap.put(key, map.get(key));
                break;
            }
        }
        System.out.println("第一次按照比值截取之后的map：" + tMap);
        Map<Double, Integer> afterRatioMap = sortByKey(tMap, false);
        System.out.println("按key↑排map：" + afterRatioMap);
        List<Double> keys = Lists.newArrayList(afterRatioMap.keySet());
        // 對keys集合分區間：
        List<List<Double>> indexList = distributeDouble(keys, genRandomInteger(30, 60), 2);
        // System.out.println("固定划分好的區間段：" + distributeDouble(keys, 60, 2));

        for (List<Double> list : indexList) {
            // start為一小段的閉區間，end：為一小段的開區間。如：list為[1,5]表示的值范圍為[1,5)即 1<=x<5，但是indexList中如果list為最后一個，最為雙閉區間
            // 注意：如果划分之后的區間，list無元素存在；則不顯示此區間的個數為0.（根據需求更改：無元素在此區間，也得顯示區間的元素為0.）
            Integer tmp = 0;
            double start = list.get(0), end = list.get(1);
            for (Double timeKey : afterRatioMap.keySet()) {
                if (indexList.indexOf(list) == indexList.size() - 1) {
                    if (start <= timeKey && timeKey <= end) {
                        tmp = result.get("[" + doubleSecToTime(start) + "," + doubleSecToTime(end) + "]") == null ? 0
                            : result.get("[" + doubleSecToTime(start) + "," + doubleSecToTime(end) + "]");
                        result.put("[" + doubleSecToTime(start) + "," + doubleSecToTime(end) + "]",
                            tmp + afterRatioMap.get(timeKey));
                    }
                } else {
                    if (start <= timeKey && timeKey < end) {
                        tmp = result.get("[" + doubleSecToTime(start) + "," + doubleSecToTime(end) + ")") == null ? 0
                            : result.get("[" + doubleSecToTime(start) + "," + doubleSecToTime(end) + ")");
                        result.put("[" + doubleSecToTime(start) + "," + doubleSecToTime(end) + ")",
                            tmp + afterRatioMap.get(timeKey));
                    }
                }
            }
        }
        return result;
    }

    /**
     * 隨機生成一個[low,high]雙閉區間中隨機的一個double類型數據
     * 
     * @param low 最小值（包含）
     * @param high 最大值（包含）
     * @param effective_number double類型的精度（如果effective_number=3，則保留三位有效數字）
     * @return [low,high]雙閉區間中隨機的一個double類型數據，例如：0.77
     * @author zero 2019/04/10
     */
    public static double genRandomRatio(double low, double high, int effective_number) {
        double d = new BigDecimal(Double.toString(Math.random() * (high - low) + low))
            .setScale(effective_number, BigDecimal.ROUND_HALF_UP).doubleValue();
        return d;
    }

    public static int genRandomInteger(int low, int high) {
        return new BigDecimal(Math.random() * (high - low + 1) + low).intValue();
    }

    /**
     * 隨機生成一個[low,high]雙閉區間中隨機count個數的double類型數據的list集合
     * 
     * @param low 最小值（包含）
     * @param high 最大值（包含）
     * @param effective_number double類型的精度（如果effective_number=3，則保留三位有效數字）
     * @param count list大小（即生成多少個隨機數字）
     * @return
     * @author zero 2019/04/10
     */
    public static List<Double> genRandomDoubleList(double low, double high, int effective_number, int count) {
        List<Double> randomDouble = Lists.newArrayList();
        for (int i = 0; i < count; i++) {
            double d = new BigDecimal(Double.toString(Math.random() * (high - low) + low))
                .setScale(effective_number, BigDecimal.ROUND_HALF_UP).doubleValue();
            randomDouble.add(d);
        }
        return randomDouble;
    }

    /**
     * 將integer類型的集合按照區間個數划分固定區間范圍的多個子集合（左開右閉） TODO 可以借鑒distributeDouble()方法的分區間原理
     * 
     * @param list 待划分的區間
     * @param count 區間個數
     * @return
     * @author zero 2019/04/10
     */
    public static List<List<Integer>> distributeInteger(List<Integer> list, int count) {
        Collections.sort(list);
        int min = list.get(0);
        int max = list.get(list.size() - 1);
        // TODO 特殊情況：當list為：1，2，3，4時，區間格式為4，則結果為[[1, 2], [2, 3], [3, 4], [4, 5]]。即最后一個區間[4,5]是沒有數據的
        int range = (max - min) / count == 0 ? 1 : (max - min) / count;
        System.out.println("最大值：" + max + "\t最小值：" + min + "\t區間范圍：" + range);
        List<List<Integer>> resultList = Lists.newArrayList();
        int tmpStart = min, b1, b2;
        for (int i = 0; i < count; i++) {
            b1 = tmpStart;
            b2 = range;
            resultList.add(Arrays.asList(b1, b1 + b2));
            tmpStart = b1 + b2;
        }
        if (tmpStart < max) {
            resultList.add(Arrays.asList(tmpStart, max));
        }
        return resultList;
    }

    /**
     * 分散有序的list集合(打亂有序集合)
     * 
     * @author zero 2019/04/10
     */
    public static void shuffleList() {
        List<Integer> list = Lists.newArrayList(1, 2, 3, 4, 5);
        Collections.shuffle(list);// 打亂初始的list集合。
        System.out.println(list.get(0));
    }

    // ========================↓↓↓ double集合分區 ↓↓↓==========================
    public static void testGeneratorDouble() {
        int effective_number = 3;// 生成double值的精確度
        int length = 15;// 生成list集合數量
        int range = 100;// 每個數字的范圍
        int space = 5; // 划分十個區間
        // 隨機生成
        List<Double> list = generatorDouble(effective_number, length, range);
        System.out.println(list);
        // 不定區間-碰撞算法

        // 固定區間-划分
        List<List<Double>> distributeList = distributeDouble(list, space, effective_number);
        System.out.println(distributeList);
    }

    /**
     * 生成雙精度類型的list集合數據
     * 
     * @param effective_number 生成double值的精確度
     * @param length 生成list集合數量
     * @param range 每個值所在區間[0,100]
     * @return
     * @author zero 2019/04/09
     */
    public static List<Double> generatorDouble(int effective_number, int length, int range) {
        List<Double> randomList = Lists.newArrayList();
        for (int i = 0; i < length; i++) {
            // 如：取0-100隨機數，則range=100
            BigDecimal temp = new BigDecimal(Math.random() * range);
            // 如：取effective_number=3位有效位
            double add_data = temp.setScale(effective_number, BigDecimal.ROUND_HALF_UP).doubleValue();
            randomList.add(add_data);
        }
        return randomList;
    }

    /**
     * 將list集合划分固定范圍區間（每小段區間范圍是固定的）
     * 
     * @param list double集合
     * @param space 需要划分的具體區間數字，例如：10為划分十個區間
     * @param effective_number 每個值的精確度
     * @author zero 2019/04/09
     */
    public static List<List<Double>> distributeDouble(List<Double> list, int space, int effective_number) {
        // 針對double划分區間
        Collections.sort(list);
        double min = list.get(0);
        double max = list.get(list.size() - 1);
        double range = (max - min) / space;
        BigDecimal temp = new BigDecimal(range);
        range = temp.setScale(effective_number, BigDecimal.ROUND_HALF_UP).doubleValue();
        // ↑↑划分區間的核心代碼 ↑↑

        // 顯示每個划分好的固定區間的范圍
        List<List<Double>> distributeList = Lists.newArrayList();
        double tmpStart = min;
        BigDecimal b1, b2;
        for (int i = 0; i < space; i++) {
            b1 = new BigDecimal(Double.toString(tmpStart));
            b2 = new BigDecimal(Double.toString(range));
            // System.out.println("[" + b1.doubleValue() + "," + b1.add(b2).doubleValue() + ")");// 左閉右開
            distributeList.add(Arrays.asList(b1.doubleValue(), b1.add(b2).doubleValue()));
            tmpStart = b1.add(b2).doubleValue();
        }
        if (tmpStart < max) {
            distributeList.add(Arrays.asList(tmpStart, max));
        }
        System.out.println("最小值：" + min + "\t最大值：" + max + "\t區間值：" + range + "\t區間個數為：" + distributeList.size());
        return distributeList;
    }

    // ========================↓↓↓ 對map進行排序 ↓↓↓==========================
    public static void testSortMap() {
        Map<String, Integer> map = ImmutableMap.of("0", 3, "1", 8, "0.29", 7, "1.67", 3);
        System.out.println("原始的map：" + map);
        System.out.println("根據map的key降序：" + sortByKey(map, true));
        System.out.println("根據map的key升序：" + sortByKey(map, false));
        System.out.println("根據map的value降序：" + sortByValue(map, true));
        System.out.println("根據map的value升序：" + sortByValue(map, false));
    }

    /**
     * 根據map的key排序(如果map中的key為Integer類型的字符串，請將map中的key設置為Integer)
     * 
     * @param map 待排序的map
     * @param isDesc 是否降序，true：降序，false：升序
     * @return 排序好的map
     * @author zero 2019/04/08
     */
    public static <K extends Comparable<? super K>, V> Map<K, V> sortByKey(Map<K, V> map, boolean isDesc) {
        Map<K, V> result = Maps.newLinkedHashMap();
        if (isDesc) {
            map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByKey().reversed())
                .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
        } else {
            map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByKey())
                .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
        }
        return result;
    }

    /**
     * 根據map的value排序
     * 
     * @param map 待排序的map
     * @param isDesc 是否降序，true：降序，false：升序
     * @return 排序好的map
     * @author zero 2019/04/08
     */
    public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue(Map<K, V> map, boolean isDesc) {
        Map<K, V> result = Maps.newLinkedHashMap();
        if (isDesc) {
            map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByValue().reversed())
                .forEach(e -> result.put(e.getKey(), e.getValue()));
        } else {
            map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByValue())
                .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
        }
        return result;
    }

}

3. 示例結果展示：