统计各方面指标的java代码

最新推荐文章于 2021-08-08 15:35:51 发布

wesupercsdn

最新推荐文章于 2021-08-08 15:35:51 发布

阅读量715

点赞数

本文链接：https://blog.csdn.net/wesupercsdn/article/details/79783298

版权

Constant.java

package wonderful.tool;

public class Constant {

// ssq 1 3d 2 dlt 3
public static final int Const_SSQ = 1;
public static final int Const_3D = 2;
public static final int Const_DLT = 3;

public static final int Const_SSQ_CNT_RESULT = 6;
public static final int Const_3D_CNT_RESULT = 3;
public static final int Const_DLT_CNT_RESULT = 5;

public static final int Const_SSQ_CNT = 33;
public static final int Const_3D_CNT = 10;
public static final int Const_DLT_CNT = 35;

public static final int Const_SSQ_START = 1;
public static final int Const_3D_START = 0;
public static final int Const_DLT_START = 1;

public static final int Const_SSQ_END = 33;
public static final int Const_3D_END = 9;
public static final int Const_DLT_END = 35;

public static final int Const_SSQ_TOP_YILOU = 9;
public static final int Const_3D_TOP_YILOU = 5;
public static final int Const_DLT_TOP_YILOU = 10;

public static final int Const_SSQ_DIV1 = 11;
public static final int Const_SSQ_DIV2 = 22;
public static final int Const_3D_DIV1 = 2;
public static final int Const_3D_DIV2= 6;
public static final int Const_DLT_DIV1 = 12;
public static final int Const_DLT_DIV2 = 33;

public static final String WORKSPACE = "D:\\develop\\workspace";

}

DivConverter.java

package wonderful.tool;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;

