统计各方面指标的java代码

于 2018-04-01 23:20:27 发布
阅读量1.1k 收藏 7
点赞数 17
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/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());
}
}


}


wesupercsdn
关注
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值