ava中的数据类型，可分为两类：
1.基本数据类型，也称原始数据类型。byte,short,char,int,long,float,double,boolean
他们之间的比较，应用双等号（==）,比较的是他们的值。
2.复合数据类型(类)
当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。 JAVA当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法，这个方法的初始行为是比较对象的内存地 址，但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。
对于复合数据类型之间进行equals比较，在没有覆写equals方法的情况下，他们之间的比较还是基于他们在内存中的存放位置的地址值的，因为Object的equals方法也是用双等号（==）进行比较的，所以比较后的结果跟双等号（==）的结果相同。
public boolean equals(Object obj) { return (this == obj); }
如果对象没有覆写equals方法默认使用Object方法，就是比较对象的内存地址是否一样。
若某个类没有覆盖equals()方法，当它的通过equals()比较两个对象时，实际上是比较两个对象是不是同一个对象。这时，等价于通过“==”去比较这两个对象
注意点：
如果类没有重写equals，那么对于该类的对象来说“==”和“equals”没有区别。都是比较对象的内存地址。 但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。所以会有很多经典的面试题：
String a = new String ("abc"); String b = new String ("abc"); System.out.println(a.equals(b)); System.out.println(a==b);
返回值是true和false
String以及基本数据类型的包装类中都重写了hashCode()方法，他们生成的哈希码是跟他们的内容
（这里就是指值）息息相关，也就是说在用equals()比较两个变量是否相等的时候只要他们的值相等，那么就返回true
第二：我们可以覆写覆盖equals()方法。则通过equals()比较该类的两个对象是否相等，但是需要注意的一点如果你重写equals（）方法，那么你必须重写hashCode（）方法
从开始学习Java，哈希码以及equals和==的区别就一直困扰着我。
要想明白equals和==的区别首先应该了解什么是哈希码，因为在jdk的类库中不管是object实现的equals()方法还是String重写的equals()方法以及
其它基本数据类型的包装类重写的euqals()方法,他们在比较对象的时候都是根据hashCode()方法返回的哈希码来判断两个对象是否相等的，所以要想搞清楚
equals()就必须要知道什么是哈希码。
那么究竟是什么哈希码呢？哈希码是可以根据的自己的需求，采用不同的算法产生的一个Int型数字。Object的hashCode()方法返回的哈希码是根据对
象的内存地址来生成的，所以每个对象的哈希码是不相同的，如果你要比较的两个变量的类型没有重写Object的hashCode()方法那么这两个变量除非是指向
相同的对象（地址相同），否则返回的一定是false。而String以及基本数据类型的包装类中都重写了hashCode()方法，他们生成的哈希码是跟他们的内容
（这里就是指值）息息相关，也就是说在用equals()比较两个变量是否相等的时候只要他们的值相等，那么就返回true，因为他们生成的哈希码相等。有个
值得注意的地方是：在JDK的类中只要重写的Object的equals()方法，那就肯定重写了它的hashCode()方法，因为equals()方法中在比较两个变量时，
判断的标准就是哈希码是否一样，Object中的hashCode()方法是根据对象的内存地址生成的，如果重写了equals()方法而继续使用原来的hashCode()方
法生成的哈希码作为判断相等的依据，那显然达不到我们要改变判断对象是否相等的标准的效果。
既然知道了什么是哈希码，现在就可以说明equals()和==的区别了，对于没用重写Object的equals()方法的类型所生成的对象的比较，equals()
和==是效果一样的，==比较的是两个变量所指向的对象在内存中指向的地址是否一样，而当两个变量的类型中继承了Object的equals()方法的时候，由于
该方法比较的标准是看哈希码是否相等，而哈希码是由hashCode()方法生成的，该方法生成哈希码的依据是对象在内存中的地址，最终比较的还是地址。所
以说equals()和==效果一样。而对于像String和那些基本数据类型的包装类来说equals()和==就不一样了，因为他们重写了Object的equals()方法和
hashCode()方法，使得equals()方法的判断标准发生了改变，他们的判断标准是看对象的内容是否相等，这里就是指值是不是一样，因为他们的哈希码是
根据对象的值生成的，与内存地址无关了，所以他们的equals()方法比较的是对象的值是否相等，而==比较的仍然是地址。所以equals()和==就不一样了。
这里还要注意一下，在比较值的时候，一般==比较的是基本数据类型，而equals()比较的是引用数据类型，地址相同一定值相等，而值相等地址不一定
相同。如果比较的是地址，那最好是用==，因为无论是否重写了Object的equals()方法，==永远比较的是地址,equals()比较的是哈希码，而哈希码生成
的标准是由类作者自己根据需求来控制的。
结论2：
如果两个对象x和y满足x.equals(y) == true，它们的哈希码（hash code）应当相同。Java对于eqauls方法和hashCode方法是这样规定的：(1)如果两个对象相同（equals方法返回true），那么它们的hashCode值一定要相同；(2)如果两个对象的hashCode相同，它们并不一定相同
1、如果两个对象相等，那么它们的hashCode()值一定相同。
这里的相等是指，通过equals()比较两个对象时返回true。
2.、如果两个对象hashCode()相等，它们并不一定相等。
因为在散列表中，hashCode()相等，即两个键值对的哈希值相等。然而哈希值相等，并不一定能得出键值对相等。补充说一句：“两个不同的键值对，哈希值相等”，这就是哈希冲突。
我们来看下面的例子
HashSet （需要重写hashCode和equals方法）
一般描述的事物需要往集合中添加，那么都需要重写这两个方法
删除和判断元素是否存在，都是先判断hashCode 看看是否存在，若存在则继续equals（）；
import java.util.*; class Person { private String name; private int age; Person(String name,int age) { this.name=name; this.age=age; } public int hashCode()//重写 { return name.hashCode()+age ; } public boolean equals(Object obj)//重写 Object不能换 { if(!(obj instanceof Person)) return false; Person p=(Person)obj; System.out.println(this.name+"...."+p.name); return this.name.equals(p.name)&&this.age==p.age; } public String getName() { return name; } public int getAge() { return age; } } class HashSetDemo { public static void main(String[] args) { HashSet hs=new HashSet(); hs.add(new Person("lisi01",30)); hs.add(new Person("lisi02",33)); hs.add(new Person("lisi03",35)); hs.add(new Person("lisi02",33)); hs.add(new Person("lisi01",30)); hs.add(new Person("lisi04",32)); hs.add(new Person("lisi03",35)); Iterator it=hs.iterator(); while(it.hasNext()) { Person p=(Person)it.next();; sop(p.getName()+" "+p.getAge()); } } public static void sop(Object obj) { System.out.println(obj); } }
参考案例2：
第一：
Set集合没有顺序，也不允许重复。
为什么要这样：模拟现实的集合。
这里的重复只是：对象的重复
何为对象的重复：指的就是同一个对象。
何为同一个对象：内存中，所在的内存编号一致。
内存编号的表示是什么：哈希码（哈希码一般是 类名 和 对象所在内存地址的十六进制数字表示 的组合）。
第二：
这种设置和实现中的矛盾在什么地方：
现实生活中只要属性相同，我们就认为那是同一个对象。
这与计算机比较同一个对象的方法不同（计算机使用内存地址，即哈希码）
于是，就需要重写equals方法和hashCode方法（&&）来让程序的运行结果符合现实生活
基本数据类型的实现类都已经重写了上面的两个方法。
第三：
为什么要重写equals方法和hashCode方法（技术实现原理）：
程序向HashSet中添加一个对象时，先用hashCode方法计算出该对象的哈希码。
比较：
（1），如果该对象哈希码与集合已存在对象的哈希码不一致，则该对象没有与其他对象重复，添加到集合中！
（2），如果存在于该对象相同的哈希码，那么通过equals方法判断两个哈希码相同的对象是否为同一对象（判断的标准是：属性是否相同）
1>，相同对象，不添加。
2>，不同对象，添加！
这时有两个疑问：
1，为什么哈希码相同了还有可能是不同对象？
2,为什么经过比较哈希码还需要借助equals方法判断？
答：
首先：
按照Object类的hashCode方法，是不可能返回两个相同的哈希码的。（哈希码唯一标志了对象）
然后：
Object类的hashCode方法返回的哈希码具有唯一性（地址唯一性），但是这样不能让程序的运行逻辑符合现实生活。（这个逻辑就是：属性相同的对象被看作同一个对象。）
为了让程序的运行逻辑符合现实生活，Object的子类重写了hashCode的方法（基本数据类型的实现类都已经重写了两个方法，自定义的类要软件工程 师自己重写。）
那么：
重写的宗旨是什么？
重写就是为了实现这样的目的：属性相同的不同对象在调用其hashCode方法后，返回的是同样的哈希码。
但是
我们在重写的时候，发现几乎所有的写法都无法避免一个bug：有一些属性不同的对象（当然是不同的对象），会返回相同的哈希码。（即 重码）
最后：
为了解决这个问题：在哈希码相同的时候，再用equals方法比较两个对象的对应属性是否相同，这样，确保了万无一失。
这样：上面两个问题得到解决。
5
下面给出一个属性不同但哈希码相同的例子：
import java.util.HashSet; import java.util.Iterator; import java.util.Set; class Person { private String name; private int id; Person(String name,int id) { this.name = name; this.id = id; } public void setName(String name){ this.name = name; } public String getName(){ return name; } public void setId(int id){ this.id = id; } public int getId(){ return id; } public int hashCode(){ return name.hashCode()+id; //使用字符串哈希值与Integer的哈希值的组合 //这样会产生重码，实际上重码率很高 } public boolean equals(Object obj){ if(obj instanceof Person){ // Person p = (Person)obj; return(name.equals(p.name) && id == p.id); } return super.equals(obj); } } public class TestHashSet2 { public static void main(String[] args) { Person p1 = new Person("a",1); Person p2 = new Person("b",0); Set<Person> set = new HashSet<Person>(); set.add(p1); set.add(p2); Iterator<Person> it = set.iterator(); while(it.hasNext()){ System.out.println(it.next().getName()); } } }
-
总思路：hashCode不同时，则必为不同对象。hashCode相同时，根据equlas()方法判断是否为同一对象。
-
在HashSet，HashMap，HashTable中都存在该问题。