public class DivConverter {

public static int getBigDivCnt(Integer div, ArrayList<Integer> arr) {

int divCnt = 0;

for (Integer num : arr) {
if ((num - 1) / 11 + 1 == div) {
divCnt = divCnt + 1;
}
}

return divCnt;
}

public static int getBigDivCntB(Integer div, ArrayList<Integer> arr) {

int divCnt = 0;

for (Integer num : arr) {
if ((num - 1) / 11 + 1 == div
&& ((num >= 6 && num <= 11) || (num >= 17 && num <= 22) || (num >= 28))) {
divCnt = divCnt + 1;
}
}

return divCnt;
}

public static int getBigDivCntSport(Integer div, ArrayList<Integer> arr) {

int divCnt = 0;

for (Integer num : arr) {
if (div == 1 && num <= 12) {
divCnt = divCnt + 1;
} else if (div == 2 && num >= 13 && num <= 23) {
divCnt = divCnt + 1;
} else if (div == 3 && num >= 24) {
divCnt = divCnt + 1;
}
}

return divCnt;
}

public static int getBigDivCntBSport(Integer div, ArrayList<Integer> arr) {

int divCnt = 0;

for (Integer num : arr) {
if (div == 1 && num >= 7 && num <= 12) {
divCnt = divCnt + 1;
} else if (div == 2 && num >= 18 && num <= 23) {
divCnt = divCnt + 1;
} else if (div == 3 && num >= 29 && num <= 35) {
divCnt = divCnt + 1;
}
}

return divCnt;
}

public static void getPosSum(ArrayList<Integer> arr,
LinkedHashMap<Integer, Integer> map,
LinkedHashMap<Integer, Integer> mapLess,
LinkedHashMap<Integer, Integer> mapEqual,
LinkedHashMap<Integer, ArrayList<Integer>> mapHistory) {

int[] posAvgArr = new int[] { 5, 10, 14, 19, 24, 29 };
for (int i = 0; i < arr.size(); i++) {
if (!map.containsKey(i + 1)) {
map.put(i + 1, arr.get(i));
} else {
map.put(i + 1, map.get(i + 1) + arr.get(i));
}
if (arr.get(i) < posAvgArr[i]) {
if (!mapLess.containsKey(i + 1)) {
mapLess.put(i + 1, 1);
} else {
mapLess.put(i + 1, mapLess.get(i + 1) + 1);
}
}
if (arr.get(i) == posAvgArr[i]) {
if (!mapEqual.containsKey(i + 1)) {
mapEqual.put(i + 1, 1);
} else {
mapEqual.put(i + 1, mapEqual.get(i + 1) + 1);
}
}
if (!map.containsKey(i + 1)) {
ArrayList<Integer> arrayList = new ArrayList<Integer>();
arrayList.add(arr.get(i) - posAvgArr[i]);
mapHistory.put(i + 1, arrayList);
} else {
mapHistory.get(i + 1).add(arr.get(i) - posAvgArr[i]);
}
}
}

public static void getPosSpan(ArrayList<Integer> arr1,
ArrayList<Integer> arr2,
LinkedHashMap<Integer, ArrayList<Integer>> mapHistory) {

for (int i = 0; i < arr1.size(); i++) {
if (!mapHistory.containsKey(i + 1)) {
ArrayList<Integer> arrTemp = new ArrayList<Integer>();
arrTemp.add(Math.abs(arr1.get(i) - arr2.get(i)));
mapHistory.put(i + 1, arrTemp);
} else {
mapHistory.get(i + 1).add(Math.abs(arr1.get(i) - arr2.get(i)));
}
}
}

public static ArrayList<Integer> getEnderFull(ArrayList<Integer> arr) {

ArrayList<Integer> tempArr = new ArrayList<Integer>();

for (Integer num : arr) {
tempArr.add(num % 10);
}

return tempArr;
}

public static int getBigDivCnt3D(Integer div, ArrayList<Integer> arr) {

int divCnt = 0;

for (Integer num : arr) {
if (div == 1 && num <= 2) {
divCnt = divCnt + 1;
} else if (div == 2 && num >= 3 && num <= 6) {
divCnt = divCnt + 1;
} else if (div == 3 && num >= 7) {
divCnt = divCnt + 1;
}
}

return divCnt;
}

public static String getBigDivPic(ArrayList<Integer> arr) {

String ret = "";
String temp = getBigDivStr(arr);

HashMap<String, Integer> posHashMap = new HashMap<String, Integer>();

if (arr.size() == 5) {
posHashMap.put("015", 1);
posHashMap.put("051", 2);
posHashMap.put("105", 3);
posHashMap.put("150", 4);
posHashMap.put("501", 5);
posHashMap.put("510", 1);

posHashMap.put("024", 1);
posHashMap.put("042", 2);
posHashMap.put("204", 3);
posHashMap.put("240", 4);
posHashMap.put("402", 5);
posHashMap.put("420", 2);

posHashMap.put("033", 1);
posHashMap.put("303", 2);
posHashMap.put("330", 3);
posHashMap.put("114", 4);
posHashMap.put("141", 5);
posHashMap.put("411", 3);

posHashMap.put("123", 2);
posHashMap.put("132", 3);
posHashMap.put("213", 4);
posHashMap.put("231", 5);
posHashMap.put("312", 4);
posHashMap.put("321", 5);

posHashMap.put("006", 1);
posHashMap.put("060", 2);
posHashMap.put("600", 3);

posHashMap.put("222", 1);
} else if (arr.size() == 3) {
// sum 42
posHashMap.put("012", 1);
posHashMap.put("102", 1);
// sum 46
posHashMap.put("021", 2);
posHashMap.put("030", 2);
// sum 42
posHashMap.put("210", 3);
posHashMap.put("201", 3);
// sum 37
posHashMap.put("003", 4);
posHashMap.put("120", 4);
// sum 43
posHashMap.put("300", 5);
posHashMap.put("111", 5);
}

for (int i = 1; i <= 5; i++) {
if (posHashMap.get(temp) == i) {
ret += " " + i + " ";
} else {
ret += " " + " " + " ";
}
}

ret += " " + temp;

return ret;
}

public static String getBigDivStr(ArrayList<Integer> arr) {

int div1 = 0;
int div2 = 0;

if (arr.size() == 6) {
div1 = Constant.Const_SSQ_DIV1;
div2 = Constant.Const_SSQ_DIV2;
} else if (arr.size() == 5) {
div1 = Constant.Const_DLT_DIV1;
div2 = Constant.Const_DLT_DIV2;
} else if (arr.size() == 3) {
div1 = Constant.Const_3D_DIV1;
div2 = Constant.Const_3D_DIV2;
}

int a1 = 0;
int a2 = 0;
int a3 = 0;

for (int i = 0; i < arr.size(); i++) {
if (arr.get(i) <= div1) {
a1++;
} else if (arr.get(i) <= div2 && arr.get(i) > div1) {
a2++;
} else {
a3++;
}
}

return a1 + "" + a2 + "" + a3;
}

}

