二维map找出值中值得最大值，借助二维数组

最新推荐文章于 2024-01-25 17:43:54 发布

修炼到救赎

最新推荐文章于 2024-01-25 17:43:54 发布

阅读量856

点赞数

分类专栏： Java 文章标签：二层map嵌套取里层

本文链接：https://blog.csdn.net/rentian1/article/details/52644660

版权

Java 专栏收录该内容

364 篇文章 2 订阅

订阅专栏

笔记本，以后好回顾
public static void main(String[] args) {
        //封装数据
        try {
            InteratorManyMap(testTwoCengMap());
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
    //拼接数据源
    public static LinkedHashMap<String, Map<String, Integer>> testTwoCengMap(){
        LinkedHashMap<String, Map<String, Integer>> result = new LinkedHashMap<String, Map<String,Integer>>();
        Map <String,Integer> map =new HashMap<String,Integer>();
                            map.put("20160901", 250);
                            map.put("20160902", 230);
                            map.put("20160904", 202);
                            map.put("20160903", 245);
                            map.put("20160906", 280);
                            map.put("20160905", 209);
                            map.put("20160907", 240);
                            map.put("20160908", 290);
                            map.put("20160909", 250);
                            map.put("20160911", 247);
                            map.put("20160910", 258);
                            map.put("20160912", 247);
                            map.put("20160913", 258);
                        result.put("weixin", map);
                            map =new HashMap<String,Integer>();
                                    map.put("20160901", 210);
                                    map.put("20160902", 250);
                                    map.put("20160904", 212);
                                    map.put("20160903", 285);
                                    map.put("20160905", 276);
                                    map.put("20160906", 258);
                                    map.put("20160907", 212);
                                    map.put("20160908", 258);
                                    map.put("20160909", 270);
                                    map.put("20160911", 207);
                                    map.put("20160910", 298);
                                    map.put("20160912", 257);
                                    map.put("20160913", 289);
                        result.put("qqQuze", map);
                            map =new HashMap<String,Integer>();
                                    map.put("20160901", 280);
                                    map.put("20160902", 260);
                                    map.put("20160904", 242);
                                    map.put("20160903", 275);
                                    map.put("20160905", 286);
                                    map.put("20160906", 238);
                                    map.put("20160907", 202);
                                    map.put("20160908", 158);
                                    map.put("20160909", 870);
                                    map.put("20160911", 297);
                                    map.put("20160910", 220);
                                    map.put("20160912", 357);
                                    map.put("20160913", 290);
                        result.put("weibo", map);
            return result;
    }
    //二维多个map遍历找最大值
    public static void InteratorManyMap(LinkedHashMap<String, Map<String, Integer>> linkedmap){
        Map<String,Integer> first = new HashMap<String,Integer>();
        List<String> dateList = new ArrayList<String>();
                    Set<String> outerkeys =linkedmap.keySet();
                    Object[] ke=outerkeys.toArray();
                    String key1=ke[0].toString();
                    first = linkedmap.get(key1);
                    first = treeMapSort(first);
        for(Map.Entry<String, Integer> entry:first.entrySet()){
                    dateList.add(entry.getKey());
        }
        List<Integer>comp =new ArrayList<Integer>();//比较暂时用的容器
        List<Integer>aftermax =new ArrayList<Integer>();//存储最大值容器，
        int[][] num;             //定义一个float类型的2维数组
        num= new int[ke.length][dateList.size()]; 
        int[][] num2;             //定义一个float类型的2维数组
        num2= new int[dateList.size()][ke.length];   
         int i,j;
         int amax=0;
         int temp=0;//当前内map的值
        for( i=0;i<ke.length;i++){
            for( j=0;j<dateList.size();j++){
                temp=Integer.parseInt(linkedmap.get(ke[i].toString()).get(dateList.get(j)).toString());
                num[i][j]=temp;
            }
        }
        for(i=0;i<ke.length;i++)
        {
            for(j=0;j<dateList.size();j++)
            {
                num2[j][i] = num[i][j];
            }
        }
        int nu=0;
        for(i=0;i<dateList.size();i++)
        {
            for(j=0;j<ke.length;j++)
            {
                comp.add(num2[i][j]);
                nu++;
                if(nu%ke.length==0){
                    aftermax.add(manyNumMax(comp));//存储比较的最大值
                    comp.clear();
                }
            }
        }
        System.out.println(aftermax.toString());
    }
    /**
     * 多个数比大小
     */
    public static int manyNumMax(List<Integer>comp){
        int amax =0;
        for(Integer value:comp){
            if(value>amax){
                amax=value;
            }
        }
        return amax;
    }
    /**
     * 把hashmap或者linkedhashmap放进treeMap排序
     */
    public static  Map<String,Integer> treeMapSort(Map<String,Integer>map){
        TreeMap<String,Integer> map1 = new TreeMap<String,Integer>();
        for(Map.Entry<String, Integer> entry:map.entrySet()){
            map1.put(entry.getKey(), entry.getValue());
        }
        return map1;
    }