大杂烩 -- equals、hashCode联系与区别
基础大杂烩 -- 目录
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
Equals
1、默认情况（没有覆盖equals方法）下equals方法都是调用Object类的equals方法，而Object的equals方法主要用于判断对象的内存地址引用是不是同一个地址（是不是同一个对象）。
public boolean equals(Object obj) { return (this == obj); }
2 、如果类中覆盖了equals方法，那么就要根据具体的代码来确定equals方法的作用了，覆盖后一般都是通过对象的内容是否相等来判断对象是否相等。
@Override public boolean equals(Object obj) { // 1.地址相等 if (this == obj) return true; // 2.不为空 if (obj == null) return false; // 3.类型相同 if (getClass() != obj.getClass()) return false; StudentOverrideEquals other = (StudentOverrideEquals) obj; // 4.属性相等 if (age != other.age) // 4.1基本数据类型判断值 return false; // 4.2引用数据类型。1.空值判断，2.非空调用自身equals() if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; }
HashCode
1.默认情况（没有覆盖hashCode方法）下hashCode方法都是调用Object类的hashCode方法，而Object的hashCode方法的返回值的默认实现是根据对象的内存地址进行计算。
public native int hashCode();
2.如果类中覆盖了hashCode方法，那么就要根据具体的代码来确定hashCode方法的返回值，覆盖后一般都是通过对象的属性计算hashCode值。
@Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; }
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
不覆写equals、不覆写hashCode（Tt02）
覆写equals、不覆写hashCode（Tt03）
不覆写equals、 覆写hashCode（Tt04）
覆写equals、 覆写hashCode（Tt05）
覆写equals、 覆写hashCode（返回值不同）（Tt06）
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
Tt02：不覆写equals、不覆写hashCode
Class ： Student
package limeMianShi.duolaidian.equals_hashcode; /** * 没有覆盖equals、hashCode方法 * * @author lime * */ public class Student { private String name; private int age; public Student() { super(); } public Student(String name, int age) { super(); this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }
Class : main
package limeMianShi.duolaidian.equals_hashcode; import java.util.HashSet; import java.util.LinkedList; import java.util.List; import java.util.Set; /** * 没有覆盖equals、hashCode方法 * * @author lime * */ public class Test02 { public static void main(String[] args) { List<Student> list = new LinkedList<Student>(); Set<Student> set = new HashSet<Student>(); Student stu1 = new Student("lime",25); Student stu2 = new Student("lime", 25); System.out.println("stu1 == stu2 : "+(stu1 == stu2)); System.out.println("stu1.equals(stu2) : "+stu1.equals(stu2)); System.out.println("stu1-->HashCode:" + stu1.hashCode()); System.out.println("stu2-->HashCode:" + stu2.hashCode()); list.add(stu1); list.add(stu2); System.out.println("list size:"+ list.size()); set.add(stu1); set.add(stu2); System.out.println("set size:"+ set.size()); } }
Console :
stu1 == stu2 : false stu1.equals(stu2) : false stu1-->HashCode:1865127310 stu2-->HashCode:515132998 list size:2 set size:2
Tt03：覆写equals、不覆写hashCode
Class ： StudentOverrideEquals
package limeMianShi.duolaidian.equals_hashcode; /** * 覆写equals方法 * * @author lime * */ public class StudentOverrideEquals { private String name; private int age; public StudentOverrideEquals() { super(); } public StudentOverrideEquals(String name, int age) { super(); this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public boolean equals(Object obj) { // 1.地址相等 if (this == obj) return true; // 2.不为空 if (obj == null) return false; // 3.类型相同 if (getClass() != obj.getClass()) return false; StudentOverrideEquals other = (StudentOverrideEquals) obj; // 4.属性相等 if (age != other.age) // 4.1基本数据类型判断值 return false; // 4.2引用数据类型。1.空值判断，2.非空调用自身equals() if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } }
Class ： main
package limeMianShi.duolaidian.equals_hashcode; import java.util.HashSet; import java.util.LinkedList; import java.util.List; import java.util.Set; /** * 覆写equals方法 * * @author lime * */ public class Test03 { public static void main(String[] args) { List<StudentOverrideEquals> list = new LinkedList<StudentOverrideEquals>(); Set<StudentOverrideEquals> set = new HashSet<StudentOverrideEquals>(); StudentOverrideEquals stu1 = new StudentOverrideEquals("lime",25); StudentOverrideEquals stu2 = new StudentOverrideEquals("lime", 25); System.out.println("stu1 == stu2 : "+(stu1 == stu2)); System.out.println("stu1.equals(stu2) : "+stu1.equals(stu2)); System.out.println("stu1-->HashCode:" + stu1.hashCode()); System.out.println("stu2-->HashCode:" + stu2.hashCode()); list.add(stu1); list.add(stu2); System.out.println("list size:"+ list.size()); set.add(stu1); set.add(stu2); System.out.println("set size:"+ set.size()); } }
Console ：
stu1 == stu2 : false stu1.equals(stu2) : true stu1-->HashCode:1865127310 stu2-->HashCode:515132998 list size:2 set size:2
Tt04：不覆写equals、覆写hashCode
Class ： StudentOverrideHashCode
package limeMianShi.duolaidian.equals_hashcode; /** * 覆盖hashCode方法 * * @author lime * */ public class StudentOverrideHashCode { private String name; private int age; public StudentOverrideHashCode(String name, int age) { super(); this.name = name; this.age = age; } public StudentOverrideHashCode() { super(); } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } }
Class ： main
package limeMianShi.duolaidian.equals_hashcode; import java.util.HashSet; import java.util.LinkedList; import java.util.List; import java.util.Set; /** * 覆写hashCode方法 * * @author lime * */ public class Test04 { public static void main(String[] args) { List<StudentOverrideHashCode> list = new LinkedList<StudentOverrideHashCode>(); Set<StudentOverrideHashCode> set = new HashSet<StudentOverrideHashCode>(); StudentOverrideHashCode stu1 = new StudentOverrideHashCode("lime",25); StudentOverrideHashCode stu2 = new StudentOverrideHashCode("lime", 25); System.out.println("stu1 == stu2 : "+(stu1 == stu2)); System.out.println("stu1.equals(stu2) : "+stu1.equals(stu2)); System.out.println("stu1-->HashCode:" + stu1.hashCode()); System.out.println("stu2-->HashCode:" + stu2.hashCode()); list.add(stu1); list.add(stu2); System.out.println("list size:"+ list.size()); set.add(stu1); set.add(stu2); System.out.println("set size:"+ set.size()); } }
Console ：
stu1 == stu2 : false stu1.equals(stu2) : false stu1-->HashCode:3323549 stu2-->HashCode:3323549 list size:2 set size:2
Tt05：覆写equals、覆写hashCode
Class : StudentOverrideEqualsHashCode
package limeMianShi.duolaidian.equals_hashcode; /** * 覆盖equals 和 hashCode方法 * * @author lime * */ public class StudentOverrideEqualsHashCode { private String name; private int age; public StudentOverrideEqualsHashCode(String name, int age) { super(); this.name = name; this.age = age; } public StudentOverrideEqualsHashCode() { super(); } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; StudentOverrideEqualsHashCode other = (StudentOverrideEqualsHashCode) obj; if (age != other.age) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } }
Class : main
package limeMianShi.duolaidian.equals_hashcode; import java.util.HashSet; import java.util.LinkedList; import java.util.List; import java.util.Set; /** * 覆写equals、hashCode方法 * * @author lime * */ public class Test05 { public static void main(String[] args) { List<StudentOverrideEqualsHashCode> list = new LinkedList<StudentOverrideEqualsHashCode>(); Set<StudentOverrideEqualsHashCode> set = new HashSet<StudentOverrideEqualsHashCode>(); StudentOverrideEqualsHashCode stu1 = new StudentOverrideEqualsHashCode("lime",25); StudentOverrideEqualsHashCode stu2 = new StudentOverrideEqualsHashCode("lime", 25); System.out.println("stu1 == stu2 : "+(stu1 == stu2)); System.out.println("stu1.equals(stu2) : "+stu1.equals(stu2)); System.out.println("stu1-->HashCode:" + stu1.hashCode()); System.out.println("stu2-->HashCode:" + stu2.hashCode()); list.add(stu1); list.add(stu2); System.out.println("list size:"+ list.size()); set.add(stu1); set.add(stu2); System.out.println("set size:"+ set.size()); } }
Console :
stu1 == stu2 : false stu1.equals(stu2) : true stu1-->HashCode:3323549 stu2-->HashCode:3323549 list size:2 set size:1
Tt05：覆写equals、覆写hashCode（返回值不同）
Class ： StudentOverrideEqualsHashCodeneq
package limeMianShi.duolaidian.equals_hashcode; /** * equals 相等，hashCode不等 * * @author lime * */ public class StudentOverrideEqualsHashCodeneq { private String name; private int age; public StudentOverrideEqualsHashCodeneq(String name, int age) { super(); this.name = name; this.age = age; } public StudentOverrideEqualsHashCodeneq() { super(); } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public int hashCode() { return (int) (Math.random()*10); } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; StudentOverrideEqualsHashCodeneq other = (StudentOverrideEqualsHashCodeneq) obj; if (age != other.age) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } }
Class ： main
package limeMianShi.duolaidian.equals_hashcode; import java.util.HashSet; import java.util.LinkedList; import java.util.List; import java.util.Set; /** * 覆写equals、hashCode(返回值不同)方法 * * @author lime * */ public class Test06 extends Object{ public static void main(String[] args) { List<StudentOverrideEqualsHashCodeneq> list = new LinkedList<StudentOverrideEqualsHashCodeneq>(); Set<StudentOverrideEqualsHashCodeneq> set = new HashSet<StudentOverrideEqualsHashCodeneq>(); StudentOverrideEqualsHashCodeneq stu1 = new StudentOverrideEqualsHashCodeneq("lime",25); StudentOverrideEqualsHashCodeneq stu2 = new StudentOverrideEqualsHashCodeneq("lime", 25); System.out.println("stu1 == stu2 : "+(stu1 == stu2)); System.out.println("stu1.equals(stu2) : "+stu1.equals(stu2)); System.out.println("stu1-->HashCode:" + stu1.hashCode()); System.out.println("stu2-->HashCode:" + stu2.hashCode()); list.add(stu1); list.add(stu2); System.out.println("list size:"+ list.size()); set.add(stu1); set.add(stu2); System.out.println("set size:"+ set.size()); } }
Console :
stu1 == stu2 : false stu1.equals(stu2) : true stu1-->HashCode:1 stu2-->HashCode:6 list size:2 set size:2
Tt07：覆写equals、覆写hashCode(修改属性值，改变hashCode，remove）
Class ：StudentOverrideEqualsHashCode
package limeMianShi.duolaidian.equals_hashcode; /** * 覆盖equals 和 hashCode方法 * * @author lime * */ public class StudentOverrideEqualsHashCode { private String name; private int age; public StudentOverrideEqualsHashCode(String name, int age) { super(); this.name = name; this.age = age; } public StudentOverrideEqualsHashCode() { super(); } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; StudentOverrideEqualsHashCode other = (StudentOverrideEqualsHashCode) obj; if (age != other.age) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } }
Class : main
package limeMianShi.duolaidian.equals_hashcode; import java.util.HashSet; import java.util.LinkedList; import java.util.List; import java.util.Set; /** * 覆写equals、hashCode方法。修改参与计算hashCode的属性 * * @author lime * */ public class Test07{ public static void main(String[] args) { List<StudentOverrideEqualsHashCode> list = new LinkedList<StudentOverrideEqualsHashCode>(); Set<StudentOverrideEqualsHashCode> set = new HashSet<StudentOverrideEqualsHashCode>(); StudentOverrideEqualsHashCode stu1 = new StudentOverrideEqualsHashCode("lime",25); StudentOverrideEqualsHashCode stu2 = new StudentOverrideEqualsHashCode("lime", 25); System.out.println("stu1 == stu2 : "+(stu1 == stu2)); System.out.println("stu1.equals(stu2) : "+stu1.equals(stu2)); System.out.println("stu1-->HashCode:" + stu1.hashCode()); System.out.println("stu2-->HashCode:" + stu2.hashCode()); list.add(stu1); list.add(stu2); System.out.println("list size:"+ list.size()); set.add(stu1); set.add(stu2); System.out.println("set size:"+ set.size()); System.out.println("修改stu1的name"); stu1.setName("oracle"); System.out.println("stu1-->HashCode:" + stu1.hashCode()); set.remove(stu1); System.out.println("set size:"+ set.size()); } }
Console ：
stu1 == stu2 : false stu1.equals(stu2) : true stu1-->HashCode:3323549 stu2-->HashCode:3323549 list size:2 set size:1 修改stu1的name stu1-->HashCode:-1008860090 set size:1
结果分析：
set添加元素时，首先判断hashCode一致，在判断equals一致。
set移除元素时，首先判断hashCode一致，根据hashCode移除元素。
当我们将某个对象存到set中时，如果该对象的属性参与了hashcode的计算，那么以后就不能修改该对象参与hashcode计算的那些属性了，否则会引起意向不到的错误的。正如测试中，不能够移除stu1对象。
hashSet本质是封装hashMap
package java.util; import java.io.InvalidObjectException; public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, java.io.Serializable{ static final long serialVersionUID = -5024744406713321676L; private transient HashMap<E,Object> map; private static final Object PRESENT = new Object(); public HashSet() { map = new HashMap<>(); } public HashSet(Collection<? extends E> c) { map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16)); addAll(c); } public HashSet(int initialCapacity, float loadFactor) { map = new HashMap<>(initialCapacity, loadFactor); } public HashSet(int initialCapacity) { map = new HashMap<>(initialCapacity); } HashSet(int initialCapacity, float loadFactor, boolean dummy) { map = new LinkedHashMap<>(initialCapacity, loadFactor); } public Iterator<E> iterator() { return map.keySet().iterator(); } public int size() { return map.size(); } public boolean isEmpty() { return map.isEmpty(); } public boolean contains(Object o) { return map.containsKey(o); } public boolean add(E e) { return map.put(e, PRESENT)==null; } public boolean remove(Object o) { return map.remove(o)==PRESENT; } public void clear() { map.clear(); } @SuppressWarnings("unchecked") public Object clone() { try { HashSet<E> newSet = (HashSet<E>) super.clone(); newSet.map = (HashMap<E, Object>) map.clone(); return newSet; } catch (CloneNotSupportedException e) { throw new InternalError(e); } } private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException { s.defaultWriteObject(); s.writeInt(map.capacity()); s.writeFloat(map.loadFactor()); s.writeInt(map.size()); for (E e : map.keySet()) s.writeObject(e); } private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException { s.defaultReadObject(); int capacity = s.readInt(); if (capacity < 0) { throw new InvalidObjectException("Illegal capacity: " + capacity); } float loadFactor = s.readFloat(); if (loadFactor <= 0 || Float.isNaN(loadFactor)) { throw new InvalidObjectException("Illegal load factor: " + loadFactor); } int size = s.readInt(); if (size < 0) { throw new InvalidObjectException("Illegal size: " + size); } capacity = (int) Math.min(size * Math.min(1 / loadFactor, 4.0f), HashMap.MAXIMUM_CAPACITY); map = (((HashSet<?>)this) instanceof LinkedHashSet ? new LinkedHashMap<E,Object>(capacity, loadFactor) : new HashMap<E,Object>(capacity, loadFactor)); for (int i=0; i<size; i++) { @SuppressWarnings("unchecked") E e = (E) s.readObject(); map.put(e, PRESENT); } } public Spliterator<E> spliterator() { return new HashMap.KeySpliterator<E,Object>(map, 0, -1, 0, 0); } }
set-->add：
public boolean add(E e) { return map.put(e, PRESENT)==null; }
public V put(K key, V value) { return putVal(hash(key), key, value, false, true); }
set-->remove :
public boolean remove(Object o) { return map.remove(o)==PRESENT; }
public V remove(Object key) { Node<K,V> e; return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value; }
总结：
1、equals方法用于比较对象的内容是否相等（覆盖以后）
2、hashcode方法只有在集合中用到
3、当覆盖了equals方法时，比较对象是否相等将通过覆盖后的equals方法进行比较（判断对象的内容是否相等）。
4、将对象放入到集合中时，首先判断要放入对象的hashcode值与集合中的任意一个元素的hashcode值是否相等，如果不相等直接将该对象放入集合中。如果hashcode值相等，然后再通过equals方法判断要放入对象与集合中的任意一个对象是否相等，如果equals判断不相等，直接将该元素放入到集合中，否则不放入。
5、将元素放入集合的流程图：
啦啦啦
啦啦啦
