允许key重复的map

在使用map的时候，大家肯定会想到key-value，key用于检索value的内容。在正常情况下，可以不允许重复；但是其实重复在java中分为2中情况，一是内存地址重复，另一个是不同的地址但内容相等，而IdentityHashMap用于后者，即内容相等。更详细的解释如下：此类利用哈希表实现 Map 接口，比较键（和值）时使用引用相等性代替对象相等性。换句话说，在 IdentityHashMap 中，当且仅当 (k1==k2) 时，才认为两个键 k1 和 k2 相等（在正常 Map 实现（如 HashMap）中，当且仅当满足下列条件时才认为两个键 k1 和 k2 相等：(k1==null ? k2==null : e1.equals(e2))）。

此类不是通用 Map 实现！此类实现 Map 接口时，它有意违反 Map 的常规协定，该协定在比较对象时强制使用 equals 方法。此类设计仅用于其中需要引用相等性语义的罕见情况。

例如：

class Person{
private String name ;
private int age ;
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
public boolean equals(Object obj){
if(this==obj){
return true ;
}
if(!(obj instanceof Person)){
return false ;
}
Person p = (Person)obj ;
if(this.name.equals(p.name)&&this.age==p.age){
return true ;
}else{
return false ;
}
}
public int hashCode(){
return this.name.hashCode() * this.age ;
}
public String toString(){
return "姓名：" + this.name + "，年龄：" + this.age ;
}
};

HashMap情况：

public class IdentityHashMapDemo01{
public static void main(String args[]){
Map<Person,String> map = null ; // 声明Map对象
map = new HashMap<Person,String>() ;
map.put(new Person("张三",30),"zhangsan_1") ; // 加入内容
map.put(new Person("张三",30),"zhangsan_2") ; // 加入内容
map.put(new Person("李四",31),"lisi") ; // 加入内容
Set<Map.Entry<Person,String>> allSet = null ; // 准备使用Set接收全部内容
allSet = map.entrySet() ;
Iterator<Map.Entry<Person,String>> iter = null ;
iter = allSet.iterator() ;
while(iter.hasNext()){
Map.Entry<Person,String> me = iter.next() ;
System.out.println(me.getKey() + " --> " + me.getValue()) ;
}
}
};

结果：相同的key内容，value会被覆盖

姓名：李四，年龄：31 --> lisi
姓名：张三，年龄：30 --> zhangsan_2

IdentityHashMap情况

public class IdentityHashMapDemo02{
public static void main(String args[]){
Map<Person,String> map = null ; // 声明Map对象
map = new IdentityHashMap<Person,String>() ;
map.put(new Person("张三",30),"zhangsan_1") ; // 加入内容
map.put(new Person("张三",30),"zhangsan_2") ; // 加入内容
map.put(new Person("李四",31),"lisi") ; // 加入内容
Set<Map.Entry<Person,String>> allSet = null ; // 准备使用Set接收全部内容
allSet = map.entrySet() ;
Iterator<Map.Entry<Person,String>> iter = null ;
iter = allSet.iterator() ;
while(iter.hasNext()){
Map.Entry<Person,String> me = iter.next() ;
System.out.println(me.getKey() + " --> " + me.getValue()) ;
}
}
};

结果：相同的key内容(由于是new出来的，内存地址不同但内容相同)，但value不会被覆盖

姓名：张三，年龄：30 --> zhangsan_2
姓名：张三，年龄：30 --> zhangsan_1
姓名：李四，年龄：31 --> lisi

本文转自 zhouhaipeng 51CTO博客，原文链接：http://blog.51cto.com/tianya23/707603，如需转载请自行联系原作者

步骤：从数据库读取数据，在ztree下拉树初始化勾选节点时勾选的节点一直不完整。开始以为是ztree初始化出的问题，原来在存放map键值对的时候存放了重复的key,导致存放的key不完整。key和value互换位置解决问题。

代码如下：

/**
	 * 根据角色初始勾选菜单
	 * @param request
	 * @param response
	 */
	@RequestMapping("v_initMenu.aspx")
	public void initCheckedMenu(HttpServletRequest request , HttpServletResponse response){
		String jsonStr = "{\"result\":1}";
		String id=request.getParameter("roleId");
		List<TbAllianceRoleMenu> list = roleMenuService.findByRoleId(id);
		Map<String, String> map = new HashMap<String, String>();
		if(list != null){
			for (TbAllianceRoleMenu tbAllianceRoleMenu : list) {
				TbAllianceMenu menu = tbAllianceRoleMenu.getMenu();
				//String type = menu.getMenuType();
				//if(type != null && type.equals("btn")){
					map.put(menu.getId(), menu.getName());
				//}
			}
		}
		try {
			JSONArray json1 = JSONArray.fromObject(map);
			jsonStr = json1.toString();
			ResponseUtils.renderJson(response, jsonStr);
		} catch (Exception e) {
			log.error("initMenu", e);
            ResponseUtils.renderJson(response, jsonStr);
		}
	}

