精华内容
下载资源
问答
  • map集合根据value排序

    2019-06-27 10:23:58
    map集合根据value从大到小排序 `` vgsdz // map集合根据value从大到小排序 public static List sortMapByValue(Map<String, Integer> map) { int size = map.size(); //通过map.entrySet()将map转换为"1.B.1....

    1. 封装排序方法

    	//map集合根据value从大到小排序
    	public static List<String> sortMapByValue(Map<String, Integer> map) {
            int size = map.size();
            //通过map.entrySet()将map转换为"1.B.1.e=78"形式的list集合
            List<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(size);
            list.addAll(map.entrySet());
            List<String> keys = list.stream()
                    .sorted(Comparator.comparing(Map.Entry<String, Integer>::getValue).reversed())
                    .map(Map.Entry<String, Integer>::getKey)
                    .collect(Collectors.toList());
            return keys;
        }
    

    2. 调用方法实现排序

    	/**
    	 * 获取最大或最小投票数map
    	 * @param map
    	 * @return
    	 */
    	public List<GVotingMinAndMax> getMaxAndMinMap(GVotingInfo gVotingInfo) {
    		Map<String, Integer> votingMap = new HashMap<String,Integer>();
    		votingMap.put("总裁办", gVotingInfo.getCeoOffice());
    		votingMap.put("营销中心", gVotingInfo.getMarkCenter());
    		votingMap.put("产品与资源管理中心", gVotingInfo.getProductResource());
    		votingMap.put("操作中心", gVotingInfo.getOperatingCenter());
    		votingMap.put("财务中心", gVotingInfo.getFinanceCenter());
    		votingMap.put("人力行政中心", gVotingInfo.getHrCenter());
    		votingMap.put("组织发展部", gVotingInfo.getOrgaDevelopment());
    		votingMap.put("法务部", gVotingInfo.getLegalDepartmen());
    		votingMap.put("数据与信息中心", gVotingInfo.getItCenter());
    		votingMap.put("投资管理部", gVotingInfo.getInvestManageDepa());
    		votingMap.put("签证中心", gVotingInfo.getVisaCenter());
    		votingMap.put("服务质量管理部", gVotingInfo.getQualityServiceDepa());
    		votingMap.put("结算中心", gVotingInfo.getSettlementCenter());
    		votingMap.put("美惠", gVotingInfo.getMhome());
    		List<String> keys = sortMapByValue(votingMap);
    		String key1 = keys.get(0);
    		String key2 = keys.get(13);
    		Integer value1 = (Integer) votingMap.get(key1);
    		Integer value2 = (Integer) votingMap.get(key2);	
    		/*Map<Integer, String> newMap = new LinkedHashMap<Integer, String>();//LinkedHashMap有序存储已排好序的键值对
    		newMap.put(value1,key1);
    		newMap.put(value2,key2);*/
    		List<GVotingMinAndMax> list = new ArrayList<>();
    		GVotingMinAndMax gVotingMinAndMax = new GVotingMinAndMax();
    		gVotingMinAndMax.setMaxVot(key1);
    		gVotingMinAndMax.setMaxScore(value1);
    		gVotingMinAndMax.setMinVot(key2);
    		gVotingMinAndMax.setMinScore(value2);
    		list.add(gVotingMinAndMax);
    		/*for(GVotingMinAndMax model:list) {
    			System.out.println("-----------------------"+model.toString());
    		}*/
    		return list;
    	}
    
    展开全文
  • 实现思路:将Map key,value模式转换为List key=value模式,然后利用冒泡排序进行排序 Map<Long, Double> historyBuy = new HashMap<Long, Double>(); // 获得map集合 List<Map.Entry<Long,...

    实现思路:将Map key,value模式转换为List key=value模式,然后利用冒泡排序进行排序

            Map<Long, Double> historyBuy = new HashMap<Long, Double>();
            // 获得map集合
    		List<Map.Entry<Long, Double>> list = new ArrayList<Map.Entry<Long, Double>>(historyBuy.size());
            list.addAll(historyBuy.entrySet());
            int j = list.size();
            // 冒泡排序
            for(int i = 0; i < j - 1; i++) {
            	for(int k = 0; k < j - i - 1; k++) {
            		Entry<Long, Double> e1 = list.get(k);
            		Entry<Long, Double> e2 = list.get(k + 1);
            		double d1 = e1.getValue();
            		double d2 = e2.getValue();
            		if(d1 < d2) { // 升序此处为> 降序此处为<
            			Collections.swap(list, k, k + 1); // 交换集合中下标为i 和 k 的数据
            		}
            	}
            }

    使用的Entry为:import java.util.Map.Entry;

    实际效果:

    排序前:[38291=4.0, 38290=1.0, 38289=3.0, 38832=1.0, 38294=507.0, 38293=26.0, 38292=32.0, 38829=1.0, 38830=6.0, 38831=6.0, 38824=2.0, 38287=16.0, 38825=10.0, 38826=9.0]
    排序后:[38294=507.0, 38292=32.0, 38293=26.0, 38287=16.0, 38825=10.0, 38826=9.0, 38830=6.0, 38831=6.0, 38291=4.0, 38289=3.0, 38824=2.0, 38290=1.0, 38832=1.0, 38829=1.0]

    等号左边为原来Map的key,等号右边为原来Map的value,排序方式为降序排序

     

    展开全文
  • Map集合按照Value排序(Map value sort)

    千次阅读 2013-01-03 15:01:49
    public static void main(String[] args) { ... Map map = new HashMap(); map.put("001", 2); map.put("002", 6); map.put("003", 9); map.put("004", 1); map.put("005", 9); List> orderList = n
    public static void main(String[] args) {
    		
    		Map<String,Integer> map = new HashMap<String,Integer>();
    		map.put("001", 2);
    		map.put("002", 6);
    		map.put("003", 9);
    		map.put("004", 1);
    		map.put("005", 9);
    		
    		List<Map.Entry<String, Integer>> orderList = new ArrayList<Map.Entry<String, Integer>>(map.entrySet());  
    		Collections.sort(orderList, new Comparator<Map.Entry<String, Integer>>() {   
                public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {   
                    // 降序:o2.getValue()-o1.getValue() 
                	// 升序:o1.getValue()-o2.getValue()
                	return (o2.getValue()-o1.getValue());   
                }   
            });
    		
    		for(Map.Entry<String, Integer> m : orderList){
    			System.out.println(m);
    		}
    	}


    展开全文
  • 根据map集合value进行排序

    千次阅读 2018-05-03 17:12:44
    1.map集合类型 Map //自定义比较器 Comparator&lt;Map.Entry&lt;String, Double&gt;&gt; valueComparator = new Comparator&lt;Map.Entry&lt;String, Double&gt;&gt;() { @...

    本项目用到排序

    1.map集合类型 Map

    //自定义比较器
                Comparator<Map.Entry<String, Double>> valueComparator = new Comparator<Map.Entry<String, Double>>() {
                    @Override
                    public int compare(Entry<String, Double> o1, Entry<String, Double> o2) {
                        return o1.getValue().compareTo(o2.getValue());
                    }
                };
                // map转换成list进行排序
                List<Map.Entry<String, Double>> list = new ArrayList<Map.Entry<String, Double>>(avgMap.entrySet());
                // 排序
                Collections.sort(list, valueComparator);

    自定义demo

        @Test
        public void demo2() {
            Map<String, Double> map = new TreeMap<String, Double>();
            map.put("acb1", 5.1);
            map.put("bac1", 3.1);
            map.put("bca1", 2.9);
            map.put("cab1", 80.1);
            map.put("cba1", 1.1);
            map.put("abc1", 10.1);
            map.put("abc2", 12.1);
            Comparator<Map.Entry<String, Double>> valueComparator = new Comparator<Map.Entry<String, Double>>() {
                @Override
                public int compare(Entry<String, Double> o1, Entry<String, Double> o2) {
                    return o1.getValue().compareTo(o2.getValue());
                }
            };
            // map转换成list进行排序
            List<Map.Entry<String, Double>> list = new ArrayList<Map.Entry<String, Double>>(map.entrySet());
            // 排序
            Collections.sort(list, valueComparator);
        }

    输出结果:
    [cba1=1.1, bca1=2.9, bac1=3.1, acb1=5.1, abc1=10.1, abc2=12.1, cab1=80.1]
    获取对应的key, 即cba1,bca1 等等

    list.get(i).getKey

    2.对list中的类的某个属性的值进行排序

    需求:根据timeProportion的大小进行排序

    public class InterestStudentLocation implements Comparable<InterestStudentLocation>, Serializable {
        private static final long serialVersionUID = -5411406470341636658L;
    
        /**
         * 时间占比
         */
        private Double timeProportion;
    
            public Double getTimeProportion() {
            return timeProportion;
        }
    
        public void setTimeProportion(Double timeProportion) {
            this.timeProportion = timeProportion;
        }
    
        @Override
        public int compareTo(InterestStudentLocation o) {
            Double id1 = timeProportion;
            Double id2 = o.getTimeProportion();
            return id1 > id2 ? 1 : id1 == id2 ? 0 : -1;
        }
    
    }
    
    //调用方法查询出list
    List<InterestStudentLocation> list = interestStudentLocationDao.getClassLocationAndTime(t);
    
    //对list进行排序
    Collections.sort(list);
    list就根据timeProportion的大小进行排序了
    展开全文
  • Map集合根据key或者value排序

    千次阅读 2018-10-31 14:18:28
    前几天开发项目,需要用到这一个小的技巧点,原以为,自己put进去的会根据自己put时顺序自己拍好的,没想到,Map集合会变乱的。。 //hashmap降順ソート private static List&lt;Map.Entry&lt;String, ...
  • java8 Stream Map集合value排序

    千次阅读 2019-12-09 13:25:32
    java8 Stream Map排序 map.entrySet().stream() .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
  • Map集合排序——根据value对key进行排序 在流水的业务中,码出最优雅的代码。 描述:有若干个键值对格式的json字符串,根据其中的value排序,取出其中的排位靠前的一半以上的key值,json数据为:{“1.B.1.f”...
  • // HashMap是由数组和链表组成的链表散列结构,根据key的hash值来决定存储的位置,这就导致了存储后的元素不会维持插入时的顺序,因此放数据的前后顺序不重要 Map<String,Integer> map = new HashMap<...
  • Map集合根据key排序

    千次阅读 2017-06-14 20:55:36
    public static void main(String[] args) { Map map = new TreeMap(); map.put("d", "ddddd"); map.put("c", "ccccc"); List> list = new ArrayList>(map.entrySet()); Co
  • java8 stream map根据value排序

    万次阅读 2017-09-21 16:34:30
    java8 stream map根据value排序
  • Java map根据key排序,根据value排序

    千次阅读 2018-09-17 13:34:05
    /**  * 按key排序(sort by ... * @param oriMap 要排序map集合  * @param isAsc(true:升序,false:降序)  * @return  */  private Map&lt;String, Long&gt; sortMapByKey(Map&lt;String, L...
  • 1 public static void main(String[] args) { 2 Map<String, Integer> map = new HashMap<String, Integer>(); 3 map.put("os5", 10); 4 map.put("os4", 13); 5 ...
  • 下面小编就为大家带来一篇java的Map集合中按value值进行排序输出的实例代码。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  •  Map內涵资料是Key -> Value的架构集合体,而Key是属于Set的架构集合体,也就是说Key的值是唯一的,而Value的值可以重复。  一般常用的子类是HashMap或TreeMap,  如果考虑效能的话,建议使用HashMap,
  • Map<String, String> collect = noWhiteListMap.entrySet().stream() .sorted(Comparator.comparing(entry -> entry.getValue().split(",").length,Comparator.reverseOrder())) ...
  • Java Map集合利用比较器Comparator根据Key和Value排序
  • Map根据 key 排序需要用到 TreeMap 对象,因为它是默认按照升序进行输出的,可以使用比较器 compareTo 对它进行降序排序,Comparator 可以对集合对象或者数组进行排序的比较器接口,实现该接口的 public compare...
  • (PS:其实当我们在工作中,有时候会用到这种排序,所以我在这里会稍微介绍一下这种排序,主要运用到了集合类。) 为什么我们需要做排序排序对于我们来说是一件非常基础的事情,排序算法有很多,但是在实际过程中...
  • java8新特性:对map集合排序根据key或者value操作排序(升序、降序) 直接上代码: package com.drew.test; import java.util.List; import java.util.Map; import com.google.common.collect.ImmutableMap...
  • 根据value排序 List&lt;String&gt; items = Arrays.asList("apple", "apple", "banana", "apple", "orange", "banana", "papaya&...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 126,540
精华内容 50,616
关键字:

map集合根据value排序