提出问题

项目中一些不为人知却好用的集合map有哪些???

解决问题

双向map：DualHashBidiMap

DualHashBidiMap可以通过key找到value，也可以通过value找到key

  1. @Test
  2. public void testDualHashBidiMap(){
  3.    //双向map
  4.    BidiMap bidiMap = new DualHashBidiMap();
  5.    bidiMap.put("Ay", "Boy");
  6.    bidiMap.put("Al", "Girl");
  7.    System.out.println("Key-Value:Ay = " + bidiMap.get("Ay"));//Key-Value:Ay = Boy
  8.    System.out.println("Value-Key:Gril = " + bidiMap.getKey("Girl"));//Value-Key:Gril = Al
  9. }

一对多map：MultiMap

MultiMap：一个key不在是简单的指向一个对象，而是一组对象

  1. @Test
  2. public void testMultiMap(){
  3.    //MultiHashMap已经废弃
  4.    MultiMap giftMap = new MultiHashMap();
  5.    giftMap.put("gift", "鲜花");
  6.    giftMap.put("gift", "戒指");
  7.    giftMap.put("gift", "伞");
  8.    List list = (List) giftMap.get("gift");
  9.    System.out.println(list);//[鲜花, 戒指, 伞]
  10.    MultiMap giftMap2 = new MultiValueMap();
  11.    giftMap2.put("gift", "鲜花");
  12.    giftMap2.put("gift", "戒指");
  13.    giftMap2.put("gift", "伞");
  14.    giftMap2.put("boy","ay");
  15.    giftMap2.put("girl","al");
  16.    List list2 = (List) giftMap2.get("gift");
  17.    List list3 = (List)giftMap2.get("boy");
  18.    System.out.println(list2);//[鲜花, 戒指, 伞]
  19.    System.out.println(list3);//[ay]
  20. }

固定大小map：LRUMap

LRUMap：大小固定。它不是同步的，也不是线程安全的,新增的元素个数大于允许的最大集合个数时，则会执行LRU淘汰算法。 所有的元素在LRUMap中会根据最近使用情况进行排序。最近使用的会放在元素的最前面(LRUMap是通过链表来存储元素内容). 所以LRUMap进行淘汰时只需要删除链表最后一个即可（即header.after所指的元素对象）

影响元素的使用情况的操作：

1.put 当新增加一个集合元素对象，则表示该对象是最近被访问的
2.get 操作会把当前访问的元素对象作为最近被访问的，会被移到链接表头
注：当执行containsKey和containsValue操作时，不会影响元素的访问情况。

  1. @Test
  2. public void testLRUMap(){
  3.    LRUMap lruMap = new LRUMap(2);
  4.    //因为LRUMap是非线程安全，所以可以使用
  5.    // Collections.synchronizedMap(map)来保证线程安全
  6.    Map map = Collections.synchronizedMap(lruMap);
  7.    lruMap.put("boy", "ay");
  8.    lruMap.put("girl", "al");
  9.    lruMap.get("boy");//最近使用
  10.    lruMap.put("person", "person");
  11.    System.out.println(lruMap);//{boy=ay, person=person}
  12. }

多个关键字经过组合映射map：MultiKeyedMap

根据API文档，MultiKeyedMap可以通过下面方式进行什么：

