统计键值相同的key(python java)

python

代码

reversed_dict_per_length = {}
vv=[]
vals=list(mapping.values())
for i in range(0,len(vals)):
    rvs={}
    v=vals[i]
    if v in vv:   #已统计
       continue                    
    
    #遍历相同值的key
    kk=[]
    for (k1,v1) in mapping.items():        
       if(v1==v):
           kk.append(k1) 
    #字典记录 值及 对应的键列表
    rvs[v]=kk
    
    cnt=vals.count(v)  #相同值的数量
    if cnt not in reversed_dict_per_length:
        reversed_dict_per_length[cnt]=rvs
    else:
        tmp=reversed_dict_per_length[cnt]      
        tmp.update(rvs)  #更新rvs到tmp
        reversed_dict_per_length[cnt]=tmp     
    vv.append(v)   
# {数量：{   值1：    【key1】 ，值2：【Key2】   }


print('\nThe (triply ordered) reversed dictionary per lengths is: ')
pprint(reversed_dict_per_length)

 

运行结果

java

代码

import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;

public class tess {
	public static void main(String[] args) {
	
//20 11		2: 4, 3: 9, 4: 4, 5: 8, 6: 2, 7: 5, 8: 11, 9: 1, 10: 10, 11: 5
		Map<Integer, Integer> map = new HashMap<Integer, Integer>();
		map.put(2, 4);
		map.put(3, 9);
		map.put(4, 4);
		map.put(5, 8);
		map.put(6, 2);
		map.put(7, 5);
		map.put(8, 11);
		map.put(9, 1);
		map.put(10, 10);
		map.put(11, 5);
		

		//#遍历值相同的键: 键的数量：    值：【键1,键2...】
		Map<Integer, Object> reversed_dict_per_length = new HashMap<Integer, Object>();
		Set<Integer>  vv=new HashSet<>();
		Collection<Integer> vals=map.values();
		for (int v : vals) {
			Map<Integer, Object> rvs = new HashMap<Integer, Object>();
            if (vv.contains(v)) {
				continue;
			}
//            遍历相同值的key
            int cnt=0;
            Set<Integer>  kk=new HashSet<>();
            for(Integer k1:map.keySet()) {
            	if(map.get(k1)==v) {
            		kk.add(k1);
            		cnt++;
            	}
            }
            rvs.put(v, kk);
            if (reversed_dict_per_length.get(cnt)==null) {
				reversed_dict_per_length.put(cnt, rvs);
			} else {
				Map<Integer, Object>	  tmp= 	(Map<Integer, Object>) reversed_dict_per_length.get(cnt);
		        tmp.put(v, kk);
		        reversed_dict_per_length.put(cnt, tmp);
		        
			}           
			vv.add(v);
		}
		
		System.out.println("The (triply ordered) reversed dictionary per lengths is: ");
		System.out.println("显示1"+reversed_dict_per_length);
		int s=0;
		System.out.print("显示2{");
		for (Integer cnt : reversed_dict_per_length.keySet()) {
			System.out.print(s==0?(cnt+":"):(","+cnt+":") ); 			
			Map<Integer, Object>	  tmp= 	(Map<Integer, Object>) reversed_dict_per_length.get(cnt);
			int s2=0;
			System.out.print("{");
			for(int v:tmp.keySet()) {
				System.out.print(s2==0?(v+":"+tmp.get(v)):(","+v+":"+tmp.get(v)) ); 				
				s2++;
	        }
	        System.out.print("}");
	        s++;
		}
		System.out.print("}");
//		{1: {1: [9], 2: [6], 8: [5], 9: [3], 10: [10], 11: [8]},2: {4: [2, 4], 5: [7, 11]}}
	}
}

 

运行结果