1. 描述：将integer类型的集合数据，按照比例进行固定区间划分。
2. 示例全部代码：
package com.drew.test;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import com.alibaba.fastjson.JSON;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
/**
* @author zero 2019/04/10
*/
public class DistributeIntegerList {
public static void main(String[] args) {
testRandomDistributeMap();
// System.out.println("===================================");
// System.out.println(genRandomInt(5, 10));
// System.out.println(genRandomIntList(5, 10, 10));
// System.out.println(genRandomDouble(5, 10, 2));
// System.out.println(genRandomDoubleList(5, 10, 2, 20));
// System.out.println("===================================");
}
/**
* 本测试方法的整体思路: <br>
* 要求：随机给定的map集合，按照value值的大小排序，截取一定比例的数据之后对截取的数据按照key正序之后----进行固定区间分组。
*
* @author zero 2019/04/10
*/
public static void testRandomDistributeMap() {
Map<Integer, Integer> map = Maps.newLinkedHashMap();
// 1. 为了测试，随机生成map数据
int mapKeyCount = 50;// 生成随机数个数
int range = 100;// 每个值的范围[1,100]
for (int i = 0; i < mapKeyCount; i++) {
int value = new BigDecimal(Math.random() * range).setScale(0, BigDecimal.ROUND_HALF_UP).intValue();
int key = new BigDecimal(Math.random() * range).setScale(0, BigDecimal.ROUND_HALF_UP).intValue();
map.put(key, value);
System.out.print(key + " ");
}
System.out.println("\n随机生成的map：" + map);
// 2. 对map进行排序：
Map<Integer, Integer> sortedMapByKey = sortByKey(map, false);
System.out.println("按key↑排map：" + sortedMapByKey);
Map<Integer, Integer> sortedMapByValue = sortByValue(map, true);
System.out.println("按val↓排map：" + sortedMapByValue + "\n");
// 3. 调用划分区间的方法this.randomDistribute(map,ratio)方法
double ratio = genRandomDouble(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.newLinkedHashMap();
Map<String, Object> nodeNeedMap = Maps.newLinkedHashMap();
nodeNeedMap.put("axis", result.keySet());
nodeNeedMap.put("data", result.values());
nodeNeedMap.put("field", "avg_spent_time");
nodeNeedMap.put("legend", "平均时刻分布");
needResultFormatterMap.put("attrDetails", nodeNeedMap);
System.out.println("json格式：" + 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<Integer, Integer> map, double ratio) {
Map<String, Integer> result = Maps.newLinkedHashMap();
long sum = map.values().stream().reduce((a, b) -> a + b).get();// map的value累加求和。
long dirtributeNode = Math.round(sum * ratio);
System.out.println("所有访客数：" + sum + "，划分节点：" + dirtributeNode);
// 第一次划分区间：（8--2）
Map<Integer, Integer> tMap = Maps.newLinkedHashMap();
long tmpSum = 0;
for (Integer 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<Integer, Integer> afterRatioMap = sortByKey(tMap, false);
System.out.println("按key↑排map：" + afterRatioMap);
List<Integer> keys = Lists.newArrayList(afterRatioMap.keySet());
// 对keys集合分区间：TODO 区间是固定设置好的，可以随机生成区间数。可以调用此类中的genRandomInt()方法
System.out.println("固定划分好的区间段：" + distributeInteger(keys, 5));
List<List<Integer>> indexList = distributeInteger(keys, 5);
for (List<Integer> list : indexList) {
// start为一小段的闭区间，end：为一小段的开区间。如：list为[1,5]表示的值范围为[1,5)即 1<=x<5，但是indexList中如果list为最后一个，最为双闭区间
// 注意：如果划分之后的区间，list无元素存在；则不显示此区间的个数为0.（根据需求更改：无元素在此区间，也得显示区间的元素为0.）
Integer tmp = 0, start = list.get(0), end = list.get(1);
for (Integer timeKey : afterRatioMap.keySet()) {
if (indexList.indexOf(list) == indexList.size() - 1) {
if (start <= timeKey && timeKey <= end) {
tmp = result.get("[" + start + "," + end + "]") == null ? 0
: result.get("[" + start + "," + end + "]");
result.put("[" + start + "," + end + "]", tmp + afterRatioMap.get(timeKey));
}
} else {
if (start <= timeKey && timeKey < end) {
tmp = result.get("[" + start + "," + end + ")") == null ? 0
: result.get("[" + start + "," + end + ")");
result.put("[" + start + "," + 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 genRandomDouble(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;
}
/**
* 生成从low到high的随机整数[low,high]
*
* @param low 最小值（包含）
* @param high 最大值（包含）
* @return
* @author zero 2019/04/10
*/
public static int genRandomInt(int low, int high) {
int num = new BigDecimal((int)(Math.random() * (high - low + 1) + low)).intValue();
return num;
}
/**
* 随机生成一个[low,high]双闭区间中随机count个数的int类型数据的list集合
*
* @param low 最小值（包含）
* @param high 最大值（包含）
* @param count list大小（即生成多少个）
* @return
* @author zero 2019/04/10
*/
public static List<Integer> genRandomIntList(int low, int high, int count) {
List<Integer> randomIntList = Lists.newArrayList();
for (int i = 0; i < count; i++) {
randomIntList.add(new BigDecimal((int)(Math.random() * (high - low + 1) + low)).intValue());
}
return randomIntList;
}
/**
* 随机生成一个[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);
}
System.out.println("原始的doubleList:" + randomDouble);
Collections.sort(randomDouble);
System.out.println("\n升序后的doubleList:" + randomDouble);
return randomDouble;
}
/**
* 将integer类型的集合按照区间个数划分固定区间范围的多个子集合（左开右闭）
*
* @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;
}
/**
* 根据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. 示例结果显示：
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
