精华内容
下载资源
问答
  • treeMap值排序

    2021-01-30 10:41:51
    1、默认按key排序 //treeMap private static void test01(){ TreeMap<String, Object> treeMap = new TreeMap<String, Object>(); treeMap.put("zs", 15); treeMap.put("ls",18); treeMap.put("ww...

    1、默认按key排序

    //treeMap
    private static void test01(){
        TreeMap<String, Object> treeMap = new TreeMap<String, Object>();
        treeMap.put("zs", 15);
        treeMap.put("ls",18);
        treeMap.put("ww", 22);
        String key = treeMap.firstEntry().getKey();
        String key2 = treeMap.lastEntry().getKey();
        System.out.println(key);
        System.out.println(key2);
    }

    2、treeMap按值排序

    private static void test02(){
        TreeMap<String, Integer> treeMap = new TreeMap<String, Integer>();
        treeMap.put("zs", 18);
        treeMap.put("ls",25);
        treeMap.put("ww", 22);
        
        Set<Entry<String,Integer>> entrySet = treeMap.entrySet();
        List<Entry<String,Integer>> list = new ArrayList<Entry<String,Integer>>(entrySet);
        Collections.sort(list, new Comparator<Entry<String, Integer>>() {
            public int compare(Entry<String, Integer> entry1, Entry<String, Integer> entry2) {
                return entry1.getValue().compareTo(entry2.getValue());
            }
        });
        
        for(Entry<String, Integer> entry : list) {
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
    }

     

    往期精彩内容:

    Java知识体系总结(2021版)

    超详细的springBoot学习笔记

    Java多线程基础知识总结(绝对经典)

    Java面试题总结(附答案)

    Vue基础知识总结(绝对经典)

    常见数据结构与算法整理总结

    展开全文
  • package demo1;import java.util.Comparator;import java.util.HashMap;...import java.util.TreeMap;public class Testing {public static void main(String[] args) {HashMap map = new HashMap...

    package demo1;

    import java.util.Comparator;

    import java.util.HashMap;

    import java.util.Map;

    import java.util.TreeMap;

    public class Testing {

    public static void main(String[] args) {

    HashMap map = new HashMap<>();

    ValueComparator vc = new ValueComparator(map);

    TreeMap sorted_map = new TreeMap<>(vc);

    map.put("A", 432.3);

    map.put("B", 44.3);

    map.put("C", 46.3);

    map.put("D", 43.3);

    sorted_map.putAll(map);

    System.out.println(map);

    System.out.println(sorted_map);

    }

    }

    class ValueComparator implements Comparator{

    private Map base;

    public ValueComparator(Map base) {

    this.base = base;

    }

    @Override

    public int compare(String a, String b) {

    if (base.get(a) >= base.get(b)) {

    return 1;

    }

    return -1;

    }

    }

    展开全文
  • 使用TreeMap值排序

    千次阅读 2017-03-18 11:31:17
    如果我们需要一个有序的Map,我们会使用TreeMap...TreeMap默认是按照key升序进行排序的,如数字、ASCII。 如果我们需要对TreeMap进行排序的话,可以实例化Comparator接口,在TreeMap的构造方法中当作参数传入。

    如果我们需要一个有序的Map,我们会使用TreeMap进行存储。TreeMap默认是按照key值升序进行排序的,如数字、ASCII。
    如果我们需要对TreeMap按值进行排序的话,可以实例化Comparator接口,在TreeMap的构造方法中当作参数传入。这里遇到了问题:当插入TreeMap的两条数据value值一样的时候,后一条数据会覆盖前一条数据。
    通过查资料发现,原因是实例化Comparator接口的时候,相当于自己实现了一个比较器,而TreeMap的插入与取出都是会经过比较器的。以如下代码为例:
    1. public class ValueComparator implements Comparator<Object>{  
    2.   
    3.     Map<Object, Object> base;  
    4.       
    5.     public ValueComparator(Map<Object, Object> map){  
    6.         this.base = map;  
    7.     }  
    8.       
    9.     @Override  
    10.     public int compare(Object o1, Object o2) {  
    11.         Integer value1 = Integer.parseInt(base.get(o1.toString()).toString());  
    12.         Integer value2 = Integer.parseInt(base.get(o2.toString()).toString());  
    13.         if ((value2 - value1) > 0) {  
    14.             return 1;  
    15.         }else if (value2 - value1 ==0) {  
    16.             return o2.toString().compareTo(o1.toString());  
    17.         }else {  
    18.             return -1;  
    19.         }  
    20.     }  
    21. }  
    public class ValueComparator implements Comparator<Object>{
    
    	Map<Object, Object> base;
    	
    	public ValueComparator(Map<Object, Object> map){
    		this.base = map;
    	}
    	
    	@Override
    	public int compare(Object o1, Object o2) {
    		Integer value1 = Integer.parseInt(base.get(o1.toString()).toString());
    		Integer value2 = Integer.parseInt(base.get(o2.toString()).toString());
    		if ((value2 - value1) > 0) {
    			return 1;
    		}else if (value2 - value1 ==0) {
    			return o2.toString().compareTo(o1.toString());
    		}else {
    			return -1;
    		}
    	}
    }



    base就是我们需要按值排序的Map,在ValueComparator的构造方法中传入。然后在下面的compare方法中,value1与value2就是根据o1和o2取到的value值,其中o1与o2都是Map的key值。当o1与o2的value值不一样的时候,会返回1与-1,代表着排序关系。而当他们的value值一样的时候,需要对o1和o2的进行排序关系的判断。当取出数据的时候,过程是一样的,需要根据get方法中的参数对TreeMap中的数据对TreeMap进行遍历判断,如果相等则返回0,并且get方法会返回相等的那个对象,如果不等,就搜索下一节点并进行判断,知道遍历完整个TreeMap。
    这里就很明显了,如果两个key值一样的对象插入到TreeMap中时,由于插入的时候进行判断返回的结果为0,后一个插入的对象会覆盖在TreeMap中存储的对象。

    以上转自:http://blog.csdn.net/u012434091/article/details/38276807

    自己项目中用的treemap:

    //treeMap排序代码
    
    public AppCacheDataManager() {
    
    metaMap = new TreeMap<String,AppMetaData>(newMyComparator());
    
    appList = new Vector<String>();
    
    this.comm= HistoryClient.build();
    
    userInfoMap = new HashMap<String,AmUserInfo>();
    
    }
    
    public static class MyComparator implementsComparator {
    public int compare(Objecto1, Object o2) {
    
    String s1 = (String) o1;
    
    String s2 = (String) o2;
    
    String str1 = s1.replace('_','-');
    
    String str2 = s2.replace('_','-');
    
    return str2.compareTo(str1);
    // app_user_20161111152008_1928 与app-user-20161111152008-1930去掉前面"app_user_9"个字符, // 和后面"_1928"5个或6个字符之后再比较。前面方法不好使,所以直接把_转为-再排序
    }
    }
    

    
    
    
    
    
    
    
    
    展开全文
  • import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.LinkedHashMap;...import java.util.TreeMap; import ...

     

    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.HashMap;
    import java.util.LinkedHashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.Map.Entry;
    import java.util.TreeMap;
    import java.util.stream.Collectors;
    
    /**
    * @desc: tompai-common
    * @name: MapSortTest.java
    * @author: tompai
    * @email:liinux@qq.com
    * @createTime: 2021年4月12日 下午9:23:03
    * @history:
    * @version: v1.0
    */
    
    public class MapSortTest {
    
    	/**
    	* @author: tompai
    	* @createTime: 2021年4月12日 下午9:23:04
    	* @history:
    	* @param args void
    	*/
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		// treeMapReverseOrder();
    		// treeMapSortByValue();
    		 treeMapSortByValue()
    	}
    
    	public static void treeMapReverseOrder() {
    		// 默认的TreeMap升序排列
    		TreeMap<Integer, Integer> map1 = new TreeMap<Integer, Integer>();
    		map1.put(1, 2);
    		map1.put(2, 4);
    		map1.put(7, 1);
    		map1.put(5, 2);
    		System.out.println("map1=" + map1);
    
    		// TreeMap降序排列
    		Map<Integer, Integer> map2 = new TreeMap<>((o1, o2) -> o2.compareTo(o1));
    		map2.put(1, 2);
    		map2.put(2, 4);
    		map2.put(7, 1);
    		map2.put(5, 2);
    		System.out.println("Map2=" + map2);
    	}
    
    	public static void treeMapSortByValue() {
    		Map<String, String> map = new TreeMap<String, String>();
    		map.put("a", "dddd");
    		map.put("d", "aaaa");
    		map.put("b", "cccc");
    		map.put("c", "bbbb");
    
    		List<Entry<String, String>> list = new ArrayList<Entry<String, String>>(map.entrySet());
    		Collections.sort(list, new Comparator<Map.Entry<String, String>>() {
    			// 升序排序
    			public int compare(Entry<String, String> o1, Entry<String, String> o2) {
    				return o1.getValue().compareTo(o2.getValue());
    			}
    		});
    
    		for (Entry<String, String> e : list) {
    			System.out.println(e.getKey() + ":" + e.getValue());
    		}
    	}
    
    	public static void mapSortByKey1() {
    		Map<String, String> result = new HashMap<>();
    		result.put("1", "aaa");
    		result.put("7", "bbb");
    		result.put("22", "ccc");
    		Map<String, String> finalMap = new LinkedHashMap<>();
    		// Sort a map and add to finalMap
    		result.entrySet().stream().sorted(Map.Entry.<String, String>comparingByKey().reversed())
    				.forEachOrdered(e -> finalMap.put(e.getKey(), e.getValue()));
    		System.out.println(finalMap);
    	}
    
    	public static void mapSortByKey2() {
    		Map<String, Integer> codes = new HashMap<>();
    		codes.put("United", 1);
    		codes.put("Germany", 49);
    		codes.put("France", 33);
    		codes.put("China", 86);
    		codes.put("Pakistan", 92);
    
    		// 按照Map的键进行排序
    		Map<String, Integer> sortedMap = codes
    				.entrySet()
    				.stream()
    				.sorted(Map.Entry.comparingByKey())
    				.collect(Collectors
    				.toMap(
    					Map.Entry::getKey, 
    					Map.Entry::getValue, 
    					(oldVal, newVal) -> oldVal, 
    					LinkedHashMap::new));
    
    		// 将排序后的Map打印
    		sortedMap.entrySet().forEach(System.out::println);
    	}
    
    	public static void mapSortByValue1() {
    		Map<String, String> result = new HashMap<>();
    		result.put("13", "aaa");
    		result.put("37", "bbb");
    		result.put("22", "ccc");
    		Map<String, String> finalMap = new LinkedHashMap<>();
    		// Sort a map and add to finalMap
    		result.entrySet().stream().sorted(Map.Entry.<String, String>comparingByValue().reversed())
    				.forEachOrdered(e -> finalMap.put(e.getKey(), e.getValue()));
    
    		System.out.println(finalMap);
    	}
    
    	public static void mapSortByValue2() {
    		Map<String, String> codes = new HashMap<>();
    		codes.put("13", "aaa");
    		codes.put("37", "fff");
    		codes.put("22", "bbb");
    		// Sort a map and add to finalMap
    		Map<String, String> sortedMap = codes
    				.entrySet()
    				.stream()
    				.sorted(Map.Entry.comparingByValue())
    				.collect(Collectors
    				.toMap(
    					Map.Entry::getKey, 
    					Map.Entry::getValue, 
    					(oldVal, newVal) -> oldVal,LinkedHashMap::new));
    
    		sortedMap.entrySet().forEach(System.out::println);
    	}
    
    	public static void mapMerge1() {
    		String k = "key";
    		HashMap<String, Integer> map = new HashMap<String, Integer>() {
    			{
    				put(k, 1);
    			}
    		};
    		map.merge(k, 2, (oldVal, newVal) -> oldVal + newVal);
    
    		map.entrySet().forEach(System.out::println);
    	}
    
    	public static void mapMerge2() {
    		// 创建一个HashMap
    		HashMap<String, Integer> prices = new HashMap<>();
    		// 往 HashMap 插入映射
    		prices.put("Shoes", 200);
    		prices.put("Bag", 300);
    		prices.put("Pant", 150);
    		prices.put("Shirt", 10);
    		System.out.println("HashMap: " + prices);
    		int returnedValue = prices.merge("Shirt", 100, (oldValue, newValue) -> oldValue + newValue);
    		System.out.println("Price of Shirt: " + returnedValue);
    		// 输出更新后的 HashMap
    		System.out.println("Updated HashMap: " + prices);
    	}
    
    	public static void mapMerge3() {
    		// 创建一个 HashMap
    		HashMap<String, String> countries = new HashMap<>();
    		// 往HashMap插入映射项
    		countries.put("Washington", "America");
    		countries.put("Canberra", "Australia");
    		countries.put("Madrid", "Spain");
    		System.out.println("HashMap: " + countries);
    		// 合并 key为 Washington的映射
    		String returnedValue = countries.merge("Washington", "USA", (oldValue, newValue) -> oldValue + "/" + newValue);
    		System.out.println("Washington: " + returnedValue);
    		// 输出更新后的HashMap
    		System.out.println("Updated HashMap: " + countries);
    	}
    }
    

     

    展开全文
  • 使用TreeMap值排序遇到的问题

    千次阅读 2014-07-29 19:56:17
    TreeMap默认是按照key升序进行排序的,如数字、ASCII。  如果我们需要对TreeMap进行排序的话,可以实例化Comparator接口,在TreeMap的构造方法中当作参数传入。这里遇到了问题:当插入TreeMap的两条数据...
  • TreeMap 按照value值排序

    2020-08-07 17:17:07
    按照value里gmn_no进行排序如果相等按照di_no排序 TreeMap<Integer, Map> zeroTreeMap = new TreeMap<Integer, Map>(zeroList); zeroTreeMap 里为 { 1={gmn_no=1,di_no=3,scr_no=3} 2={gmn_no=3,di...
  • 1. 定义TreeMap排序方法使用Comparator对象作为参数需要注意的是:排序方法是针对键的,而不是的。如果想针对,需要更麻烦的一些方法(重写一些方法)TreeMap res = new TreeMap(new Comparator() {@...
  • Map sortedHashMap = new TreeMap(new Comparator(){ public int compare(String o1, String o2) { ... //指定排序器按照降序排列(o1, o2指的是Map的Key) char char1 = o1.charAt(0); char char2 = o
  • TreeSet和TreeMap排序

    2018-04-06 13:44:03
    2.TreeMap要求对建值排序 对于TreeSe和TreeMap都是在添加数据时进行排序的。所以要对其设置比较器,例如: package treeset; import java.util.Comparator; import java.util.TreeSet; public class ...
  • 1.TreeMap是有序集合,默认按照key的compareTo来排序。 2.重写comparator,按照比较。 3.利用guava中Ordering.onResultOf方法 代码实现: import com.google.common.base.Functions; import ...
  • TreeMap按照Value值排序

    千次阅读 2019-07-29 16:17:10
    Map<... selectedMap=new TreeMap<GUID, Integer>(); List<Entry<GUID, Integer>> list = new ArrayList<Entry<GUID, Integer>>(selectedMap.entrySet()); Co...
  • 我正在尝试在HashMap中放置一些键值,然后尝试使用TreeMap进行排序,如下所示.问题是如果地图中有类似的,那么在排序后它会考虑其中任何一个.import java.util.*;public class HashmapExample {public static void ...
  • 遍历丶排序TreeMap

    2018-09-16 12:17:41
    今天给大家说说怎么把TreeMap进行排序,TreeMap 默认排序规则:按照key的字典顺序来排序(升序) 而HashMap在放入的时候已经内部规定好排序了,TreeMap可以可以自定义排序,废话不多说,上代码! 首先,这里创建了一...
  • TreeMap 排序

    2019-05-25 23:43:00
    1:key是基本数据类型 在声明treeMap时创建匿名内部类(Comparator)并实现比较器方法(compare())。 package Conllection; import java.util.Comparator;... * TreeMap排序 * * @author ...
  • TreeMap用法 排序 示例

    2009-05-23 10:27:41
    TreeMap类通过使用树来实现Map接口.TreeMap提供了按排序顺序存储关键字/对的有效手段,同时允许快速检索。不像散列映射,树映射保证它的元素按照关键字升序排序。 [code="java"]import java....
  • TreeMap默认按键的自然顺序升序进行排序,如果有需求要按键的倒序排序,或者按类型进行排序呢?    在问题开始之前,让我们先回顾一下有关Map及其排序基本的知识点用的最多的HashMap,不保证映射的顺序,特别...
  • //将key较大数据进行排序 Map, Integer> map3 = new TreeMap, Integer>(new MapValueComparator(gcdw)); map3.putAll(gcdw); //取排序前十 int i=0; for (String key : map3.keySet()) { i...
  • 之前写过一篇TreeMap自定义排序的博客,不过那个是根据key的排序,如果想要根据value的值排序可以这样写: HashMap map = new HashMap(); map.put("aaa", 3); map.put("bbb", 2); map.put("ccc", 5); map.put("ddd...
  • 在最近写的一个工程里用到了TreeMap这个数据结构,TreeMap是SortedMap接口基于红黑树的实现,该类保证了映射按照升序排列关键字,根据使用的构造方法不同,可能会按照键的类的自然顺序进行排序,或者按照创建时所...
  • HashMap: 最常用的Map,它根据键的HashCode 存储数据,根据键可以直接获取它的,具有很快的访问速度。HashMap最多只允许一条记录的键为Null(多条会覆盖);允许多条记录的为 Null。非 首先简单说一下...
  • TreeSet 和 TreeMap 排序

    2020-09-13 21:25:09
    TreeSet 和 TreeMap 默认排序均为按照字典顺序升序排序TreeMap排序依据为key 以下为TreeSet 和 TreeMap 自定义倒序排序样例: new TreeSet<Integer>(new Comparator<Integer>() { @Override ...
  • 做了几年java现在才知道有TreeMap Comparator 可以很好根据map中的value对map进行排序
  • 选择某种Map集合保存学号从1到15的学员的学号(键)和姓名(),学号用字符串表示,输入的时候要以学号乱序的方式存入Map集合,然后按照学号从大到小的顺序将Map集合中的元素输出打印。需要自定义Map集合的比较器...
  • TreeMap使用红黑树实现,保留有key值顺序性,会自动按照key值排序。 默认是按照key值的升序排序,key值必须实现 Comparator接口。如果希望按找一定规则排序,则需要重新定义compare函数。 如: ...
  • 首先TreeSet底层构造器实际是TreeMap(有key.value为null);...自然排序(按元素大小)需该对象所属类实现comparable<T>接口,定制排序自定义比较器实现comparator<T>接口。 TreeSet/...
  • 生成的map放时是无序的,遍历后打印的结果可以得出一下结论: 1,HashMap key是整型时会默认排序,而且是升序; key不是整型时,默认不排序,并且遍历取值时是随机的顺序,不是原先放入的顺序。 2,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,008
精华内容 403
关键字:

treemap值排序