一、前言
日常中使用的HashSet或者HashMap，一般都用String作为key值，这洽洽不能体现这两个集合类的数据结构和特征，另外说的hash碰撞时展示出来的hash桶，也压根不会出现，本文就用简单示例描述。
二、准备工作
1、定义一个接口Shape表示形状
public interface Shape extends Serializable {
Float getArea();
}
2、定义一个抽象类，表示长方形（包括长方形状 正方形 或者类似a*b方式求面积）
@Data
public abstract class AbstractRectangle implements Shape{
private String name;
private Float length;
private Float width;
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
AbstractRectangle that = (AbstractRectangle) o;
if (!name.equals(that.name)) return false;
if (!length.equals(that.length)) return false;
return width.equals(that.width);
}
@Override
public int hashCode() {
int result = name.hashCode();
result = 31 * result + length.hashCode();
result = 31 * result + width.hashCode();
return result;
}
@Override
public String toString() {
return "AbstractRectangle{" +
"name='" + name + '\'' +
", length=" + length +
", width=" + width +
'}';
}
}
3、定义一个标准长方形
注意！！！故意修改其hashcode方法为其面积值，这样容易造例子成hashcode冲突
public class Rectangle extends AbstractRectangle{
public Rectangle() {
}
@Override
public Float getArea() {
return this.getLength()*this.getWidth();
}
/**
* 故意重写hashCode 直接用面积代替标准的31倍乘散列方式
* @return
*/
@Override
public int hashCode() {
System.out.println(this.toString());
return this.getArea().hashCode();
}
@Override
public String toString() {
return "Rectangle{" +
"name='" + super.getName() + '\'' +
", length=" + super.getLength() +
", width=" + super.getWidth() +
'}';
}
}
4、定义一个建造者builder（顺便复习下设计模式）
public class RectangleBuilder {
private Rectangle rectangle=new Rectangle();
public static RectangleBuilder getBuilder(){
return new RectangleBuilder();
}
public Rectangle build(){
return rectangle;
}
public RectangleBuilder setName(String name){
rectangle.setName(name);
return this;
}
public RectangleBuilder setLength(Float length){
rectangle.setLength(length);
return this;
}
public RectangleBuilder setWidth(Float width){
rectangle.setWidth(width);
return this;
}
}
三、开始测试
1、HashSet测试
@Test
public void testHashSet(){
Rectangle r1=RectangleBuilder.getBuilder().setName("a").setLength(10f).setWidth(5f).build();
Rectangle r2=RectangleBuilder.getBuilder().setName("a").setLength(5f).setWidth(10f).build();
Rectangle r3=RectangleBuilder.getBuilder().setName("a").setLength(5f).setWidth(10f).build();
Set<Rectangle> rectangleSet=new HashSet<>();
rectangleSet.add(r1);
rectangleSet.add(r2);
rectangleSet.add(r3);
System.out.println("rectangleSet"+rectangleSet);
System.out.println(r2==r3);
System.out.println(r1.getArea().hashCode());
}
输出
Rectangle{name='a', length=10.0, width=5.0}
Rectangle{name='a', length=5.0, width=10.0}
Rectangle{name='a', length=5.0, width=10.0}
rectangleSet[Rectangle{name='a', length=10.0, width=5.0}, Rectangle{name='a', length=5.0, width=10.0}]
false
1112014848
解析：r1 r2 r3的hashcode均一样（就是面积一样均为50f ），除此之外r2和r3的equals也一样，但是从构造器的代码看，r1 r2 r3的地址肯定多是不一样的。
我们看到，最终set塞进了两个值，一个是r1，一个是r3。
过程是这样，初始Set内没有值，首次顺利插入r1，在Float.floatToIntBits（50f）=1112014848 的位置。
接着设置r2，检查hashcode，发现和r1一样，则继续检查equals，发现两者不一样（长宽顺序相反），此时，同样在1112014848 的位置，插入r2，（具体就是链表方式在r1值的尾部设置r2的值），此时1112014848 hashcode的位置 就表现为放了两个对象，他们的值（equals）不一样。
最后，设置r3，发现r3的hashcode和r1 r2都一样，接着检查equals，发现和r2一样，则把r2位置的值（指向）替换为r3，而r1则不变。
最终表现为图示的结果了。
2、HashMap测试
@Test
public void testHashMap(){
Rectangle r1=RectangleBuilder.getBuilder().setName("a").setLength(10f).setWidth(5f).build();
Rectangle r2=RectangleBuilder.getBuilder().setName("a").setLength(5f).setWidth(10f).build();
Rectangle r3=RectangleBuilder.getBuilder().setName("a").setLength(5f).setWidth(10f).build();
Map<Rectangle,String> rectangleMap=new HashMap<>();
rectangleMap.put(r1,"元素1");
rectangleMap.put(r2,"元素2");
rectangleMap.put(r3,"元素3");
System.out.println("rectangleMap"+rectangleMap);
}
输出
Rectangle{name='a', length=10.0, width=5.0}
Rectangle{name='a', length=5.0, width=10.0}
Rectangle{name='a', length=5.0, width=10.0}
rectangleMap{Rectangle{name='a', length=10.0, width=5.0}=元素1, Rectangle{name='a', length=5.0, width=10.0}=元素3}
key值的设置原理和HashSet一样
引申
如果用List做key呢(当然平时肯定不这样用)
@Test
public void testHashMapListKey(){
Rectangle r1=RectangleBuilder.getBuilder().setName("a").setLength(10f).setWidth(5f).build();
Rectangle r2=RectangleBuilder.getBuilder().setName("a").setLength(5f).setWidth(10f).build();
Rectangle r3=RectangleBuilder.getBuilder().setName("a").setLength(5f).setWidth(10f).build();
Map<List<Rectangle>,String> rectangleMap=new HashMap<>();
rectangleMap.put(Lists.newArrayList(r1,r2),"元素1");
rectangleMap.put(Lists.newArrayList(r2,r1),"元素2");
rectangleMap.put(Lists.newArrayList(r1,r3),"元素2");
System.out.println("rectangleMap"+rectangleMap);
}
输出
Rectangle{name='a', length=10.0, width=5.0}
Rectangle{name='a', length=5.0, width=10.0}
Rectangle{name='a', length=5.0, width=10.0}
Rectangle{name='a', length=10.0, width=5.0}
Rectangle{name='a', length=10.0, width=5.0}
Rectangle{name='a', length=5.0, width=10.0}
rectangleMap{[Rectangle{name='a', length=10.0, width=5.0}, Rectangle{name='a', length=5.0, width=10.0}]=元素2, [Rectangle{name='a', length=5.0, width=10.0}, Rectangle{name='a', length=10.0, width=5.0}]=元素2}
发现并没有输出元素1，
我们可以顺道去看下ArrayList的hashcode方法
public int hashCode() {
int hashCode = 1;
for (E e : this)
hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
return hashCode;
}
再看下它的equals方法
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof List))
return false;
ListIterator<E> e1 = listIterator();
ListIterator<?> e2 = ((List<?>) o).listIterator();
while (e1.hasNext() && e2.hasNext()) {
E o1 = e1.next();
Object o2 = e2.next();
if (!(o1==null ? o2==null : o1.equals(o2)))
return false;
}
return !(e1.hasNext() || e2.hasNext());
}
不难猜想就是把各个元素的hashcode再进行一次hash散列，而上面的例子，元素1的key值和元素3的key值，两者的hashcode是一样的，不仅如此，他们的equals也一样
rectangleMap.put(Lists.newArrayList(r1,r2),"元素1");//顺利插入元素1
rectangleMap.put(Lists.newArrayList(r2,r1),"元素2");// 顺利插入元素2
// 这个key值检查 ，和元素1一样，进行equal判断，又一样，则直接替换元素1
rectangleMap.put(Lists.newArrayList(r1,r3),"元素2");
``
最终展示为同一个hash桶里放置了两个值为元素2的对象（当然地址肯定不一样）。
debug源码也容易验证结论。