范例：Map中的key不允许重复，重复就是覆盖

[java]view plaincopy 
   
 package org.lxh.demo13.mapdemo;    
 import java.util.HashMap;    
 import java.util.Iterator;    
 import java.util.Map;    
 import java.util.Set;    
 class Person {                                
 // 定义Person类    
     private String name;                     
 // 定义name属性    
     private int age;                          
 // 定义age属性    
     public Person(String name, int age) {     
 // 通过构造方法为属性赋值    
         this.name = name;                     
 // 为name属性赋值    
         this.age = age;                       
 // 为age属性赋值    
     }    
     public boolean equals(Object obj) {      
 // 覆写equals()方法    
         if (this == obj) {                    
 // 判断地址是否相等    
             return true;                      
 // 返回true表示同一对象    
         }    
         if (!(obj instanceof Person)) {       
 // 传递进来的不是本类的对象    
             return false;                     
 // 返回false表示不是同一对象    
         }    
         Person p = (Person) obj;              
 // 进行向下转型    
         if (this.name.equals(p.name) &&  
 this.age == p.age) {    
             return true ;                     
 // 属性依次比较，相等返回true    
         }else{    
             return false ;                    
 // 属性内容不相等，返回false    
         }    
     }    
     public int hashCode(){                      
 // 覆写hashCode()方法    
         return this.name.hashCode() * this.age ;    
 // 计算公式    
     }    
     public String toString() {                      
 // 覆写toString()方法    
         return "姓名：" + this.name + "；年龄："   
 + this.age;   // 返回信息    
     }    
 }     
 public class IdentityHashMapDemo01 {    
     public static void main(String[] args) {    
         Map<Person, String> map = null;              
 // 声明Map对象，指定    
 泛型类型    
         map = new HashMap<Person, String>();           
 // 实例化Map对象    
         map.put(new Person("张三", 30), "zhangsan_1");    
 // 增加内容    
         map.put(new Person("张三", 30), "zhangsan_2");     
 // 增加内容，key重复    
         map.put(new Person("李四", 31), "lisi");       
 // 增加内容    
         Set<Map.Entry<Person, String>> allSet = null;    
 // 声明一个Set集合    
         allSet = map.entrySet();                    
 // 将Map接口实例变为    
 Set接口实例    
         Iterator<Map.Entry<Person, String>>   
 iter = null;    // 声明Iterator    
 对象    
         iter = allSet.iterator();                
 // 实例化Iterator    
 对象    
         while (iter.hasNext()) {                 
 // 迭代输出    
             Map.Entry<Person, String> me =   
 iter.next();// 每个对象都是Map.     
 Entry实例    
             System.out.println(me.getKey()     
                     + " --> " + me.getValue());    
 // 输出key和value    
         }    
     }    
 }   

程序运行结果：

[java]view plaincopy 
   
 姓名：李四；年龄：31 --> lisi    
 姓名：张三；年龄：30 --> zhangsan_2   

从程序的运行结果中可以发现，第二个内容覆盖了第一个内容，所以此时可以使用Identity HashMap。使用此类时只要地址不相等（key1！=key2），就表示不是重复的key，可以添加到集合中。

范例：使用IdentityHashMap修改程序

[java]view plaincopy 
   
 package org.lxh.demo13.mapdemo;    
 import java.util.IdentityHashMap;    
 import java.util.Iterator;    
 import java.util.Map;    
 import java.util.Set;    
 class Person {    
     // 此类与之前定义一样，此处不再列出    
 }    
 public class IdentityHashMapDemo02 {    
     public static void main(String[] args) {    
         Map<Person, String> map = null;          
 // 声明Map对象，指定    
 泛型类型    
         map = new IdentityHashMap<Person, String>();   
 // 实例化Map对象    
         map.put(new Person("张三", 30), "zhangsan_1");   
 // 增加内容    
         map.put(new Person("张三", 30), "zhangsan_2");    
 // 增加内容，key重复    
         map.put(new Person("李四", 31), "lisi");      
 // 增加内容    
         Set<Map.Entry<Person, String>> allSet =   
 null;   // 声明一个Set集合    
         allSet = map.entrySet();                 
 // 将Map接口实例变为    
 Set接口实例    
         Iterator<Map.Entry<Person, String>>   
 iter = null;// 声明Iterator对象    
         iter = allSet.iterator();              
 // 实例化Iterator    
 对象    
         while (iter.hasNext()) {                 
 // 迭代输出    
             Map.Entry<Person, String> me =   
 iter.next();// 每个对象都是Map.    
 Entry实例    
             System.out.println(me.getKey()     
                     + " --> " + me.getValue());    
 // 输出key和value    
         }    
     }    
 }   