HistoryTool.java

package wonderful.tool;

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map.Entry;

import WonderfulFile.ExportData;

public class HistoryTool {

private static ArrayList<LinkedHashMap<Integer, Integer>> hisMapArr = null;
private static ArrayList<LinkedHashMap<Integer, Integer>> timesMapArr = null;
private static ArrayList<LinkedHashMap<Integer, Integer>> timesMapArrJO = null;

public static void main(String[] args) {
// TODO Auto-generated method stub
ExportData.loadFile3d();
init(3);
System.out.println("h");
}

public static LinkedHashMap<Integer, Integer> getHisByIndex(int index) {
return hisMapArr.get(index);
}

public static LinkedHashMap<Integer, Integer> getTimsByIndex(int index) {
return timesMapArr.get(index);
}

public static LinkedHashMap<Integer, Integer> getTimsJOByIndex(int index) {
return timesMapArrJO.get(index);
}

public static void init(int term) {

ArrayList<ArrayList<Integer>> arr = ExportData.getReds();
int size = arr.get(0).size();

if (hisMapArr == null) {

hisMapArr = new ArrayList<LinkedHashMap<Integer, Integer>>(
arr.size());

LinkedHashMap<Integer, Integer> tempHisMap = new LinkedHashMap<Integer, Integer>();
clearHisMap(size, tempHisMap);

for (int i = arr.size() - 1; i > -1; i--) {
LinkedHashMap<Integer, Integer> termHisMap = new LinkedHashMap<Integer, Integer>();
for (Entry<Integer, Integer> ent : tempHisMap.entrySet()) {
if (arr.get(i).indexOf(ent.getKey()) != -1) {
tempHisMap.put(ent.getKey(), 0);
termHisMap.put(ent.getKey(), 0);
} else {
MapTool.addMapTimes(tempHisMap, ent.getKey());
termHisMap.put(ent.getKey(),
tempHisMap.get(ent.getKey()));
}
}

hisMapArr.add(termHisMap);
}
Collections.reverse(hisMapArr);
}

if (timesMapArr == null) {
timesMapArr = new ArrayList<LinkedHashMap<Integer, Integer>>(
arr.size());

for (int i = 0; i < arr.size(); i++) {
LinkedHashMap<Integer, Integer> tempTimesMap = new LinkedHashMap<Integer, Integer>();
clearTimesMap(size, tempTimesMap);

for (int j = 0; j < term && i + j < arr.size(); j++) {
for (Integer num : arr.get(i + j)) {
MapTool.addMapTimes(tempTimesMap, num);
}
}

timesMapArr.add(tempTimesMap);
}
}
if (timesMapArrJO == null) {
timesMapArrJO = new ArrayList<LinkedHashMap<Integer, Integer>>(
arr.size());

for (int i = 0; i < arr.size(); i++) {
LinkedHashMap<Integer, Integer> tempTimesMap = new LinkedHashMap<Integer, Integer>();
clearTimesJOMap(size, tempTimesMap);

for (int j = 0; j < term && i + j < arr.size(); j++) {
for (Integer num : arr.get(i + j)) {
MapTool.addMapTimes(tempTimesMap, num % 2);
}
}

timesMapArrJO.add(tempTimesMap);
}
}
}

private static void clearHisMap(int size,
LinkedHashMap<Integer, Integer> tempTimesMap) {
// init
if (Constant.Const_3D_CNT_RESULT == size) {
for (int i = 0; i < Constant.Const_3D_CNT; i++) {
tempTimesMap.put(i, 0);
}
} else if (Constant.Const_SSQ_CNT_RESULT == size) {
for (int i = 0; i < Constant.Const_SSQ_CNT; i++) {
tempTimesMap.put(i + 1, 0);
}
} else if (Constant.Const_DLT_CNT_RESULT == size) {
for (int i = 0; i < Constant.Const_DLT_CNT; i++) {
tempTimesMap.put(i + 1, 0);
}
}
}

private static void clearTimesMap(int size,
LinkedHashMap<Integer, Integer> tempTimesMap) {
// init
if (Constant.Const_3D_CNT_RESULT == size) {
for (int i = 0; i < Constant.Const_3D_CNT; i++) {
tempTimesMap.put(i, 0);
}
} else if (Constant.Const_SSQ_CNT_RESULT == size) {
for (int i = 0; i < Constant.Const_SSQ_CNT; i++) {
tempTimesMap.put(i + 1, 0);
}
} else if (Constant.Const_DLT_CNT_RESULT == size) {
for (int i = 0; i < Constant.Const_DLT_CNT; i++) {
tempTimesMap.put(i + 1, 0);
}
}
}

private static void clearTimesJOMap(int size,
LinkedHashMap<Integer, Integer> tempTimesMap) {
tempTimesMap.put(0, 0);
tempTimesMap.put(1, 0);
}

}

