zoukankan      html  css  js  c++  java
  • Java List/HashSet/HashMap的排序

    在对Java无序类集合,如List(ArrayList/LinkedList)、HashSet(TreeSet有序)、HashMap等排序时,Java中一个公共的类Collections,提供了对Java集合排序等很好的方法sort。 但是有一个要求是sort方法的参数为<List list>  或<List list, Comparator<? super T>  c>,即排序对象要求必须是List类型。

         sort 方法的参数必须为List 的原因是,只有List可以定义排序的方法,让List中的元素改变在构建List时原始的相对位置(初始构建时,元素相对位置即为元素初始加入顺序)。HashSet、HashMap 在构建时,初始加入的元素已经按照元素的hashCode()方法的定义排好序。所以这里所说的HashSet 排序 和 HashMap 排序是指:将其中的元素导出到另一个集合中,对该载体集合排序。排序之后,原HashSet 和 HashMap 中元素顺序没有变。

        故而对Java无序类集合的排序问题,基本思路就是:将HashSet 或 HashMap 中的元素取出放入 List 中,对List 用 Collections.sort() 方法排序,之后输出排序后List中的元素,即为对Set/Map 中元素排序后的结果。注意HashSet、HashMap 中元素位置没有改变,依然只和 初始构建时,元素本身自定义的hashCode() 方法有关

    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.LinkedList;
    import java.util.Map;
    
    public class Test {
        public static void main(String[] args){
            ArrayList<String> listTest = new ArrayList<String>();
            listTest.add("bbc");
            listTest.add("abc");
            listTest.add("acb");        
            
            HashSet<String> setTest = new HashSet<String>();
            setTest.add("bbc");
            setTest.add("abc");
            setTest.add("acb");
            System.out.println("HashSet BeforeSort:");
            for(String s : setTest)
                System.out.println(s);
            
            HashMap<String, Integer> mapTest = new HashMap<String, Integer>();
            mapTest.put("bbc", 1);
            mapTest.put("abc", 2);
            mapTest.put("acb", 3);
            System.out.println("HashMap BeforeSort:");
            for(Map.Entry<String, Integer> entry : mapTest.entrySet())
                System.out.println(entry.getKey() + " " + entry.getValue());
            
            /*
             * List 
             */
            Collections.sort(listTest);
            Iterator<String> list_iter = listTest.iterator();
            while(list_iter.hasNext())
                System.out.println(list_iter.next());
            
            /*
             * Set
             */        
            LinkedList<String> setSort = new LinkedList<String>(setTest);        
            //Collections.sort(setSort);
            Comparator<String> setComp = Collections.reverseOrder();
            Collections.sort(setSort, setComp);
            /*LinkedList<String> setSort = new LinkedList<String>();
            for(String s : setTest)
                setSort.add(s);*/
            for(String s : setTest)
                System.out.println(s);
            for(String s : setSort)
                System.out.println(s);    
            
            /*
             * Map
             */        
            LinkedList<String> mapSort = new LinkedList<String>();
            mapSort.addAll(mapTest.keySet());
            //Collections.sort(mapSort);
            Comparator<String> mapComp = Collections.reverseOrder();
            Collections.sort(mapSort, mapComp);
            for(Map.Entry<String, Integer> entry : mapTest.entrySet())
                System.out.println(entry.getKey() + " " + entry.getValue());
            for(final Iterator<String> map_iter= mapSort.iterator(); map_iter.hasNext();)
                System.out.println(map_iter.next());        
    /*        
            LinkedList<Map.Entry<String, Integer>> mapEntry = new LinkedList<Map.Entry<String,Integer>>();
            mapEntry.addAll(mapTest.entrySet());
            Collections.sort(mapEntry, new Comparator<Map.Entry<String, Integer>>() {
                public int compare(Map.Entry<String, Integer> a, Map.Entry<String, Integer> b){
                    if(a.getValue() > b.getValue())
                        return -1;
                    else
                        return 1;                
                }
            });        
            
            for(Map.Entry<String, Integer> entry : mapEntry)
                System.out.println(entry.getKey() + " " +entry.getValue());
            for(Map.Entry<String, Integer> entry : mapTest.entrySet())
                System.out.println(entry.getKey() + " " + entry.getValue());*/        
        }
    }
    HashSet BeforeSort:
    abc
    acb
    bbc
    HashMap BeforeSort:
    abc 2
    acb 3
    bbc 1
    //List AfterSort
    abc
    acb
    bbc
    //HashSet AfterSort
    abc
    acb
    bbc
    //setSort AfterSort (setSort is means HashSet to LinkedList)
    bbc
    acb
    abc
    //HashMap AfterSort
    abc 2
    acb 3
    bbc 1
    //mapSort AfterSort (mapSort is means HashMap to LinkedList)
    bbc
    acb
    abc
    一、按key值排序
    假设HashMap存储的键-值对为(String,Integer),按key排序可以调用JDK函数sort(默认的按字典升序):
    Set<String> keySet = map.keySet();
     Collections.sort(keySet);
     for(Iterator<String> ite = keySet.iterator(); ite.hasNext();) {
         String temp = ite.next();
         System.out.println("key-value: "+temp+","+map.getValue(temp);
     }
    如果想要按字典的降序排列,则需改写sort方法里面的比较器Comparator:
    Collections.sort(keySet, new Comparator() {
         public int compare(Object o1, Object o2) {
            if(Integer.parseInt(o1.toString())>Integer.parseInt(o2.toString())
                 return 1;
            if(Integer.parseInt(o1.toString())==Integer.parseInt(o2.toString())
                return 0;
             else
                 return -1;
         }
     });
    
    
    
    
    二、按value值排序
    1)方法一:用两个list链表实现
    List<String> keyList = new LinkedList<String>();
     keyList.addAll(map.keySet());
     List<Integer> valueList = new LinkedList<Integer>();
     valueList.addAll(map.values());
     for(int i=0; i<valueList.size(); i++)
        for(int j=i+1; j<valueList.size(); j++) {
           if(valueList.get(j)>valueList.get(i)) {
               valueList.set(j, valueList.get(i));
               valueList.set(i, valueList.get(j));
               //同样调整对应的key值
              keyList.set(j, keyList.get(i));
               keyList.set(i, kyeList.get(j));
           }
    然后依次把key值和对应value值重新装入HashMap即可。
    2)方法二:改写JDK提供的Comparator接口方法compare
     List<Map.Entry<String, Integer>> list = new LinkedList<Map.Entry<String, Integer>>();
     list.addAll(map.entrySet());
     Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
        public int compare(Map.Entry obj1, Map.Entry obj2) {//从高往低排序
           
            if(Integer.parseInt(obj1.getValue().toString())<Integer.parseInt(obj2.getValue().toString()))
                return 1;
            if(Integer.parseInt(obj1.getValue().toString())==Integer.parseInt(obj2.getValue().toString()))
                return 0;
            else
               return -1;
        }
     });
     for(Iterator<Map.Entry<String, Integer>> ite = list.iterator(); ite.hasNext();) {
          Map.Entry<String, Integer> map = ite.next();
         System.out.println("key-value: " + map.getKey() + "," + map.getValue());
     } 
  • 相关阅读:
    RESTful 、RESTful API 、REST 介绍
    微服务 第三章:SpringBoot 创建web项目(调用jsp)
    微服务 第二章:SpringBoot 创建web项目(用Thymeleaf模板引擎)
    SpringBoot学习之 Thymeleaf
    Junit测试
    ---run-pat 测试 crontab 命令
    ---iproute2 策略路由
    ---曾经整混的两个词
    ---Under Ubuntu 14.04
    ---Ubuntu 14.04 虚拟机器和主机时间同步
  • 原文地址:https://www.cnblogs.com/tingbogiu/p/6373400.html
Copyright © 2011-2022 走看看