精华内容
下载资源
问答
  • hashmap排序
    2020-08-02 18:37:12

    说明

    已知一个 HashMap<Integer,User>集合, User 有 name(String)和 age(int)属性。请写一个方法实现对HashMap 的排序功能,该方法接收 HashMap<Integer,User>为形参,返回类型为 HashMap<Integer,User>,要求对 HashMap 中的 User 的 age 倒序进行排序。排序时 key=value 键值对不得拆散。

    注意:要做出这道题必须对集合的体系结构非常的熟悉。HashMap本身就是不可排序的,但是该题偏偏让HashMap排序,那我们就得想在API中有没有这样的 Map 结构是有序的,我们不难发现其中LinkedHashMap就具有这样的结构,是链表结构有序的,更可喜的是他是 HashMap的子类,我们返回LinkedHashMap<Integer,User>即可,还符合面向接口编程的思想。

    但凡是对集合的操作,我们应该保持一个原则就是能用JDK中的API就用JDK中的 API,比如排序算法我们不应该去用冒泡或者选择,而是首先想到用 Collections 集合工具类。

    class User{
        private String name;
        private int age;
    
        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    
    
    public class SortedHashMap {
        public static HashMap<Integer,User> sortedHashMap(HashMap<Integer,User> map){
            Set<Map.Entry<Integer,User>> entrySet=map.entrySet();
            List<Map.Entry<Integer,User>> list=new ArrayList<>(entrySet);
            Collections.sort(list, new Comparator<Map.Entry<Integer, User>>() {
                @Override
                public int compare(Map.Entry<Integer, User> o1, Map.Entry<Integer, User> o2) {
                    return o2.getValue().getAge()-o1.getValue().getAge();
                }
            });
    
            LinkedHashMap<Integer,User> res=new LinkedHashMap<>();
            for(Map.Entry<Integer,User> entry:list){
                res.put(entry.getKey(),entry.getValue());
            }
            return res;
        }
    
        public static void main(String[] args) {
            HashMap<Integer,User> users=new HashMap();
    
        }
    }
    
    更多相关内容
  • Hashmap排序

    2022-05-09 16:21:42
    代码如下: ... HashMap<String, Integer> map = new HashMap<>(); map.put("xxx10",12); map.put("xxx2",10); map.put("xxxq",3); map.put("xxxx",41); System.out.println(map); .

     代码如下:

      @Test
        public void xxx(){
            HashMap<String, Integer> map = new HashMap<>();
            map.put("xxx10",12);
            map.put("xxx2",10);
            map.put("xxxq",3);
            map.put("xxxx",41);
            System.out.println(map);
            HashMap<String,Integer> sortHashMap = sortHashMap(map);
            System.out.println(sortHashMap);
    
        }
        public static HashMap<String,Integer> sortHashMap(HashMap<String,Integer> map) {
            // 首先拿到map 的键值对集合
            Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
            // 将set 集合转为List 集合,为什么,为了使用工具类的排序方法
            List<Map.Entry<String,Integer>> list = new ArrayList<Map.Entry<String,Integer>>(entrySet);
            // 使用Collections 集合工具类对list 进行排序,排序规则使用匿名内部类来实现
            Collections.sort(list, new Comparator<Map.Entry<String,Integer>>() {
    
                @Override
                public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                    return o2.getValue() - o1.getValue();
                }
            });
            //创建一个新的有序的HashMap 子类的集合
            LinkedHashMap<String,Integer> linkedHashMap = new LinkedHashMap<String,Integer>();
            //将List 中的数据存储在LinkedHashMap 中
            for(Map.Entry<String,Integer> entry : list){
                linkedHashMap.put(entry.getKey(), entry.getValue());
            }
            //返回结果
            return linkedHashMap;
    
        }

    结果:  根据v的值进行排序

     

    展开全文
  • 主要介绍了Android中实现HashMap排序的方法,很经典的一种排序算法,需要的朋友可以参考下
  • Java数组、ArrayList、HashMap排序总结

    千次阅读 2022-04-11 11:38:13
    在Java刷题过程中,无论是数组、ArrayList还是HashMap排序是必不可少的,下面就对这些不同数据结构的排序做一个汇总。 1. 数组排序 1)一维数组 直接调用sort方法: int[] num = new int[n]; Arrays.sort(num); ...

    在Java刷题过程中,无论是数组、ArrayList还是HashMap,排序是必不可少的,下面就对这些不同数据结构的排序做一个汇总。

    1. 数组排序

    1)一维数组

    直接调用sort方法:

    int[] num = new int[n];
    Arrays.sort(num);
    

    自定义排序:

    Integer[] = new Integer[n];
    Arrays.sort(minNum, new Comparator<String>() {
    @Override
    	public int compare(Integer e1, Integer e2) {
    	    return e1.compareTo(e2);
    	}
    });
    

    :在自定义排序方法的时候,需要注意,不能对基本类型的数组进行自定义排序,如int,byte,char

    所以,举例子用的Integer。

    lambda表达式排序:

    Arrays.sort(minNum, ((o1, o2) -> (o1).compareTo(o2)));
    

    2)二维数组

    int[][] arr = new int[m][n];
    
    1. 实现Comparator接口 :匿名内部类实现
    Arrays.sort(arr, new Comparator<int[]>() {    // 匿名内部类
    	@Override
    	public int compare(int[] e1, int[] e2) {
    		// 如果第一列元素相等,则比较第二列元素
    		if (e1[0] == e2[0]) return e1[1] - e2[1];   // e1[1]-e2[1]表示对于第二列元素进行升序排序
    		return e1[0] - e2[0];                     // e1[0]-e2[0]表示对于第一列元素进行升序排序
    	}
    });
    
    1. lambda表达式实现
    // 仅按第一列元素升序排序
    Arrays.sort(arr, (e1, e2) -> (e1[0] - e2[0]));   // "->"lambda表达式符号,其将参数与实现隔开。
    
    // 先按第一列元素升序排序,如果第一列相等再按第二列元素升序;
    Arrays.sort(arr, (e1, e2)->(e1[0] == e2[0] ? (e1[1] - e2[1]):(e1[0] - e2[0])));
    

    2. ArrayList排序

    直接调用sort方法:

    ArrayList<Integer> list = new ArrayList<>();
    Collections.sort(list);  // Java7,list并没有sort方法
    

    自定义排序方法:

    List<Integer> list = new ArrayList<Integer>();
    Collections.sort(list, new Comparator<Integer>() {
        @Override 
        public int compare(Integer o1, Integer o2) { 
        // 可以比较对象中任意属性,这里是Integer类型,直接是它本身进行比较       
            return o1.compareTo(o2); 
        }
    });
    

    Java8新特性:lambda表达式:

    Collections.sort(list, (e1 , e2) -> (e1.compareTo(e2)));
    

    需要去重的话:

    1. 可以用list去重
    2. 用TreeSet直接去重并排序,只是获取元素的时候仍需转为list

    3. HashMap排序

    Java中HashMap是一种用于存储“键”和“值”信息对的数据结构。不同于Array、ArrayList和LinkedLists,它不会维持插入元素的顺序。因此对HashMap排序的掌握很重要。

    HashMap的排序分为按key和按Value进行排序。

    HashMap排序有两个步骤:

    1. 通过map.entrySet()方法获取键值对;并将键值对传递给链表list

      List<Map.Entry<String,Integer>> list = new ArrayList<>(map.entrySet());
      
    2. 自定义比较器来使用Collections.sort()方法排序链表

       Collections.sort(list, new Comparator<Map.Entry<String,Integer>>() {  
           public int compare(Map.Entry<String, Integer> e1,  
                  Map. Entry<String, Integer> e2) {  
               return e1.getValue().compareTo(e2.getValue());  
           }  
       }); 
      

    示例:

    单关键字排序:

    Map<Integer, Integer> map = new HashMap<>();
    List<Map.Entry<Integer,Integer>> list = new ArrayList<>(map.entrySet());
    // 直接使用lambda表达式排序
    list.sort((o1, o2) -> o2.getValue() - o1.getValue());
    

    多关键字排序:

    Map<Integer, int[]> map = new HashMap<>();
    // Map按value排序,先将map转为list,再排序list(按value值进行排序)
    List<Map.Entry<Integer, int[]>> list = new ArrayList<Map.Entry<Integer, int[]>>(map.entrySet());
    
    // 通过比较器来实现排序
    Collections.sort(list, new Comparator<Map.Entry<Integer, int[]>>() {
        @Override
        public int compare(Map.Entry<Integer, int[]> o1, Map.Entry<Integer, int[]> o2) {
            // 降序排序
            int re = o1.getValue()[0] - o2.getValue()[0];
            if (re != 0) {
                return re;
            }
            re = o1.getValue()[1] - o2.getValue()[1];
            if (re != 0) {
                return re;
            }
            return 0;
        }
    });
    // 直接使用lambda表达式排序
    list.sort((o1, o2) -> (o1.getValue()[0]==o2.getValue()[0]?(o1.getValue()[1]-o2.getValue()[1]):(o1.getValue()[0]-o2.getValue()[0])));
    

    以下再按valaue和key排序总结一下,是重写compare方法的一个介绍:

    1. 对value降序
    public int compare(Map.Entry<Integer,Integer>e1,Map.Entry<Integer,Integer>e2){
        return e2.getValue().compareTo(e1.getValue()); 
    }
    
    1. 对值value升序排序
    public int compare(Map.Entry<Integer,Integer>e1,Map.Entry<Integer,Integer>e2){
        return e1.getValue().compareTo(e2.getValue()); 
    }
    
    1. 对键KEY降序排列
    public int compare(Map.Entry<Integer,Integer>e1,Map.Entry<Integer,Integer>e2){
        return e2.getKey().compareTo(e1.getKey()); 
    }
    
    1. 对键KEY升序排列
    public int compare(Map.Entry<Integer,Integer>e1,Map.Entry<Integer,Integer>e2){
        return e1.getKey().compareTo(e2.getKey()); 
    }
    
    1. 优先按值value降序、其次按键key升序排序
    public int compare(Map.Entry<String,Integer>e1,Map.Entry<String,Integer>e2){
        int re = e2.getValue().compareTo(e1.getValue());
        if(re!=0){return re;}
        else{return e1.getKey().compareTo(e2.getKey());}
    }
    
    1. 优先按键key降序、其次按值value升序排序
    public int compare(Map.Entry<String,Integer>e1,Map.Entry<String,Integer>e2){
        int re = e2.getKey().compareTo(e1.getKey());
        if(re!=0){return re;}
        else{return e1.getValue().compareTo(e2.getValue());}
    }
    

    总的来说HashMap的排序,就是先加入list,转而对list进行排序。这时候可以选择重写匿名内部类,也可以使用lambda表达式。

    也可以转为TreeMap进行排序,同List。

    最后是获取排序后的HashMap:

    1. 从list取值再赋给Map.Entry<Integer, Integer>
    for (int i = 0; i < list.size(); i++) {
        Map.Entry<Integer, Integer> entry = list.get(i);
        if (i != list.size() - 1) {
            System.out.print(entry.getKey() + ",");
        } else {
            System.out.println(entry.getKey());
        }
    }
    
    1. 直接从list取
    for (Map.Entry<Integer, Integer> entry : list) {
        System.out.print(entry.getKey());
    }
    
    展开全文
  • HashMap排序算法

    2020-06-04 22:02:20
    import java.util.*; /** * @author kiki * @version 1.0 ... * 对hashmap集合进行排序 */ public class HashMapTest { public static void main(String[] args) { //初始化数据 HashMap<Inte
    package com.itheima.kiki.demo01;
    import java.util.*;
    /**
     * @author kiki
     * @version 1.0
     * @create 2020/6/4 21:24
     */
    /**
     * 对hashmap集合进行排序,按年龄进行倒序排列
     */
    public class HashMapTest {
        public static void main(String[] args) {
            //初始化数据
            HashMap<Integer, User> users = new HashMap<>();
            users.put(1,new User("张三",25));
            users.put(2,new User("李四",28));
            users.put(3,new User("王五",22));
            System.out.println(users);
            //调用排序方法
            HashMap<Integer, User> sortHashMap = sortHashMap(users);
            //{2=User{name='李四', age=28}, 1=User{name='张三', age=25}, 3=User{name='王五', age=22}}
            System.out.println(sortHashMap);
        }
        public static HashMap<Integer, User> sortHashMap(HashMap<Integer, User> map){
            //拿到map的键值对集合
            Set<Map.Entry<Integer, User>> entrySet = map.entrySet();
            //转list集合,为了使用Collections的sort方法
            ArrayList<Map.Entry<Integer, User>> list = new ArrayList<Map.Entry<Integer, User>>(entrySet);
            Collections.sort(list, new Comparator<Map.Entry<Integer, User>>() {
                @Override
                public int compare(Map.Entry<Integer, User> o1, Map.Entry<Integer, User> o2) {
                    return o2.getValue().getAge()  - o1.getValue().getAge();
                }
            });
            //创建有序的hashmap子类的集合
            LinkedHashMap<Integer, User> linkedHashMap = new LinkedHashMap<>();
            //将list的数据存储到linkedHashMap中
            for (Map.Entry<Integer, User> entry : list) {
                linkedHashMap.put(entry.getKey(),entry.getValue());
            }
            //返回有序的hashmap的子类集合
            return linkedHashMap;
        }
    }
    class User{
        String name;
        int age;
        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    展开全文
  • Hashmap排序的几个方法

    千次阅读 2021-02-12 13:41:57
    HashMap排序方法 假设有这样的类 代码如下(示例): class Student { private Integer id; private String name; Student(Integer id, String name) { this.id = id; this.name = name; } public String toString()...
  • java 中HashMap排序

    2021-02-12 14:41:28
    一、按key值排序假设HashMap存储的键-值对为(String,Integer),按key排序可以调用JDK函数sort(默认的按字典升序):Set keySet = map.keySet();Collections.sort(keySet);for(Iterator ite = keySet.iterator(); ite...
  • 用Java对HashMap排序

    千次阅读 2020-06-08 10:55:39
    在本教程中,我们将学习如何对Java HashMap进行排序。 我们可以按键或按值对HashMap进行排序。 我们将讨论这两种策略。 对Java 为了跟上本文的其余部分,我们首先构造一个HashMapHashMap<Integer, ...
  • 按照Value对HashMap排序

    2021-03-08 09:26:01
    TreeMap基于红黑树排序的算法,默认数据put进来按照key的大小升序排序,如果需要改成按value排序,则自定义新的Comparator,重写compare(Object, Object)方法即可。看TreeMap的源码可知,它实现了AbstractMap类的put...
  • java中hashMap排序

    千次阅读 2019-02-12 10:34:03
     首先我们要知道HashMap 本身就是不可排序的,但这里我们要使HashMap 排序,那我们就得想在 API 中有没有这样的 Map 结构是有序的,那就需要用上LinkedHashMap,它是 Map 结构,也是链表结构有序的,更重要的是它是...
  • HashMap排序和遍历(Java实现)
  • HashMap排序

    2021-05-23 17:02:24
    集合,User有name(String) 和age(int)属性,请写一个方法实现对HashMap排序功能,该方法接收HashMap<Integer, User>为形参,返回类型为HashMap<Integer, User>,要求对HashMap中的User的age倒序进行...
  • hashmap排序

    2017-10-17 16:39:29
    HashMap hashS1=new HashMap(); //遍历有效公司的排序 ArrayList> listG= new ArrayList>(hashS1.entrySet()); Collections.sort(listG, new Comparator>() { public int compare(Map.Entry o1,
  • Map<String,Object>map=new HashMap<>(); map.forEach((key,value)->{ System.out.println(key+":"+value); });
  • HashMap 排序

    2019-04-19 17:48:06
    Java中 HashMap没有排序, 如果想要对HashMap排序怎么办,当然是用TreeMap可以,本文总结的是给已有HashMap排序 第一次试验: 排序后HashMap结果没变, 总结原因: HashMap本生是无序的,将HashMap转换为list,对...
  • java hashmap排序的2种方式

    千次阅读 2019-09-03 20:25:30
    对名称进行排序,首先要得到HashMap中键的集合(keySet),并转换为数组,这样才能用Arrays.sort()进行排序 Set set=phone.keySet(); Object[] arr=set.toArray(); Arrays.sort(arr); for(Object key:arr){ ...
  • 实现HashMap排序

    2018-09-19 14:06:12
    自己刷在线编程题用到好多次hashmap,刷了三四遍才能记住hashmap表的排序。 我就不生讲了,直接用刷的一个题目为例 给出一个01字符串(长度不超过100),求其每一个子串出现的次数。 输入描述: 输入包含多行,...
  • HashMap:新key的加入或旧key的value的改变会刷新map中key的位置,变化的key总是存储在最前面。 LinkedHashMap:有序的HashMap,key的改变不会影响key在map中的位置。 如下一道DB面试题: /** @author hetao @date ...
  • java List中的HashMap排序

    千次阅读 2019-02-18 16:20:03
    采用重写Collections.sort方法实现对 List中的HashMap排序。 ArrayList&lt;Map&lt;String,Object&gt;&gt; list = new ArrayList&lt;Map&lt;String, Object&gt;&gt;(); Map&lt;...
  • HashMap按Value排序 import java.util.*; public class HashMapSort { private static void mapValueSort(HashMap<String, Integer> labelsMap) { List<Map.Entry<String, Integer>> ...
  • Hashmap HashMap 是一个散列表,它存储的内容是键值对(key-value)映射。 HashMap 实现了 Map 接口,根据键的 HashCode 值存储数据,具有很快的访问速度,最多允许一条记录的键为 null,不支持线程同步。 但HashMap ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 176,639
精华内容 70,655
关键字:

hashmap排序

友情链接: surf_integral.zip