MapTool.java

package wonderful.tool;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.Map.Entry;

public class MapTool {

public static LinkedHashMap<Integer, Integer> addMapTimes(LinkedHashMap<Integer, Integer> map,
int num) {
if (map.containsKey(num)) {
map.put(num, map.get(num) + 1);
} else {
map.put(num, 1);
}
return map;
}

public static LinkedHashMap<Double, Integer> addMapTimes(LinkedHashMap<Double, Integer> map,
Double num) {
if (map.containsKey(num)) {
map.put(num, map.get(num) + 1);
} else {
map.put(num, 1);
}
return map;
}

public static LinkedHashMap<Integer, Integer> addMapTimes(LinkedHashMap<Integer, Integer> map,
int num, int times) {
if (map.containsKey(num)) {
map.put(num, map.get(num) + times);
} else {
map.put(num, times);
}
return map;
}

public static LinkedHashMap<String, Integer> addMapTimes(LinkedHashMap<String, Integer> map,
String num) {
if (map.containsKey(num)) {
map.put(num, map.get(num) + 1);
} else {
map.put(num, 1);
}
return map;
}

public static LinkedHashMap<String, Integer> setZeroVal(LinkedHashMap<String, Integer> map) {

map.clear();

map.put("0:0:0", 0);
map.put("0:0:1", 0);
map.put("0:1:0", 0);
map.put("0:1:1", 0);
map.put("1:0:0", 0);
map.put("1:0:1", 0);
map.put("1:1:0", 0);
map.put("1:1:1", 0);

return map;
}

public static LinkedHashMap<ArrayList<Integer>, Integer> addMapTimes(
LinkedHashMap<ArrayList<Integer>, Integer> map, ArrayList<Integer> arr) {
if (map.containsKey(arr)) {
map.put(arr, map.get(arr) + 1);
} else {
map.put(arr, 1);
}
return map;
}

public static LinkedHashMap<ArrayList<Integer>, ArrayList<Integer>> addMapTimes(
LinkedHashMap<ArrayList<Integer>, ArrayList<Integer>> map, ArrayList<Integer> arr,
int term) {
if (map.containsKey(arr)) {
map.get(arr).add(term);
} else {
ArrayList<Integer> temp = new ArrayList<Integer>();
temp.add(term);
map.put(arr, temp);
}
return map;
}

public static LinkedHashMap<String, ArrayList<String>> addMapTimesHis(
LinkedHashMap<String, ArrayList<String>> mapHis, String num, String his) {
if (mapHis.containsKey(num)) {
mapHis.get(num).add(his);
} else {
ArrayList<String> temp = new ArrayList<String>();
temp.add(his);
mapHis.put(num, temp);
}
return mapHis;
}

public static LinkedHashMap<ArrayList<Integer>, Integer> getSubMap(
LinkedHashMap<ArrayList<Integer>, Integer> mapComCover, int start, int end) {

LinkedHashMap<ArrayList<Integer>, Integer> map = new LinkedHashMap<ArrayList<Integer>, Integer>();
int cnt = 0;

for (Entry<ArrayList<Integer>, Integer> ent : mapComCover.entrySet()) {

if (cnt >= start - 1 && cnt <= end - 1) {
map.put(ent.getKey(), ent.getValue());
}
cnt++;
}

return map;
}

public static LinkedHashMap<ArrayList<String>, ArrayList<Integer>> getSubMapAA(
LinkedHashMap<ArrayList<String>, ArrayList<Integer>> mapComCover, int start, int end) {

LinkedHashMap<ArrayList<String>, ArrayList<Integer>> map = new LinkedHashMap<ArrayList<String>, ArrayList<Integer>>();
int cnt = 0;

for (Entry<ArrayList<String>, ArrayList<Integer>> ent : mapComCover.entrySet()) {

if (cnt >= start - 1 && cnt <= end - 1) {
map.put(ent.getKey(), ent.getValue());
}
cnt++;
}

return map;
}

public static ArrayList<Integer> getKeyArrFromMap(LinkedHashMap<Integer, Integer> map,
int start, int end) {

ArrayList<Integer> arrRet = new ArrayList<Integer>();

int i = 0;

for (Entry<Integer, Integer> ent : map.entrySet()) {
if (i + 1 >= start && i + 1 <= end) {
arrRet.add(ent.getKey());
}
i++;
}

return arrRet;
}

}

