方法摘要
public final native Class<?> getClass() //获取对象的运行时对象的类
public native int hashCode() //获取对象的 hash 值
public boolean equals(Object obj) //比较两个对象是否相等
protected native Object clone() //创建并返回一个对象的拷贝
public String toString() //返回对象的字符串表示形式。
public final native void notify() //唤醒在该对象上等待的某个线程
public final native void notifyAll() //唤醒在该对象上等待的所有线程
public final void wait() //让当前线程进入等待状态。直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。
public final native void wait(long timeout) //让当前线程处于等待(阻塞)状态，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过参数设置的timeout超时时间。
public final void wait(long timeout, int nanos) //与 wait(long timeout) 方法类似，多了一个 nanos 参数，这个参数表示额外时间（以纳秒为单位，范围是 0-999999）。 所以超时的时间还需要加上 nanos 纳秒。。
protected void finalize() //当 GC (垃圾回收器)确定不存在对该对象的有更多引用时，由对象的垃圾回收器调用此方法。
equals()
等价关系
- 自反性
x.equals(x) //true
- 对称性
x.equals(y) == y.equals(x) //true
- 传递性
x.equals(y) //true
y.equals(z) //true
x.equals(z) //true
- 一致性
多次调用 equals() 方法结果不变
x.equals(y) == x.equals(y); // true
- 与 null 的比较
对任何不是 null 的对象 x 调用 x.equals(null) 结果都为 false
x.equals(null); // false;
等价与相等
- 对于基本类型，==判断两个值是否相等，基本类型没有 equals() 方法
- 对于引用类型，==判断两个值的引用是否相等，而 equals() 方法判断引用的对象是否相等
Integer x = new Integer(1);
Integer y = new Integer(1);
System.out.println(x.equals(y)); // true
System.out.println(x == y); // false
实现
- 检查是否为同一个对象的引用，如果是直接返回 true；
- 检查是否是同一个类型，如果不是，直接返回 false；
- 将 Object 对象进行转型；
- 判断每个关键域是否相等。
public class EqualExample {
private int x;
private int y;
private int z;
public EqualExample(int x, int y, int z) {
this.x = x;
this.y = y;
this.z = z;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
EqualExample that = (EqualExample) o;
if (x != that.x) return false;
if (y != that.y) return false;
return z == that.z;
}
}
hashCode()
hashCode 用于获取对象的 hash 值，表示在哈希表中的位置。
equals() 方法判断两个对象是否等价，等价的两个对象哈希值一定相等，而哈希值相等的两个对象不一定等价，因为计算哈希值具有随机性。
在覆盖 object 的 equals() 方法时应当总是覆盖 hashCode() 方法，保证等价的两个对象哈希值也是相等的
String 和 ArrayList 类都重写了 Object 的 equals() 方法，并重写了 hashCode() 方法
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}
}
重写 hashCode 方法时，需要用素数31作为乘子，因为31可以被 JVM 优化
- 左移 << : 左边的最高位丢弃，右边补全0（把 << 左边的数据*2的移动次幂）。
- 右移 >> : 把>>左边的数据/2的移动次幂。
- 无符号右移 >>> : 无论最高位是0还是1，左边补齐0。
所以 ：31 * i = (i << 5) - i（左边 31 * 2=62，右边2 * 2^5-2=62）两边相等，JVM就可以高效的进行计算
toString
toString() 方法用于返回对象的字符串表示形式。默认返回格式：对象的 class 名称 + @ + hashCode 的十六进制字符串。
public static void main(String[] args) {
A a = new A();
System.out.println(a.toString()); //client.A@b4c966a
}
clone()
1. cloneable
clone() 是 Object 的 protected 方法，它不是 public，一个类不显式去重写 clone()，其它类就不能直接去调用该类实例的 clone() 方法。
public class A {
public static void main(String[] args) {
A a = new A();
a.clone(); //Unhandled exception: java.lang.CloneNotSupportedException
}
}
重写 clone() 方法，必须实现 Cloneable，因为 Cloneable 接口规定，如果一个类没有实现 Cloneable 接口又调用了 clone() 方法，就会抛出 java.lang.CloneNotSupportedException
public class A implements Cloneable {
private int a;
private int b;
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
public static void main(String[] args) throws CloneNotSupportedException {
A a = new A();
a.clone();
}
}
2. 浅拷贝
拷贝对象和原始对象的引用类型引用同一个对象。
public class A implements Cloneable {
private int arr;
public int getArr() {
return arr;
}
public void setArr(int arr) {
this.arr = arr;
}
@Override
public A clone() throws CloneNotSupportedException {
return (A) super.clone();
}
public static void main(String[] args) throws CloneNotSupportedException {
A a = new A();
a.setArr(123);
A a1 = null;
a1 = a.clone();
System.out.println(a1.getArr()); //123
}
}
3. 深拷贝
拷贝对象和原始对象的引用类型引用不同对象。
public class A implements Cloneable {
private int arr;
public int getArr() {
return arr;
}
public void setArr(int arr) {
this.arr = arr;
}
@Override
public A clone() throws CloneNotSupportedException {
A result = (A) super.clone();
result.arr = this.arr;
return result;
}
public static void main(String[] args) throws CloneNotSupportedException {
A a = new A();
a.setArr(123);
A a1 = null;
a1 = a.clone();
System.out.println(a1.getArr()); //123
}
}
4. clone() 的替代方案
使用 clone() 方法来拷贝一个对象即复杂又有风险，它会抛出异常，并且还需要类型转换。Effective Java 书上讲到，最好不要去使用 clone()，可以使用拷贝构造函数或者拷贝工厂来拷贝一个对象。
public class A {
private int arr;
public int getArr() {
return arr;
}
public void setArr(int arr) {
this.arr = arr;
}
public A() {
}
public A(A a) {
this.arr = a.arr;
}
public static void main(String[] args){
A a = new A();
a.setArr(123);
A a1 = new A(a);
System.out.println(a1.getArr()); //123
}
}