java面试题之hashCode与equals()方法

@Data
@Entity
@Table(name = "tb_user")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    // 手机号 11位
    private String phone;

    // 用户名--唯一
    private String userName;

    // 密码
    private String password;

    // 职位
    private String jobPosition;

    // 头像
    private String headSrc;

    // 创建时间
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private Timestamp createTime;

    // 更新时间
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private Timestamp updateTime;

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (null == obj) {
            return false;
        }

        if (obj instanceof User) {
            User user = (User) obj;
            if (userName.equals(user.userName)) {
                return true;
            }
        }
        return false;
    }
     /** 
     * 重写hashcode 方法，返回的hashCode 不一样才认定为不同的对象 
     */  
    @Override  
    public int hashCode() {  
          return userName.hashCode(); // 只比较userName，userName一样就不添加进集合  
          // return id.hashCode() * username.hashCode(); 
    }  

    public User(String userName) {
        this.userName = userName;
    }

}

public class SetTest {
    public static void main(String[] args) {
        Set<User> setUsr = new HashSet<User>();

        User user1 = new User("llx");
        User user2 = new User("llx");
        User user23 = new User("llx3");

        setUsr.add(user1);
        setUsr.add(user2);
        setUsr.add(user23);
        System.out.println("size=" + setUsr.size());
        System.out.println("setUsr===" + setUsr);
        // System.out.println("userA equals userB:" + user1.equals(user2));
        // System.out.println("userA equals user23:" + user1.equals(user23));

        test1();
    }

Java中Set巧用，去掉重复数据
实际中，还是比较常用的

可以了，证明需要重写equals方法和hashCode方法，来看原理： java.lnag.Object中对hashCode的约定：

1. 在一个应用程序执行期间，如果一个对象的equals方法做比较所用到的信息没有被修改的话，则对该对象调用hashCode方法多次，它必须始终如一地返回同一个整数。
2. 如果两个对象根据equals(Object o)方法是相等的，则调用这两个对象中任一对象的hashCode方法必须产生相同的整数结果。
3. 如果两个对象根据equals(Object o)方法是不相等的，则调用这两个对象中任一个对象的hashCode方法，不要求产生不同的整数结果。但如果能不同，则可能提高散列表的性能。

在HashSet中，基本的操作都是有HashMap底层实现的，因为HashSet底层是用HashMap存储数据的。当向HashSet中添加元素的时候，首先计算元素的hashcode值，然后用这个（元素的hashcode）%（HashMap集合的大小）+1计算出这个元素的存储位置，如果这个位置位空，就将元素添加进去；如果不为空，则用equals方法比较元素是否相等，相等就不添加，否则找一个空位添加。

package java.util;  

public class HashSet<E> extends AbstractSet<E>   
    implements Set<E>, Cloneable, java.io.Serializable  
{  
    static final long serialVersionUID = -5024744406713321676L;     

    // 底层使用HashMap来保存HashSet中所有元素。     
    private transient HashMap<E,Object> map;     

    // 定义一个虚拟的Object对象作为HashMap的value，将此对象定义为static final。     
    private static final Object PRESENT = new Object();     

    /**  
     * 默认的无参构造器，构造一个空的HashSet。  
     *   
     * 实际底层会初始化一个空的HashMap，并使用默认初始容量为16和加载因子0.75。  
     */     
    public HashSet() {  
        map = new HashMap<E,Object>();  
    }  

    /**  
     * 构造一个包含指定collection中的元素的新set。  
     *  
     * 实际底层使用默认的加载因子0.75和足以包含指定  
     * collection中所有元素的初始容量来创建一个HashMap。  
     * @param c 其中的元素将存放在此set中的collection。  
     */     
    public HashSet(Collection< extends E> c) {  
        map = new HashMap<E,Object>(Math.max((int) (c.size()/.75f) + 1, 16));  
        addAll(c);  
    }  

    /**  
     * 以指定的initialCapacity和loadFactor构造一个空的HashSet。  
     *  
     * 实际底层以相应的参数构造一个空的HashMap。  
     * @param initialCapacity 初始容量。  
     * @param loadFactor 加载因子。  
     */     
    public HashSet(int initialCapacity, float loadFactor) {  
        map = new HashMap<E,Object>(initialCapacity, loadFactor);  
    }  

    /**  
     * 以指定的initialCapacity构造一个空的HashSet。  
     *  
     * 实际底层以相应的参数及加载因子loadFactor为0.75构造一个空的HashMap。  
     * @param initialCapacity 初始容量。  
     */     
    public HashSet(int initialCapacity) {  
        map = new HashMap<E,Object>(initialCapacity);  
    }  

    /**  
     * 以指定的initialCapacity和loadFactor构造一个新的空链接哈希集合。  
     * 此构造函数为包访问权限，不对外公开，实际只是是对LinkedHashSet的支持。  
     *  
     * 实际底层会以指定的参数构造一个空LinkedHashMap实例来实现。  
     * @param initialCapacity 初始容量。  
     * @param loadFactor 加载因子。  
     * @param dummy 标记。  
     */     
    HashSet(int initialCapacity, float loadFactor, boolean dummy) {  
        map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor);  
    }  

