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

    万次阅读 2017-06-16 16:17:57
    LinkedHashMap排序问题
    LinkedHashMap<String, Float> map = new LinkedHashMap<>();
    
    //先转成ArrayList集合
    ArrayList<Entry<String, Float>> list = 
            new ArrayList<Map.Entry<String, Float>>(map.entrySet());
    
    //从小到大排序(从大到小将o1与o2交换即可)
    Collections.sort(list, new Comparator<Map.Entry<String, Float>>() {
    
        @Override
        public int compare(Entry<String, Float> o1, Entry<String, Float> o2) {
            return ((o1.getValue() - o2.getValue() == 0) ? 
                    0: (o1.getValue() - o2.getValue() > 0) ? 1: -1);
        }
    
    });
    
    //新建一个LinkedHashMap,把排序后的List放入
    LinkedHashMap<String, Float> map2 = new LinkedHashMap<>();
    for (Map.Entry<String, Float> entry : list) {
        map2.put(entry.getKey(), entry.getValue());
    }
    
    //遍历输出
    for (Map.Entry<String, Float> entry : map2.entrySet()) {
        System.out.println(entry.getKey() + ":" + entry.getValue());
    }
    
    展开全文
  • LinkedHashMap对key进行排序

    千次阅读 2019-08-06 13:46:26
    LinkedHashMap按key进行降序排序 public static void main(String[] args) { LinkedHashMap<String,String> map = new LinkedHashMap<String,String>(); map.put("1","aaa"); map.put("3","bbb")....

    对LinkedHashMap按key进行降序排序

    public static void main(String[] args) {
        LinkedHashMap<String,String> map = new LinkedHashMap<String,String>();
        map.put("1","aaa");
        map.put("3","bbb");
        map.put("2","ccc");
        map.put("5","ddd");
        List<Map.Entry<String, String>> infoIds =new ArrayList<Map.Entry<String, String>>(map.entrySet());
        //排序
        Collections.sort(infoIds, new Comparator<Map.Entry<String, String>>() {
            public int compare(Map.Entry<String, String> o1, Map.Entry<String, String> o2) {
                String p1 =  o1.getKey();
                String p2 = o2.getKey();;
                return Integer.valueOf(p2)-Integer.valueOf(p1);//如果要升序, 改为return Integer.valueOf(p1)-Integer.valueOf(p2);
            }
        });
       //转换成新map输出
        LinkedHashMap<String, String> newMap = new LinkedHashMap <String, String>();

        for(Map.Entry<String,String> entity : infoIds){
            newMap.put(entity.getKey(), entity.getValue());
            System.out.println(entity.getKey());
        }
    }

    debug后的截图,已经降序排好

    展开全文
  • LinkedHashMap和TreeMap排序实现

    千次阅读 2017-09-25 23:10:46
     Comparator可以对集合对象或者数组进行排序的比较器接口,实现该接口的public compare(T o1,To2)方法即可实现排序,该方法主要是根据第一个参数o1,小于、等于或者大于o2分别返回负整数、0或者正整数。如下: ...

    TreeMap

          TreeMap默认是升序的,如果我们需要改变排序方式,则需要使用比较器:Comparator。

          Comparator可以对集合对象或者数组进行排序的比较器接口,实现该接口的public compare(T o1,To2)方法即可实现排序,该方法主要是根据第一个参数o1,小于、等于或者大于o2分别返回负整数、0或者正整数。如下:

    public class TreeMapTest {
        public static void main(String[] args) {
            Map<String, String> map = new TreeMap<String, String>(
                    new Comparator<String>() {
                        public int compare(String obj1, String obj2) {
                            // 降序排序
                            return obj2.compareTo(obj1);
                        }
                    });
            map.put("c", "ccccc");
            map.put("a", "aaaaa");
            map.put("b", "bbbbb");
            map.put("d", "ddddd");
            
            Set<String> keySet = map.keySet();
            Iterator<String> iter = keySet.iterator();
            while (iter.hasNext()) {
                String key = iter.next();
                System.out.println(key + ":" + map.get(key));
            }
        }
    }

    结果:

     d:ddddd 
     c:ccccc 
     b:bbbbb 
     a:aaaaa

    上面例子是对根据TreeMap的key值来进行排序的,但是有时我们需要根据TreeMap的value来进行排序。对value排序我们就需要借助于Collections的sort(List<T> list, Comparator<? super T> c)方法,该方法根据指定比较器产生的顺序对指定列表进行排序。但是有一个前提条件,那就是所有的元素都必须能够根据所提供的比较器来进行比较。如下:

    public class TreeMapTest {
        public static void main(String[] args) {
            Map<String, String> map = new TreeMap<String, String>();
            map.put("d", "ddddd");
            map.put("b", "bbbbb");
            map.put("a", "aaaaa");
            map.put("c", "ccccc");
            
            //这里将map.entrySet()转换成list
            List<Map.Entry<String,String>> list = new ArrayList<Map.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(Map.Entry<String,String> mapping:list){ 
                   System.out.println(mapping.getKey()+":"+mapping.getValue()); 
              } 
        }
    }

     运行结果

          a:aaaaa 
          b:bbbbb 
          c:ccccc 
          d:ddddd

    HashMap

          我们都是HashMap的值是没有顺序的,他是按照key的HashCode来实现的。对于这个无序的HashMap我们要怎么来实现排序呢?参照TreeMap的value排序,我们一样的也可以实现HashMap的排序。

    public class HashMapTest {
        public static void main(String[] args) {
            Map<String, String> map = new HashMap<String, String>();
            map.put("c", "ccccc");
            map.put("a", "aaaaa");
            map.put("b", "bbbbb");
            map.put("d", "ddddd");
            
            List<Map.Entry<String,String>> list = new ArrayList<Map.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(Map.Entry<String,String> mapping:list){ 
                   System.out.println(mapping.getKey()+":"+mapping.getValue()); 
              } 
         }
    }

    运行结果

          a:aaaaa 
          b:bbbbb 
          c:ccccc 
          d:ddddd

    HashMap通过LinkedHashMap排序

    public class TestMapSortByValue {
    
     
    
        public static void main(String[] args) {
    
            Map<String, Integer> map = new HashMap<String, Integer>();
    
            map.put("d",4);
    
            map.put("a",1);
    
            map.put("c",3);
    
            map.put("e",5);
    
            map.put("b",2);
    
            //排序前
    
            System.out.println("before sort");
    
            for(Map.Entry<String, Integer> entry:map.entrySet()){
    
                System.out.println(entry.getKey()+"->"+entry.getValue());
    
            }
    
            System.out.println();
    
             
    
            //将map转成list
    
            List<Map.Entry<String, Integer>> infos = new ArrayList<Map.Entry<String, Integer>>(map.entrySet());
    
            //对list排序,实现新的比较器
    
            Collections.sort(infos, new Comparator<Map.Entry<String, Integer>>(){
    
                @Override
    
                public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
    
                    return o1.getValue() - o2.getValue();
    
                }
    
            });
    
            //申明新的有序 map,根据放入的数序排序
    
            Map<String, Integer> lhm = new LinkedHashMap<String, Integer>();
    
            //遍历比较过后的map,将结果放到LinkedHashMap
    
            for(Map.Entry<String, Integer> entry:infos){
    
                lhm.put(entry.getKey(), entry.getValue());
    
            }
    
            //遍历LinkedHashMap,打印值
    
            System.out.println("after sort");
    
            for(Map.Entry<String, Integer> entry:lhm.entrySet()){
    
                System.out.println(entry.getKey()+"->"+entry.getValue());
    
            }
    
        }
    
    }
    结果:
    before sort
    d->4
    e->5
    b->2
    c->3
    a->1
     
    after sort
    a->1
    b->2
    c->3
    d->4
    e->5

















    展开全文
  • hashMap,treeMap,LinkedHashMap的默认排序

    千次阅读 2017-01-11 13:08:51
     TreeMap:能够把它保存的记录根据键(key)排序,默认是按升序排序,也可以指定排序的比较器,该映射根据其键的自然顺序进行排序,或者根据创建映射时提供的 Comparator 进行排序,具体取决于使用的构造方法。...

    一、简单描述

    Map是键值对的集合接口,它的实现类主要包括:HashMap,TreeMap,HashTable以及LinkedHashMap等。

            TreeMap:能够把它保存的记录根据键(key)排序,默认是按升序排序,也可以指定排序的比较器,该映射根据其键的自然顺序进行排序,或者根据创建映射时提供的 Comparator 进行排序,具体取决于使用的构造方法。

            HashMap的值是没有顺序的,它是按照key的HashCode来实现的,根据键可以直接获取它的值,具有很快的访问速度。HashMap最多只允许一条记录的键为Null(多条会覆盖);允许多条记录的值为 Null。非同步的。

            Map.Entry返回Collections视图。

            注:map简单的UML

    伦理片 http://www.dotdy.com/  

     

     HashMap是按照插入key的hashcode值进行数组排序的,插入排序,不保证稳定性。

     

     TreeMap 接收的comparator的接口默认是key值的排序,源代码如下:

     

    Java代码   收藏代码
    1. /**  
    2.      * Constructs a new, empty tree map, ordered according to the given  
    3.      * comparator.  All keys inserted into the map must be <em>mutually  
    4.      * comparable</em> by the given comparator: {@code comparator.compare(k1,  
    5.      * k2)} must not throw a {@code ClassCastException} for any keys  
    6.      * {@code k1} and {@code k2} in the map.  If the user attempts to put  
    7.      * a key into the map that violates this constraint, the {@code put(Object  
    8.      * key, Object value)} call will throw a  
    9.      * {@code ClassCastException}.  
    10.      *  
    11.      * @param comparator the comparator that will be used to order this map.  
    12.      *        If {@code null}, the {@linkplain Comparable natural  
    13.      *        ordering} of the keys will be used.  
    14.      */    
    15.     public TreeMap(Comparator<? super K> comparator) {    
    16.         this.comparator = comparator;    
    17.     }    

     注:java8 在Map接口中的Entry接口中实现了根据key、value排序的接口,源代码如下:

    Java代码   收藏代码
    1. public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {  
    2.             return (Comparator<Map.Entry<K, V>> & Serializable)  
    3.                 (c1, c2) -> c1.getKey().compareTo(c2.getKey());  
    4.         }  
    5.    public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue() {  
    6.             return (Comparator<Map.Entry<K, V>> & Serializable)  
    7.                 (c1, c2) -> c1.getValue().compareTo(c2.getValue());  
    8.         }  

     

    LinkedHashMap重写了Entry实现类,实现成双向链表的类型结构,会存取borfer和after的元素,插入的时候把当前元素插入到链表头部,

    继承自HashMap,一个有序的Map接口实现,这里的有序指的是元素可以按插入顺序或访问顺序排列;

     

    与HashMap的异同:同样是基于散列表实现,区别是,LinkedHashMap内部多了一个双向循环链表的维护,该链表是有序的,可以按元素插入顺序或元素最近访问顺序(LRU)排列,

    简单地说:LinkedHashMap=散列表+循环双向链表

    Java代码   收藏代码
    1. package java.util;  
    2. import java.io.*;  
    3.   
    4.   
    5. public class LinkedHashMap<K,V>  
    6.     extends HashMap<K,V>  
    7.     implements Map<K,V>  
    8. {  
    9.   
    10.     private static final long serialVersionUID = 3801124242820219131L;  
    11.   
    12.     /** 
    13.      * 双向循环链表,  头结点(空节点) 
    14.      */  
    15.     private transient Entry<K,V> header;  
    16.   
    17.     /** 
    18.      * accessOrder为true时,按访问顺序排序,false时,按插入顺序排序 
    19.      */  
    20.     private final boolean accessOrder;  
    21.   
    22.     /** 
    23.      * 生成一个空的LinkedHashMap,并指定其容量大小和负载因子, 
    24.      * 默认将accessOrder设为false,按插入顺序排序 
    25.      */  
    26.     public LinkedHashMap(int initialCapacity, float loadFactor) {  
    27.         super(initialCapacity, loadFactor);  
    28.         accessOrder = false;  
    29.     }  
    30.   
    31.     /** 
    32.      * 生成一个空的LinkedHashMap,并指定其容量大小,负载因子使用默认的0.75, 
    33.      * 默认将accessOrder设为false,按插入顺序排序 
    34.      */  
    35.     public LinkedHashMap(int initialCapacity) {  
    36.         super(initialCapacity);  
    37.         accessOrder = false;  
    38.     }  
    39.   
    40.     /** 
    41.      * 生成一个空的HashMap,容量大小使用默认值16,负载因子使用默认值0.75 
    42.      * 默认将accessOrder设为false,按插入顺序排序. 
    43.      */  
    44.     public LinkedHashMap() {  
    45.         super();  
    46.         accessOrder = false;  
    47.     }  
    48.   
    49.     /** 
    50.      * 根据指定的map生成一个新的HashMap,负载因子使用默认值,初始容量大小为Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,DEFAULT_INITIAL_CAPACITY) 
    51.      * 默认将accessOrder设为false,按插入顺序排序. 
    52.      */  
    53.     public LinkedHashMap(Map<? extends K, ? extends V> m) {  
    54.         super(m);  
    55.         accessOrder = false;  
    56.     }  
    57.   
    58.     /** 
    59.      * 生成一个空的LinkedHashMap,并指定其容量大小和负载因子, 
    60.      * 默认将accessOrder设为true,按访问顺序排序 
    61.      */  
    62.     public LinkedHashMap(int initialCapacity,  
    63.                          float loadFactor,  
    64.                          boolean accessOrder) {  
    65.         super(initialCapacity, loadFactor);  
    66.         this.accessOrder = accessOrder;  
    67.     }  
    68.   
    69.     /** 
    70.      * 覆盖HashMap的init方法,在构造方法、Clone、readObject方法里会调用该方法 
    71.      * 作用是生成一个双向链表头节点,初始化其前后节点引用 
    72.      */  
    73.     @Override  
    74.     void init() {  
    75.         header = new Entry<>(-1nullnullnull);  
    76.         header.before = header.after = header;  
    77.     }  
    78.   
    79.     /** 
    80.      * 覆盖HashMap的transfer方法,性能优化,这里遍历方式不采用HashMap的双重循环方式 
    81.      * 而是直接通过双向链表遍历Map中的所有key-value映射 
    82.      */  
    83.     @Override  
    84.     void transfer(HashMap.Entry[] newTable, boolean rehash) {  
    85.         int newCapacity = newTable.length;  
    86.         //遍历旧Map中的所有key-value  
    87.         for (Entry<K,V> e = header.after; e != header; e = e.after) {  
    88.             if (rehash)  
    89.                 e.hash = (e.key == null) ? 0 : hash(e.key);  
    90.             //根据新的数组长度,重新计算索引,  
    91.             int index = indexFor(e.hash, newCapacity);  
    92.             //插入到链表表头  
    93.             e.next = newTable[index];  
    94.             //将e放到索引为i的数组处  
    95.             newTable[index] = e;  
    96.         }  
    97.     }  
    98.   
    99.   
    100.     /** 
    101.      * 覆盖HashMap的transfer方法,性能优化,这里遍历方式不采用HashMap的双重循环方式 
    102.      * 而是直接通过双向链表遍历Map中的所有key-value映射, 
    103.      */  
    104.     public boolean containsValue(Object value) {  
    105.         // Overridden to take advantage of faster iterator  
    106.         if (value==null) {  
    107.             for (Entry e = header.after; e != header; e = e.after)  
    108.                 if (e.value==null)  
    109.                     return true;  
    110.         } else {  
    111.             for (Entry e = header.after; e != header; e = e.after)  
    112.                 if (value.equals(e.value))  
    113.                     return true;  
    114.         }  
    115.         return false;  
    116.     }  
    117.   
    118.     /** 
    119.      * 通过key获取value,与HashMap的区别是:当LinkedHashMap按访问顺序排序的时候,会将访问的当前节点移到链表尾部(头结点的前一个节点) 
    120.      */  
    121.     public V get(Object key) {  
    122.         Entry<K,V> e = (Entry<K,V>)getEntry(key);  
    123.         if (e == null)  
    124.             return null;  
    125.         e.recordAccess(this);  
    126.         return e.value;  
    127.     }  
    128.   
    129.     /** 
    130.      * 调用HashMap的clear方法,并将LinkedHashMap的头结点前后引用指向自己 
    131.      */  
    132.     public void clear() {  
    133.         super.clear();  
    134.         header.before = header.after = header;  
    135.     }  
    136.   
    137.     /** 
    138.      * LinkedHashMap节点对象 
    139.      */  
    140.     private static class Entry<K,V> extends HashMap.Entry<K,V> {  
    141.         // 节点前后引用  
    142.         Entry<K,V> before, after;  
    143.   
    144.         //构造函数与HashMap一致  
    145.         Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {  
    146.             super(hash, key, value, next);  
    147.         }  
    148.   
    149.         /** 
    150.          * 移除节点,并修改前后引用 
    151.          */  
    152.         private void remove() {  
    153.             before.after = after;  
    154.             after.before = before;  
    155.         }  
    156.   
    157.         /** 
    158.          * 将当前节点插入到existingEntry的前面 
    159.          */  
    160.         private void addBefore(Entry<K,V> existingEntry) {  
    161.             after  = existingEntry;  
    162.             before = existingEntry.before;  
    163.             before.after = this;  
    164.             after.before = this;  
    165.         }  
    166.   
    167.         /** 
    168.          * 在HashMap的put和get方法中,会调用该方法,在HashMap中该方法为空 
    169.          * 在LinkedHashMap中,当按访问顺序排序时,该方法会将当前节点插入到链表尾部(头结点的前一个节点),否则不做任何事 
    170.          */  
    171.         void recordAccess(HashMap<K,V> m) {  
    172.             LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;  
    173.             //当LinkedHashMap按访问排序时  
    174.             if (lm.accessOrder) {  
    175.                 lm.modCount++;  
    176.                 //移除当前节点  
    177.                 remove();  
    178.                 //将当前节点插入到头结点前面  
    179.                 addBefore(lm.header);  
    180.             }  
    181.         }  
    182.   
    183.         void recordRemoval(HashMap<K,V> m) {  
    184.             remove();  
    185.         }  
    186.     }  
    187.       
    188.     //迭代器  
    189.     private abstract class LinkedHashIterator<T> implements Iterator<T> {  
    190.         //初始化下个节点引用  
    191.         Entry<K,V> nextEntry    = header.after;  
    192.         Entry<K,V> lastReturned = null;  
    193.   
    194.         /** 
    195.          * 用于迭代期间快速失败行为 
    196.          */  
    197.         int expectedModCount = modCount;  
    198.           
    199.         //链表遍历结束标志,当下个节点为头节点的时候  
    200.         public boolean hasNext() {  
    201.             return nextEntry != header;  
    202.         }  
    203.   
    204.         //移除当前访问的节点  
    205.         public void remove() {  
    206.             //lastReturned会在nextEntry方法中赋值  
    207.             if (lastReturned == null)  
    208.                 throw new IllegalStateException();  
    209.             //快速失败机制  
    210.             if (modCount != expectedModCount)  
    211.                 throw new ConcurrentModificationException();  
    212.   
    213.             LinkedHashMap.this.remove(lastReturned.key);  
    214.             lastReturned = null;  
    215.             //迭代器自身删除节点,并不是其他线程修改Map结构,所以这里要修改expectedModCount  
    216.             expectedModCount = modCount;  
    217.         }  
    218.   
    219.         //返回链表下个节点的引用  
    220.         Entry<K,V> nextEntry() {  
    221.             //快速失败机制  
    222.             if (modCount != expectedModCount)  
    223.                 throw new ConcurrentModificationException();  
    224.             //链表为空情况  
    225.             if (nextEntry == header)  
    226.                 throw new NoSuchElementException();  
    227.               
    228.             //给lastReturned赋值,最近一个从迭代器返回的节点对象  
    229.             Entry<K,V> e = lastReturned = nextEntry;  
    230.             nextEntry = e.after;  
    231.             return e;  
    232.         }  
    233.     }  
    234.     //key迭代器  
    235.     private class KeyIterator extends LinkedHashIterator<K> {  
    236.         public K next() { return nextEntry().getKey(); }  
    237.     }  
    238.     //value迭代器  
    239.     private class ValueIterator extends LinkedHashIterator<V> {  
    240.         public V next() { return nextEntry().value; }  
    241.     }  
    242.     //key-value迭代器  
    243.     private class EntryIterator extends LinkedHashIterator<Map.Entry<K,V>> {  
    244.         public Map.Entry<K,V> next() { return nextEntry(); }  
    245.     }  
    246.   
    247.     // 返回不同的迭代器对象  
    248.     Iterator<K> newKeyIterator()   { return new KeyIterator();   }  
    249.     Iterator<V> newValueIterator() { return new ValueIterator(); }  
    250.     Iterator<Map.Entry<K,V>> newEntryIterator() { return new EntryIterator(); }  
    251.   
    252.     /** 
    253.      * 创建节点,插入到LinkedHashMap中,该方法覆盖HashMap的addEntry方法 
    254.      */  
    255.     void addEntry(int hash, K key, V value, int bucketIndex) {  
    256.         super.addEntry(hash, key, value, bucketIndex);  
    257.   
    258.         // 注意头结点的下个节点即header.after,存放于链表头部,是最不经常访问或第一个插入的节点,  
    259.         //有必要的情况下(如容量不够,具体看removeEldestEntry方法的实现,这里默认为false,不删除),可以先删除  
    260.         Entry<K,V> eldest = header.after;  
    261.         if (removeEldestEntry(eldest)) {  
    262.             removeEntryForKey(eldest.key);  
    263.         }  
    264.     }  
    265.   
    266.     /** 
    267.      * 创建节点,并将该节点插入到链表尾部 
    268.      */  
    269.     void createEntry(int hash, K key, V value, int bucketIndex) {  
    270.         HashMap.Entry<K,V> old = table[bucketIndex];  
    271.         Entry<K,V> e = new Entry<>(hash, key, value, old);  
    272.         table[bucketIndex] = e;  
    273.         //将该节点插入到链表尾部  
    274.         e.addBefore(header);  
    275.         size++;  
    276.     }  
    277.   
    278.     /** 
    279.      * 该方法在创建新节点的时候调用, 
    280.      * 判断是否有必要删除链表头部的第一个节点(最不经常访问或最先插入的节点,由accessOrder决定) 
    281.      */  
    282.     protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {  
    283.         return false;  
    284.     }  
    285. }  

     

     重写了Iterator的实现LinkedHashIterator,遍历的时候按照双向链表的顺序进行遍历,不是按照桶里数组的顺序进行遍历(HashMap).

    AbstractMap中的toString方法即调用的entrySet()方法,进行的遍历打印的值。

    图解:

    第一张图是LinkedHashMap的全部数据结构,包含散列表和循环双向链表,由于循环双向链表线条太多了,不好画,简单的画了一个节点(黄色圈出来的)示意一下,注意左边的红色箭头引用为Entry节点对象的next引用(散列表中的单链表),绿色线条为Entry节点对象的before, after引用(循环双向链表的前后引用);


    展开全文
  • LinkedHashMap源码分析  LinkedLinkedHashMap继承自HashMap,与HashMap不同的是,...  LinkedHashMap具有两种排序方式:按照插入顺序排序和按照最近使用顺序排序。而最近使用顺序正好是LRU算法实...
  • 班级排名 LinkedHashMap的按value排序

    千次阅读 2018-09-01 08:56:35
    Hash开头的会按随机排序,Linked开头的会按加入顺序排序,Tree开头的可以自定义排序规则 import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; ...
  • 分数排序的特殊问题 在java中实现排序远比C/C++简单,我们只要让集合中元素对应的类实现Comparable接口,然后调用Collections.sort();方法即可. 这种方法对于排序存在许多相同元素的情况有些浪费,明显即使值相等,...
  • LinkedHashMap继承于HashMap,如果对HashMap原理还不清楚的同学,请先了解下hashmap。本文的LinkedHashMap是jdk1.7版的 2 LinkedHashMap使用与实现 先来一张LinkedHashMap的结构图,不要虚,看完文章再来看这个图,...
  • final Map> questionMap = new LinkedHashMap(); Map> map = new LinkedHashMap(); List examPaperQuestionReferences = (List)examPaperQuestionReferenceCriteria.list(); for(int i =0;i<examPaperQuestionR
  • Java知识体系最强总结(2021版)

    万次阅读 多人点赞 2019-12-18 10:09:56
    基础知识 并发理论 并发关键字 Lock体系 并发容器 线程池 原子操作类 并发工具 并发实践 数据结构与算法 数据结构 算法 排序算法 LeetCode 数据库 Oracle MySQL 数据库基础知识 数据类型 引擎 索引 三大范式 常用SQL...
  • map 是一个普通的 hashmap,是无序的,每次遍历 map 时都会有不同的顺序 go语言自带的 json 包序列化 map 转 json 字符串时,不完全是无序的,是保持一种特定的规则排序,并且不能改变,这种规则就是按照 key 的...
  • 最近在刷题的过程中,在使用HashMap进行文件排序遇到的小问题。 题目: 开发一个简单错误记录功能小模块,能够记录出错的代码所在的文件名称和行号。 处理: 1.记录最多8条错误记录,对相同的错误记录(即文件...
  • 针对答案遍历哈希表时产生疑惑,如果按照put存入哈希表的顺序排序的话,只需要找到第一个不为-1的value值就可以break跳出循环。 测试代码: public class test02 { public static void main(String[] args) { Map&...
  • 几种map的排序规则

    2017-06-14 16:42:00
    前几天在做理事会成员的时候遇到这个问题,需要根据职务的顺序,放入...最后打印整个TreeMap的时候发现还是有不按先进先出的规则排序,百度之后发现各个map的排序规则不一样,最后用LinkedHashMap解决了问题。 Hash...
  • LinkedHashMap 访问顺序方式遍历

    万次阅读 多人点赞 2019-03-07 22:15:08
    LinkedHashMap 支持两种遍历方式 LinkedHashMap是通过比HashMap多了一个双向链表实现的有序。 1.按照插入顺序遍历 2.按照访问顺序遍历 按照访问顺序遍历时,每次访问完map中的元素后,会将该元素置入map的最后...
  • package test; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util....import java.util.LinkedHashMap; import java.util.List; import java.util....
  • 图解LinkedHashMap原理

    2019-09-09 20:49:20
    LinkedHashMap继承于HashMap,如果对HashMap原理还不清楚的同学,请先看上一篇:图解HashMap原理 2 LinkedHashMap使用与实现 先来一张LinkedHashMap的结构图,不要虚,看完文章再来看这个图,就秒懂了,先混个面熟 ...
  • 在Java中也有排序表的结构,可以使用一个TreeMap,key为一个HashMap,HashMap存储题目中的key和value,TreeMap的value为操作时间戳,每访问一次或者修改一次就更新。如果超出容量设定了就移除时间戳最靠前的那一个。...
  • LinkedHashMap

    2018-05-23 00:04:08
    摘要: HashMap和双向链表合二为一即是LinkedHashMap。所谓LinkedHashMap,其落脚点在HashMap,因此更准确地说,它是一个将所有Entry节点链入一个双向链表的HashMap。由于LinkedHashMap是HashMap的子类,所以...
  • Java知识体系最强总结(2020版)

    千次阅读 多人点赞 2020-03-07 08:35:51
    序号 内容 链接地址 1 Java内存模型 https://blog.csdn.net/ThinkWon/article/details/102073578 2 重排序与数据依赖性 https://blog.csdn.net/ThinkWon/article/details/102073858 3 as-if-serial规则和happens-...
  • Java集合面试题

    万次阅读 多人点赞 2019-06-25 14:46:19
    LinkedHashMapLinkedHashMap 继承自 HashMap,所以它的底层仍然是基于拉链式散列结构即由数组和链表或红黑树组成。另外,LinkedHashMap 在上面结构的基础上,增加了一条双向链表,使得上面的结构可以保持键值对的...
  • HashMap排序

    千次阅读 2018-09-16 04:22:14
    题: 已知一个HashMap&lt;Integer,User&gt;集合,User有username(String)和age(int)属性,请写一个方法实现对HashMap的排序功能,该方法...,要求对HashMap中的User的age进行倒序排序排序时key=valu...
  • Java集合详解5:深入理解LinkedHashMap和LRU缓存

    万次阅读 多人点赞 2018-05-12 12:06:31
    今天我们来深入探索一下LinkedHashMap的底层原理,并且使用linkedhashmap来实现LRU缓存。 具体代码在我的GitHub中可以找到 https://github.com/h2pl/MyTech 文章首发于我的个人博客: ...更多关于Java后端学习的...
  • 1 LinkedHashMap概述 2 LinkedHashMap 源码定义 2.1 类结构定义 2.2成员变量定义 2.3 成员方法定义 2.4 基本元素 Entry 3 LinkedHashMap的方法 3.1 LinkedHashMap的构造方法 3.2 初始化方法init方法 3.3 ...
  • 今天学习了使用LinkedHashMap来实现LRU算法,具体的关于LinkedHashMap的深入了解可以查看:Java集合详解5:深入理解LinkedHashMap和LRU缓存这篇文章,在介绍accessOrder属性的时候说accessOrder设置为false时,按照...
  • LinkedHashMap源码查看

    2021-01-18 17:04:08
    LinkedHashMap是基层HashMap的一个子类,所以很多方法都是用的HashMap的方法,尚未了结HashMap的同学可以去看下我的上一篇博客,在本篇博客中涉及到HashMap的源码方法就不不粘贴了,同样本篇会讲解下java7....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,783
精华内容 4,313
关键字:

linkedhashmap排序规则