hashcode()以及equals()方法

先从简单的开始
铺垫一下：

		String str1="11";
		String str2="11";
	
		String str3=new String("111");
		String str4=new String("111");
		
		System.out.println("两个String类型== 和equals方法  底层都重写了equals方法"); 
		System.out.println(str1==str2);
		System.out.println(str1.equals(str2));
		System.out.println("两个Strig对象也是 ==（比较的地址） 和equals方法（比较的内容） 重写（equals）");
		System.out.println(str3==str4);
		System.out.println(str3.equals(str4));
		//基本数据类型和所对应的包装类  的道理都是相同的  也都重写了equals方法
		这个面试会有考到，而且跟jvm有些关系 具体先不展开了

这是结果

两个String类型== 和equals方法  底层都重写了equals方法
str1==str2:true
str1.equals(str2):true
两个Strig对象也是 ==（比较的地址） 和equals方法（比较的内容） 重写（equals）
str3==str4:false   
str3.equals(str4):true

可以看到 基本数据类型、string类型 == 和equals 都是相等的
但是类对象（包括包装类、String类）中 ==是比较的是地址值 ，而equals中比较的是类中的内容（但是除（包装类和String类）之外的要重写equals()方法才行）至于为什么？？？下面讲

2、进一步深入，如果进一步深入肯定使用hash表，这个面试肯定也会涉及到的
具体的公式是这样的

两个对象的equals相等 则两个对象的hashcode值一定相等
两个对象的equals不想等，则连个对象的hashcode值一定不相等
两个对象的hashcode相等 则两个对象equals不一定相等
两个对象的hashcode不相等 则两个对象的equals一定不相等

还有 我记得有一个这样的原则 如果在hashset、hashmap等hash表中存储key为对象的时候，
一定要重写对象的hashcode方法和equals方法。
但是 上述的公式和原则是为什么呢？？？？？？？
先来看一个存储hashset中的小demo把

对象中先不重写hashcode方法和equals

	private int age;
	private String name;
	public student(int age, String name) {
		this.age = age;
		this.name = name;
	}
	@Override
	public String toString() {
		return "student [age=" + age + ", name=" + name + "]";
	}
	public static void main(String[] args) {
		HashSet<student> set=new HashSet<>();
		student s1=new student(12,"张三");
		set.add(s1);
		student s3=new student(13,"李四");
		set.add(s3);
		student s2=new student(12,"张三");
		System.out.println(s1.hashCode()==s2.hashCode());
		System.out.println(s1.equals(s2));
		set.add(s2);
		Iterator<student> it = set.iterator();
		while(it.hasNext()){
			student s=it.next();
			System.out.println(s.toString());
		}
	}
}
结果：
false
false
student [age=12, name=张三]
student [age=12, name=张三]
student [age=13, name=李四]`
小知识点：
		 *s1跟s2的内容相等但是  两个对象hashcode值和equals 均为false
		  s1.hashcode()  如果s对象没有重写hashcode方法
		 *  底层调用的是public native int hashCode();   native暂时认为地址吧new两个对象 地址肯定不相等
		 下面有个小问题：这里揭示一下
		 	为什么 除（包装类和String类）之外的要重写equals()方法，equals才是比较的是内容
		 	如果没有重写equals方法调用的是==：如下
		 * s1.equals(s2) 如果s对象没有重写equals方法底层调用的方法：
		 * public boolean equals(Object obj) {
        	return (this == obj);
    		}
    		还有：包装类和String类底层都是已经重写了equals方法的

我们应该都知道new两个对象 本来就是不一样的呀。s1本来就是不等于s2的呀（虽然内容一样）
对，这是没错的
但这里注意如果我们是使用hash表存储数据，我们会约定存储时s1一定要等于s2，这是为了进行去重操作。
但是为什么对象作为key的时候，一定要重写hashcode方法和equal方法？？如果我只写一个呢？？？？

下面：
只重写equals 不重写hashcode

@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		student other = (student) 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;
	}
	运行结果：
	student [age=12, name=张三]
	student [age=12, name=张三]
	student [age=13, name=李四]

只重写equals 不重写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;
	}
	结果：
	
student [age=12, name=张三]
student [age=12, name=张三]
student [age=13, name=李四]

可以看出都是不行的 我们要的结果中只有一个名字为张三 年龄12
如果把hashcode和equals方法同时写上后：
student [age=12, name=张三] student [age=13, name=李四]
所以要同时重写对象的equals方法和hashcode方法，才能得到存入hash表中没有重复的元素
还没完————————》》》》》》》
可以看一下hashmap中添加方法（hashset底层也是hashmap）

 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;

其中一个条件这样的 目的也是为了去重

if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
如果对象的hash值为false 直接认为两个对象不相等直接存入即可
如果hash相等则进行判断key是否相等。如果也相等则认为两个元素相等 value值进行更新。

还有hashset中的add方法调用的是hashmap中的put方法

public boolean add(E e) {
            return map.put(e, PRESENT)==null;  
        }

这里hashset中存入的E e元素就是相等于hashmap中key值。
还有其中的PRESENT
private static final Object PRESENT = new Object();
我理解就是一个常量对象吧。
总结一点：
上述set存储对象的时候所需要的条件，相当与在hashmap中存储时 key充当对象同样所需要满足的条件。
game over

本人理解大概这么多。