Sorter.java

package wonderful.tool;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;

public class Sorter {

public static LinkedHashMap<Integer, Integer> sortMapByValue(
LinkedHashMap<Integer, Integer> map) {

ArrayList<Entry<Integer, Integer>> entries = new ArrayList<Entry<Integer, Integer>>(
map.entrySet());
Collections.sort(entries,
new Comparator<Map.Entry<Integer, Integer>>() {
public int compare(Map.Entry<Integer, Integer> ent1,
Map.Entry<Integer, Integer> ent2) {
Integer val1 = (Integer) ent1.getValue();
Integer val2 = (Integer) ent2.getValue();
if (val1 != val2) {
return val1.compareTo(val2);
} else {
return ent1.getKey().compareTo(ent2.getKey());
}

}
});

map.clear();

for (Entry<Integer, Integer> entry : entries) {
map.put(entry.getKey(), entry.getValue());
}

return map;
}

public static LinkedHashMap<Integer, Double> sortMapByDoubleValueDesc(LinkedHashMap<Integer, Double> map) {

ArrayList<Entry<Integer, Double>> entries = new ArrayList<Entry<Integer, Double>>(map
.entrySet());
Collections.sort(entries, new Comparator<Map.Entry<Integer, Double>>() {
public int compare(Map.Entry<Integer, Double> ent1, Map.Entry<Integer, Double> ent2) {
Double val1 = (Double)ent1.getValue();
Double val2 = (Double)ent2.getValue();
if (val1 != val2) {
return val2.compareTo(val1);
} else {
return ent2.getKey().compareTo(ent1.getKey());
}

}
});

map.clear();

for (Entry<Integer, Double> entry : entries) {
map.put(entry.getKey(), entry.getValue());
}

return map;
}

public static ArrayList<Integer> sortArr(ArrayList<Integer> arr) {

Collections.sort(arr, new Comparator<Integer>() {
public int compare(Integer i1, Integer i2) {
Integer val1 = (Integer) i1;
Integer val2 = (Integer) i2;
return val1.compareTo(val2);
}
});

return arr;
}

public static LinkedHashMap<ArrayList<Integer>, Integer> sortArrKeyMapByValueDesc(
LinkedHashMap<ArrayList<Integer>, Integer> map) {

ArrayList<Entry<ArrayList<Integer>, Integer>> entries = new ArrayList<Entry<ArrayList<Integer>, Integer>>(
map.entrySet());
Collections.sort(entries,
new Comparator<Map.Entry<ArrayList<Integer>, Integer>>() {
public int compare(
Map.Entry<ArrayList<Integer>, Integer> ent1,
Map.Entry<ArrayList<Integer>, Integer> ent2) {
Integer val1 = (Integer) ent1.getValue();
Integer val2 = (Integer) ent2.getValue();
return val2.compareTo(val1);
}
});

map.clear();

for (Entry<ArrayList<Integer>, Integer> entry : entries) {
map.put(entry.getKey(), entry.getValue());
}

return map;
}

public static LinkedHashMap<ArrayList<Integer>, Integer> sortArrKeyMap2ByValue(
LinkedHashMap<ArrayList<Integer>, Integer> map,
LinkedHashMap<ArrayList<Integer>, Integer> mapTimes) {

ArrayList<Entry<ArrayList<Integer>, Integer>> entries = new ArrayList<Entry<ArrayList<Integer>, Integer>>(
map.entrySet());
Collections.sort(entries,
new Comparator<Map.Entry<ArrayList<Integer>, Integer>>() {
public int compare(
Map.Entry<ArrayList<Integer>, Integer> ent1,
Map.Entry<ArrayList<Integer>, Integer> ent2) {
Integer val1 = (Integer) ent1.getValue();
Integer val2 = (Integer) ent2.getValue();
if (!val1.equals(val2)) {
return val1.compareTo(val2);
} else {
Integer val3 = mapTimes
.get((ArrayList<Integer>) ent1.getKey());
Integer val4 = mapTimes
.get((ArrayList<Integer>) ent2.getKey());
return val3.compareTo(val4);
}

}

private LinkedHashMap<ArrayList<Integer>, Integer> mapTimes;

public Comparator<Map.Entry<ArrayList<Integer>, Integer>> accept(
LinkedHashMap<ArrayList<Integer>, Integer> mapTimes) {
this.mapTimes = mapTimes;
return this;
}
}.accept(mapTimes));

map.clear();

for (Entry<ArrayList<Integer>, Integer> entry : entries) {
map.put(entry.getKey(), entry.getValue());
}

return map;
}

public static LinkedHashMap<String, ArrayList<Integer>> sortStringArrByValSizeDesc(
LinkedHashMap<String, ArrayList<Integer>> map) {

ArrayList<Entry<String, ArrayList<Integer>>> entries = new ArrayList<Entry<String, ArrayList<Integer>>>(
map.entrySet());
Collections.sort(entries,
new Comparator<Map.Entry<String, ArrayList<Integer>>>() {
public int compare(
Map.Entry<String, ArrayList<Integer>> ent1,
Map.Entry<String, ArrayList<Integer>> ent2) {
Integer val1 = ent1.getValue().size();
Integer val2 = ent2.getValue().size();
// if (val1 != val2) {
// return val1.compareTo(val2);
// } else {
// return ent1.getKey().compareTo(ent2.getKey());
// }
return val2.compareTo(val1);

}
});

map.clear();

for (Entry<String, ArrayList<Integer>> entry : entries) {
map.put(entry.getKey(), entry.getValue());
}

return map;
}

}

