String的相等比较
对于String类型而言，一般用“==”或者equales做相等比较，前者比较字符串的引用，后者比较字符串的值。
字符串常量的值存储于常量池中，只要值相同，那么引用的就是同一个字符串常量，也就是说，==和equals效果一样。
字符串对象存储于堆中，不同的对象在堆上的内存地址是不一样的。因此，创建两个值相等的String对象，其引用的地址是不相等的。也就是说，用 == 比较时不等，用equals比较时相等。
Integer的相等比较
Integer是int的包装类型，通常直接赋值即可。比较时用==还是equals呢？看下面的例子：
Integer t1 = 129;
Integer t2 = 129;
Integer t3 = 119;
Integer t4 = 119;
System.out.println(t1 == t2);
System.out.println(t3 == t4);
输出结果是false，true。
原因是：对于在-128~127之间的数，Integer使用的是内部缓存值，在此范围之外的数，Integer会在堆上创建对象。t1和t2是堆上的不同对象，所以引用不相等。而t3和t4是内部缓存的值，引用相等。
显式new出来的Integer对象，必然会在堆上创建对象，其引用是不同的。
Integer和int进行==比较时，会自动拆箱进行值的比较。
HashMap中key的相等比较
对于HashMap的key，如果是基本数据类型，则直接进行值的比较。而如果是引用类型呢？
HashMap底层是用数组和链表存储的，当链表长度超过8时会转化为红黑树。根据key进行查找时，先根据hashCode找到数组上的位置，如果该位置上有多个元素，则继续通过equals方法判断值是否相等。
当两个复杂对象作为map的key相等时，必然先要保证hashCode相同，其次equals也要为true。也就是说，使用复杂对象作为map的key时，需要重写hashCode和queals方法。
如果只重写hashCode方法不重写equals方法，则默认的equals方法会进行内存地址的比较，必然是不同的。如果不重写hashCode方法而仅仅重写equals方法，则首先数组上的位置就不同（当然，发生哈希碰撞时例外），对象自然不会相同。
看下面的例子：
public static class Student {
private String name;
private String id;
public Student(String name) {
this.name = name;
}
public Student(String name, String id) {
this.name = name;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
public static void main(String[] args) throws Exception {
Student stu1 = new Student("aa", "1");
Student stu2 = new Student("aa", "1");
Map<Student, String> map = new HashMap<>();
map.put(stu1,"1");
map.put(stu2,"2");
System.out.println(map.size());
}
输出为2。
在这个例子中，map中放入Student类型对象作为key，如果不重写比较方法的话，放入的对象是不同的（默认的比较方法继承于Object类，比较的是内存地址）。
重写hashCode和queals
对Student类的比较方法进行重写：
public static class Student {
private String name;
private String id;
public Student(String name) {
this.name = name;
}
public Student(String name, String id) {
this.name = name;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
@Override
public int hashCode() {
return Objects.hash(id, name);
}
@Override
public boolean equals(Object o) {
if (o == this) return true;
if (!(o instanceof Student)) {
return false;
}
Student s = (Student) o;
return Objects.equals(id, s.getId()) && Objects.equals(name, s.getName());
}
}
public static void main(String[] args) throws Exception {
Student stu1 = new Student("aa", "1");
Student stu2 = new Student("aa", "1");
Map<Student, String> map = new HashMap<>();
map.put(stu1,"1");
map.put(stu2,"2");
System.out.println(map.size());
}
输出为1，说明stu2和stu1相同，添加元素的key相同时，后者覆盖了前者。
还可以用Apache Commons Lang中的API来实现重写：
@Override
public int hashCode() {
return new HashCodeBuilder(17, 37).append(name).append(id).toHashCode();
}
@Override
public boolean equals(Object o) {
if (o == this) return true;
if (!(o instanceof Student)) {
return false;
}
Student s = (Student) o;
return new EqualsBuilder().append(name, s.getName()).append(id, s.getId()).isEquals();
}