    /**  
     * 返回对此set中元素进行迭代的迭代器。返回元素的顺序并不是特定的。  
     *   
     * 底层实际调用底层HashMap的keySet来返回所有的key。  
     * 可见HashSet中的元素，只是存放在了底层HashMap的key上，  
     * value使用一个static final的Object对象标识。  
     * @return 对此set中元素进行迭代的Iterator。  
     */     
    @Override  
    public Iterator<E> iterator() {  
        return map.keySet().iterator();  
    }  

    /**  
     * 返回此set中的元素的数量（set的容量）。  
     *  
     * 底层实际调用HashMap的size()方法返回Entry的数量，就得到该Set中元素的个数。  
     * @return 此set中的元素的数量（set的容量）。  
     */     
    @Override  
    public int size() {  
        return map.size();  
    }  

    /**  
     * 如果此set不包含任何元素，则返回true。  
     *  
     * 底层实际调用HashMap的isEmpty()判断该HashSet是否为空。  
     * @return 如果此set不包含任何元素，则返回true。  
     */     
    @Override  
    public boolean isEmpty() {  
        return map.isEmpty();  
    }  

    /**  
     * 如果此set包含指定元素，则返回true。  
     * 更确切地讲，当且仅当此set包含一个满足(o==null ? e==null : o.equals(e))  
     * 的e元素时，返回true。  
     *  
     * 底层实际调用HashMap的containsKey判断是否包含指定key。  
     * @param o 在此set中的存在已得到测试的元素。  
     * @return 如果此set包含指定元素，则返回true。  
     */     
    @Override  
    public boolean contains(Object o) {  
        return map.containsKey(o);  
    }  

    /**  
     * 如果此set中尚未包含指定元素，则添加指定元素。  
     * 更确切地讲，如果此 set 没有包含满足(e==null ? e2==null : e.equals(e2))  
     * 的元素e2，则向此set 添加指定的元素e。  
     * 如果此set已包含该元素，则该调用不更改set并返回false。  
     *  
     * 底层实际将将该元素作为key放入HashMap。  
     * 由于HashMap的put()方法添加key-value对时，当新放入HashMap的Entry中key  
     * 与集合中原有Entry的key相同（hashCode()返回值相等，通过equals比较也返回true），  
     * 新添加的Entry的value会将覆盖原来Entry的value，但key不会有任何改变，  
     * 因此如果向HashSet中添加一个已经存在的元素时，新添加的集合元素将不会被放入HashMap中，  
     * 原来的元素也不会有任何改变，这也就满足了Set中元素不重复的特性。  
     * @param e 将添加到此set中的元素。  
     * @return 如果此set尚未包含指定元素，则返回true。  
     */     
    @Override  
    public boolean add(E e) {  
        return map.put(e, PRESENT)==null;  
    }  

    /**  
     * 如果指定元素存在于此set中，则将其移除。  
     * 更确切地讲，如果此set包含一个满足(o==null ? e==null : o.equals(e))的元素e，  
     * 则将其移除。如果此set已包含该元素，则返回true  
     * （或者：如果此set因调用而发生更改，则返回true）。（一旦调用返回，则此set不再包含该元素）。  
     *  
     * 底层实际调用HashMap的remove方法删除指定Entry。  
     * @param o 如果存在于此set中则需要将其移除的对象。  
     * @return 如果set包含指定元素，则返回true。  
     */     
    @Override  
    public boolean remove(Object o) {  
        return map.remove(o)==PRESENT;  
    }  

    /**  
     * 从此set中移除所有元素。此调用返回后，该set将为空。  
     *  
     * 底层实际调用HashMap的clear方法清空Entry中所有元素。  
     */     
    @Override  
    public void clear() {  
        map.clear();  
    }  
} 

Set (inteface)

存入Set 的每个元素必须唯一，不保证维护元素的次序.加入Set 的Object必须定义equals()方法
－－HashSet　为快速查找而设计的Set ，存入HashSet对象必须定义hashCode().
－－TreeSet 保护次序的Set ，使用它可以从Set 中提取有序序列.
－－LinkedHashSet　　具有HashSet的查询速度，且内部使用链表维护元素的次序.
它们之间的存储方式不一样：
TreeSet采用红黑树的树据结构排序元素.
HashSet采用散列函数，这是专门为快速查询而设计的.
LinkedHashSet内部使用散列以加快查询速度，同时使用链表维护元素的次序.

注意:::::使用HashSet/TreeSet时，必须为类定义equals()； 而HashCode()是针对HashSet，
作为一种编程风格，当覆盖equals()的时候，就应该同时覆盖hashCode().