转载自:http://blog.csdn.net/u010648555
看似是一个简单的问题，其实里面包含很多的东西！
需求：
实现一个在HashMap中存入（任意类型）相同的key值后，key中的value不会被覆盖，而是能够进行叠加！
拿到一个需求的时候，我们要先进行分析，看此需求能否实现，基于已有的知识（经验），然后在通过目前的一些技术看此需求如何实现。
要实现在HashMap中插入相同的key值，内容不被覆盖，那么肯定要了解HashMap的一些机制，首先看一下HashMap的put方法：
从JDK API中看到HashMap的put如何先前存储了一个key（键），在指定相同的key（键）的时候，会用新的值替换旧的值。
如下的代码示例：
public static void main(String[] args) {
Map<String, Object> map = new HashMap<>();
map.put("aflyun", "Java编程技术乐园");
map.put("aflyun", "生活在长沙的延安人");
System.out.println(map.toString());
}
--打印：--
{aflyun=生活在长沙的延安人}
1
2
3
4
5
6
7
8
9
10
11
通过上面的示例分析：为什么存入相同的key后，旧值就被新值替换了呢？
要想知道具体原因，那只能去看HashMap的源码实现了。看一下
put(K key, V value)
方法了，本篇HashMap源码是
JDK1.8
版本！
/**
* HashMap 的put方法
**/
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* HashMap 的containsKey方法
**/
public boolean containsKey(Object key) {
return getNode(hash(key), key) != null;
}
/**
* 将存入的key进行hash操作，也就是使用key.hashCode()！
**/
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
判断put和判断key是否是同一个key的时候，使用大概如下判断逻辑：
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
1
先判断Hash是否一致，然后在判断传入key和当前集合中是否有相同的key。如果key相同，则新值替换旧值。其中在判断中使用了
==
equals
==
和
equals
的区别有时候面试会问到，如何你知道这两个的区别不仅看源码能够很好的理解，并且遇到面试也不怕了。
tips：简述
==
和
equals
的区别>
1）对于==，如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；如果作用于引用类型的变量，则比较的是所指向的对象的地址！
2）对于equals方法，注意：equals方法不能作用于基本数据类型的变量。如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；诸如String等类对equals方法进行了重写的话，比较的是所指向的对象的内容。
有了上面的分析基础，那针对上面String类型的key的话，那实现起来就比较简单了！因为String中已经实现了
HashCode
和
equals
代码如下：
自定义HashMap
public class MyHashMap<K> extends HashMap<K,String> {
/**
* 使用HashMap中containsKey判断key是否已经存在
* @param key
* @param value
* @return
*/
@Override
public String put(K key, String value) {
String newV = value;
if (containsKey(key)) {
String oldV = get(key);
newV = oldV + "---" + newV;
}
return super.put(key, newV);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
String类型key的进行put操作
public static void main(String[] args) {
MyHashMap<String> map = new MyHashMap<String>();
map.put("aflyun", "Java编程技术乐园");
map.put("aflyun", "生活在长沙的延安人");
map.put("aflyun", "期待你加入乐园");
System.out.println(map.toString());
}
--打印：---
{aflyun=Java编程技术乐园---生活在长沙的延安人---期待你加入乐园}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
此时同样的key内容是进行叠加的，不是进行替换！那如何是自定义的类，要当作key，那要怎么做呢？
其实也就是重写了hashCode和equals就可以了。
public class PrettyGirl {
/**
* 姑娘唯一认证ID
*/
private String id;
/**
* 姑娘姓字名谁
*/
private String name;
@Override
public boolean equals(Object o) {
if (this == o) {return true;}
if (o == null || getClass() != o.getClass()) {return false;}
PrettyGirl that = (PrettyGirl) o;
return Objects.equals(id, that.id) &&
Objects.equals(name, that.name);
}
@Override
public int hashCode() {
return Objects.hash(id, name);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
自定义类型当做key的进行put操作
public static void main(String[] args) {
PrettyGirl prettyGirl = new PrettyGirl();
Map<PrettyGirl,String> map = new HashMap<>();
map.put(prettyGirl, "Java编程技术乐园");
map.put(prettyGirl, "生活在长沙的延安人");
map.put(prettyGirl, "期待和你加入乐园");
System.out.println("map :" + map.toString());
MyHashMap<PrettyGirl> myMap = new MyHashMap<PrettyGirl>();
myMap.put(prettyGirl, "Java编程技术乐园");
myMap.put(prettyGirl, "生活在长沙的延安人");
myMap.put(prettyGirl, "期待和你加入乐园");
System.out.println("myMap :" + myMap.toString());
}
--打印：---
map :{com.happy.PrettyGirl@3c1=期待和你加入乐园}
myMap :{com.happy.PrettyGirl@3c1=Java编程技术乐园---生活在长沙的延安人---期待和你加入乐园}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
总结：要实现开头的需求
1、如果是类似String这种，已经重写了hashCode和equals的。则只需要创建一个自己的HashMap类，重写put即可。
2、如果是自定义的类，那就必须重写了hashCode和equals的，然后在使用自定义的HashMap类了。
具体的代码判断逻辑：
判断key是否存在的时候是先比较key的hashCode，再比较相等或equals的，所以重写hashCode()和equals()方法即可实现添加重复元素。重写这两个方法之后就可以覆盖重复的键值对，如果需要对value进行叠加，调用put()方法之前用containsKey()方法判断是否有重复的键值，如果有，则用get()方法获取原有的value，再加上新加入的value即可。
本文涉及的相关知识：
1、HashMap相关源码
2、== 、equals和 hashCode
3、Hash算法
网友评论