//创建一个排序的map
- MultiKeyMap.decorate(new LinkedMap()) creates an ordered map.
- MultiKeyMap.decorate(new LRUMap()) creates an least recently used map.
- MultiKeyMap.decorate(new ReferenceMap()) creates a garbage collector sensitive map.

  1. @Test
  2.    public void testMultiKeyMap(){
  3.        //初始化类
  4.        MultiKeyMap multiKeyMap = MultiKeyMap.decorate(new LinkedMap());
  5.        multiKeyMap.put(1,1,2,"112");
  6.        multiKeyMap.put(1,1,3,"113");
  7.        multiKeyMap.put(1,2,1,"121");
  8.        multiKeyMap.put(1,2,2,"122");
  9.        multiKeyMap.put(1,3,1,"131");
  10.        //查找一个值:由1，1，2这3个key可以获得唯一的value值
  11.        String value = (String)multiKeyMap.get(1,1,2);
  12.        System.out.println("value is : " + value);//value is : 112
  13.        String value3 = (String)multiKeyMap.get(2,1,1);
  14.        System.out.println("value3 is : " + value3);//value3 is : null
  15.        String value2 = (String)multiKeyMap.get(1,2,1);
  16.        System.out.println("value2 is " + value2);//value2 is 121
  17.        Object object1 = multiKeyMap.get(1);
  18.        System.out.println("object1 is : " + object1);//object1 is : null
  19.        Object object2 = multiKeyMap.get(1,2);
  20.        System.out.println("object2 is : " + object2);//object2 is : null
  21.    }

允许Key重复的Map：IdentityHashMap

IdentityHashMap允许地址不同但内容相等作为key值，换句话说，在 IdentityHashMap 中，当且仅当 (k1==k2) 时，才认为两个键 k1 和 k2 相等。具体例子如下：

  1. @Test
  2. public void testIdentityMap(){
  3.    class Boy{
  4.        private int id;
  5.        private String name;
  6.        public Boy(int id, String name) {
  7.            this.id = id;
  8.            this.name = name;
  9.        }
  10.        public int getId() {
  11.            return id;
  12.        }
  13.        public void setId(int id) {
  14.            this.id = id;
  15.        }
  16.        public String getName() {
  17.            return name;
  18.        }
  19.        public void setName(String name) {
  20.            this.name = name;
  21.        }
  22.        @Override
  23.        public String toString() {
  24.            return "Boy{" +
  25.                    "id=" + id +
  26.                    ", name='" + name + '\'' +
  27.                    '}';
  28.        }
  29.        @Override
  30.        public boolean equals(Object o) {
  31.            if (this == o) return true;
  32.            if (o == null || getClass() != o.getClass()) return false;
  33.            Boy boy = (Boy) o;
  34.            if (id != boy.id) return false;
  35.            return name != null ? name.equals(boy.name) : boy.name == null;
  36.        }
  37.        @Override
  38.        public int hashCode() {
  39.            int result = id;
  40.            result = 31 * result + (name != null ? name.hashCode() : 0);
  41.            return result;
  42.        }
  43.    }
  44.    //初始化
  45.    IdentityMap identityMap = new IdentityMap();
  46.    //key是相同的boy对象，内存地址不同，但是内容相同
  47.    identityMap.put(new Boy(1,"ay"),"ay");
  48.    identityMap.put(new Boy(1,"ay"),"al");
  49.    System.out.println(identityMap);//{Boy{id=1, name='ay'}=al, Boy{id=1, name='ay'}=ay}
  50.    //初始化正常map
  51.    Map map = new HashedMap();
  52.    //因为我们有重写hashCode方法和toString方法
  53.    map.put(new Boy(1,"ay"),"ay");
  54.    map.put(new Boy(1,"ay"),"al");
  55.    System.out.println(map);//{Boy{id=1, name='ay'}=al}
  56. }

线程安全的map：ConcurrentMap

ConcurrentMap，是线程安全的。更多的例子可以百度。

参考文章
【1】Apache commons 之 Collections ：Map

【2】LRUMAP 原理解析

【3】org.apache.commons.collections.map.LRUMap 在cache中的使用

【4】在线文档

【5】Thinking in Java（Java编程思想）

【6】java 利用Map做缓存一个简单实例

【7】MultiKeyedMap方案的实现

【8】valuelist的应用实践之二: 实现多键值的map

【9】允许Key重复的Map - IdentityHashMap
————————————————
版权声明：本文为CSDN博主「阿_毅」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/huangwenyi1010/article/details/53750269