TermToIndex.java

package wonderful.tool;

import java.util.ArrayList;

import wonderful.analyzer.Loted;

public class TermToIndex {

public static int forecastWant(int strTerm) {

if (strTerm != 0) {
ArrayList<Integer> arr = new ArrayList<Integer>();
arr.add(strTerm);
if (Loted.getArrsTermAll().indexOf(arr) != -1) {
return Loted.getArrsTermAll().indexOf(arr);
} else {
arr.set(0, arr.get(0) - 1);
return Loted.getArrsTermAll().indexOf(arr) + 1;
}
} else {
return 0;
}
}

public static String getTerm(int index) {

String ret = "";
try {
ret = Loted.getArrsTermAll().get(index).get(0).toString();
} catch (Exception e) {
}
return ret;

}

}

Viewer.java

package wonderful.tool;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map.Entry;

public class Viewer {

public static void viewIIMap(HashMap<Integer, Integer> map) {

for (Entry<Integer, Integer> ent : map.entrySet()) {
System.out.println(ent);
}
}

public static void viewCoverConMap(
LinkedHashMap<ArrayList<Integer>, Integer> map,
LinkedHashMap<ArrayList<Integer>, Integer> mapComCover, int min,
int max) {

for (Entry<ArrayList<Integer>, Integer> ent : map.entrySet()) {
System.out.println(""
+ ent.getKey().toString().replace("[", "").toString()
.replace("]", "").replace(" ", "") + "=" + min
+ "|" + max + "-----" + ent.getValue() + " : "
+ String.valueOf(mapComCover.get(ent.getKey())));
}
}

public static String viewIDMapStr(HashMap<Integer, Double> map) {

String ret = "";
for (Entry<Integer, Double> ent : map.entrySet()) {
ret += ent.getKey() + " ";
}

return ret;
}

public static void viewIIMapOneLine(HashMap<Integer, Integer> map) {

for (Entry<Integer, Integer> ent : map.entrySet()) {
System.out.print(ent + " ");
}
System.out.println();
}

public static String getIIMapStrDivT(LinkedHashMap<Integer, Integer> map,
LinkedHashMap<Integer, Integer> mapTimes) {

String str = "";

for (Entry<Integer, Integer> ent : map.entrySet()) {
str += "" + ent.getKey() + "区" + ent.getValue() + "次(大"
+ mapTimes.get(ent.getKey()) + ") ";
}

return str;
}

public static void viewMapStrArr(
LinkedHashMap<String, ArrayList<Integer>> map) {

for (Entry<String, ArrayList<Integer>> ent : map.entrySet()) {
ArrayList<Integer> arr = ent.getValue();

System.out.println(ent.getKey() + " : " + arr.size() + " | "
+ arr.toString());
}
}

}