程序运行结果：

[java]view plaincopy 
   
 姓名：张三；年龄：30 --> zhangsan_2    
 姓名：张三；年龄：30 --> zhangsan_1    
 姓名：李四；年龄：31 --> lisi   

从程序的运行结果中可以发现，现在的key允许重复，只要两个对象的地址不相等即可。

package com.demo.jdk8.collectors;

import com.demo.jdk8.collectors.model.User;
import com.google.common.collect.Lists;
import org.junit.jupiter.api.Test;

import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * throw new IllegalStateException(String.format("Duplicate key %s", u));
 * 解决方法：调用三个参数的toMap重载方法，第三个参数为：BinaryOperator<U> mergeFunction
 *
 * @author Shanks
 * @date 2018-10-10
 */
public class ToMapTest {

    private static User user = new User(1, "Tom");
    private static User user1 = new User(2, "Jerry");
    private static User user2 = new User(3, "Rose");
    private static User user3 = new User(3, "Jack");
    private static List<User> list = Lists.newArrayList(user, user1, user2);
    private static List<User> listDuplicateKey = Lists.newArrayList(user, user1, user2, user3);

    @Test
    void testUniqueKey() {
        Map<Integer, String> map = list.stream()
                .collect(Collectors.toMap(User::getId, User::getName));
        map.forEach((k, v) -> System.out.println(k + "-->" + v));
    }

    /**
     * toMap默认方法有个参数：throwingMerger()，当key重复值，抛异常：
     * throw new IllegalStateException(String.format("Duplicate key %s", u));
     */
    @Test
    void testDuplicateKeyThrowException() {
        Map<Integer, String> map = listDuplicateKey.stream().collect(Collectors.toMap(User::getId, User::getName));
        map.forEach((k, v) -> System.out.println(k + ": " + v));
    }

    @Test
    void testDuplicateKey() {
        Map<Integer, String> map = listDuplicateKey.stream()
                .collect(Collectors.toMap(User::getId, User::getName, (oldValue, newValue) -> newValue));
        map.forEach((k, v) -> System.out.println(k + "-->" + v));
    }

    /**
     * Function.identity()获取List里面的泛型属性实体，此方式也是不允许出现重复key
     */
    @Test
    void testIdentityUniqueKey() {
        Map<Integer, User> map = list.stream().collect(Collectors.toMap(User::getId, Function.identity()));
        map.forEach((k, v) -> System.out.println(k + "-->" + v));
    }

    @Test
    void testIdentityDuplicateKey() {
        Map<Integer, User> map = listDuplicateKey.stream()
                .collect(Collectors.toMap(User::getId, Function.identity(), (oldValue, newValue) -> newValue));
        map.forEach((k, v) -> System.out.println(k + "-->" + v));
    }
}

再来一个小案例：

@Test
public void testToMap() {    
    Person p1 = new Person("kevin", 25);
    Person p2 = new Person("andy", 30);
    Person p3 = new Person("tony", 25);
    Person p4 = new Person("kevin", 20);
    Person p5 = new Person("kevin", 20);
    List<Person> list = new ArrayList<>();
    list.add(p1);
    list.add(p2);
    list.add(p3);
    list.add(p4);
    list.add(p5);
    System.out.println("----->Collectors.toMap，添加处理重复key的参数..");
    Map<String, Person> map = list.stream().collect(Collectors.toMap(person -> person.getName() + "_" + LocalDate.now(), person -> person, (oldValue, newValue) -> newValue));
    System.out.println(JSON.toJSONString(map));
}

打印结果：

----->Collectors.toMap，添加处理重复key的参数..
{"kevin_2019-01-15":{"age":20,"name":"kevin"},"tony_2019-01-15":{"age":25,"name":"tony"},"andy_2019-01-15":{"age":30,"name":"andy"}}

附录：

`Collectors.toMap`的重载方法：

public static <T, K, U>
Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper,
                                Function<? super T, ? extends U> valueMapper) {
    return toMap(keyMapper, valueMapper, throwingMerger(), HashMap::new);
}

public static <T, K, U>
Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper,
                                Function<? super T, ? extends U> valueMapper,
                                BinaryOperator<U> mergeFunction) {
    return toMap(keyMapper, valueMapper, mergeFunction, HashMap::new);
}

public static <T, K, U, M extends Map<K, U>>
Collector<T, ?, M> toMap(Function<? super T, ? extends K> keyMapper,
                            Function<? super T, ? extends U> valueMapper,
                            BinaryOperator<U> mergeFunction,
                            Supplier<M> mapSupplier) {
    BiConsumer<M, T> accumulator
            = (map, element) -> map.merge(keyMapper.apply(element),
                                          valueMapper.apply(element), mergeFunction);
    return new CollectorImpl<>(mapSupplier, accumulator, mapMerger(mergeFunction), CH_ID);
}