java-Object_java基本数据类型赋值object-CSDN博客

本文链接：https://blog.csdn.net/baidu_39534448/article/details/104060294

Object

Object类位于java.lang包中，java.lang包包含着Java最基础和核心的类，在编译时会自动导入

方法概览

public native int hashCode()

public boolean equals(Object obj)

protected native Object clone() throws CloneNotSupportedException

public String toString()

public final native Class<?> getClass()

protected void finalize() throws Throwable {}

public final native void notify()

public final native void notifyAll()

public final native void wait(long timeout) throws InterruptedException

public final void wait(long timeout, int nanos) throws InterruptedException

public final void wait() throws InterruptedException

equals()：判断是否等价

在Object中的equals()：
   public boolean equals(Object obj) {
        return (this == obj);
    }//仅仅是比较是否是同一个对象

所以当我们使用时就可能需要重写equals()方法：
当一个类表示一个值，如String、Integer；它的不同实例需要逻辑上判断是否相同，而不是地址是否相同，此时需要复写来自定义相等的条件。由于Map的键和Set的元素都是唯一的，如何判断元素相同是使用此类集合的基础。

equals方法的复写需要满足以下通用约定

1. 等价关系

Ⅰ 自反性

x.equals(x); // true

Ⅱ 对称性

x.equals(y) == y.equals(x); // true

Ⅲ 传递性

if (x.equals(y) && y.equals(z))
x.equals(z); // true;

Ⅳ 一致性

多次调用 equals() 方法结果不变
x.equals(y) == x.equals(y); // true

Ⅴ 与 null 的比较

对任何不是 null 的对象 x 调用 x.equals(null) 结果都为 false
x.equals(null); // false;
如无必要不要复写equals 方法,如果复写了此方法一定要记得复写hashCode方法，因为两个对象相等，它们的hashCode也要相等

2.等价与相等

对于基本类型，== 判断两个值是否相等，基本类型没有 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

3. 实现

检查是否为同一个对象的引用，如果是直接返回 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() 返回散列值，而 equals() 是用来判断两个对象是否等价。等价的两个对象散列值一定相同，但是散列值相同的两个对象不一定等价。
在覆盖 equals() 方法时应当总是覆盖 hashCode() 方法，保证等价的两个对象散列值也相等。

下面的代码中，新建了两个等价的对象，并将它们添加到 HashSet 中。我们希望将这两个对象当成一样的，只在集合中添加一个对象，但是因为 EqualExample 没有实现 hashCode() 方法，因此这两个对象的散列值是不同的，最终导致集合添加了两个等价的对象。

EqualExample e1 = new EqualExample(1, 1, 1);
EqualExample e2 = new EqualExample(1, 1, 1);
System.out.println(e1.equals(e2)); // true
HashSet<EqualExample> set = new HashSet<>();
set.add(e1);
set.add(e2);
System.out.println(set.size());   // 2

1.散列算法

理想的散列函数应当具有均匀性，即不相等的对象应当均匀分布到所有可能的散列值上。这就要求了散列函数要把所有域的值都考虑进来。可以将每个域都当成 R 进制的某一位，然后组成一个 R 进制的整数。。
一个数与 31 相乘可以转换成移位和减法： 31 * i == (i << 5） - i，编译器会自动进行这个优化。

@Override
public int hashCode() {
    int result = 17;
    result = 31 * result + x;
    result = 31 * result + y;
    result = 31 * result + z;
    return result;
}

R 一般取 31，因为它是一个奇素数，
1）如果是偶数的话，当出现乘法溢出，信息就会丢失，因为与 2 相乘相当于向左移一位
2）质数的特性（只有1和自己是因子）能够使得它和其他数相乘后得到的结果比其他方式更容易产成唯一性，也就是hash code值的冲突概率最小
3）方便实现位运算

2.String hashcode()方法

System.out.println("123".hashCode());//48960


   public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            hash = h = isLatin1() ? StringLatin1.hashCode(value)
                                  : StringUTF16.hashCode(value);
        }
        return h;
    }


  public static int hashCode(byte[] value) {
        int h = 0;
        for (byte v : value) {
            h = 31 * h + (v & 0xff);
        }
        return h;
    }
//h=48690

Stringhashcode总结：从第一个字符开始，让hash值初始化为1
hash=hash*31+字符的byte值；
重复运算直到最后一个字符
Object类hashcode的返回值：
不固定，可以在jvm中配置：

有直接返回内存地址，返回固定的1，运算后的内存地址，自增序列的值等

toString()：

默认返回这个类的全类名+@+hashCode()的16进制

public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
//如com.opp.Object.Demo1_toString@2096442d

clone()：

参考https://blog.csdn.net/qq_33314107/article/details/80271963

1. cloneable

clone() 是 Object 的 protected 方法，它不是 public，一个类不显式去重写 clone()，其它类就不能直接去调用该类实例的 clone() 方法。

public class CloneExample {
    private int a;
    private int b;
}
CloneExample e1 = new CloneExample();
// CloneExample e2 = e1.clone(); // 'clone()' has protected access in 'java.lang.Object'

重写 clone() 得到以下实现：
public class CloneExample {
    private int a;
    private int b;

    @Override
    public CloneExample clone() throws CloneNotSupportedException {
        return (CloneExample)super.clone();
    }
}
CloneExample e1 = new CloneExample();
try {
    CloneExample e2 = e1.clone();
} catch (CloneNotSupportedException e) {
    e.printStackTrace();
}
java.lang.CloneNotSupportedException: CloneExample

以上抛出了 CloneNotSupportedException，这是因为 CloneExample 没有实现 Cloneable 接口。
应该注意的是，clone() 方法并不是 Cloneable 接口的方法，而是 Object 的一个 protected 方法。Cloneable 接口只是规定，如果一个类没有实现 Cloneable 接口（实际上这个类是空的，不含有方法）又调用了 clone() 方法，就会抛出 CloneNotSupportedException。

public class CloneExample implements Cloneable {
    private int a;
    private int b;

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

2.浅拷贝：

被复制对象的所有值属性都含有与原来对象的相同，而所有的对象引用属性仍然指向原来的对象

class DeepCloneExample implements Cloneable {

    private int[] arr;

    public DeepCloneExample() {
        arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
        }
    }

    public void set(int index, int value) {
        arr[index] = value;
    }

    public int get(int index) {
        return arr[index];
    }

    @Override
    protected DeepCloneExample clone() throws CloneNotSupportedException {
        DeepCloneExample result = (DeepCloneExample) super.clone();
        return result;
    }
}


DeepCloneExample de=new DeepCloneExample();
		DeepCloneExample de2=de.clone();
		de.set(0, 20);
		System.out.println(de2.get(0));//20
		System.out.println(de==de2);//false

就是说浅拷贝的引用对象arr数组任然是指向原来的对象

3.深拷贝

 @Override
    protected DeepCloneExample clone() throws CloneNotSupportedException {
        DeepCloneExample result = (DeepCloneExample) super.clone();
        result.arr = new int[arr.length];
        for (int i = 0; i < arr.length; i++) { //与上面的区别 在于拷贝引用对象
            result.arr[i] = arr[i];
        }
        return result;
    }


		DeepCloneExample de=new DeepCloneExample();
		DeepCloneExample de2=de.clone();
		de.set(0, 20);
		System.out.println(de2.get(0));//0
		System.out.println(de==de2);//false

深拷贝引用对象arr数组重新赋值，指向了新的对象

4. clone() 的替代方案

使用 clone() 方法来拷贝一个对象即复杂又有风险，它会抛出异常，并且还需要类型转换。Effective Java 书上讲到，最好不要去使用 clone()，可以使用拷贝构造函数或者拷贝工厂来拷贝一个对象。

public class CloneConstructorExample {

    private int[] arr;

    public CloneConstructorExample() {
        arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
        }
    }

    public CloneConstructorExample(CloneConstructorExample original) {
        arr = new int[original.arr.length];
        for (int i = 0; i < original.arr.length; i++) {
            arr[i] = original.arr[i];
        }
    }

    public void set(int index, int value) {
        arr[index] = value;
    }

    public int get(int index) {
        return arr[index];
    }
}
CloneConstructorExample e1 = new CloneConstructorExample();
CloneConstructorExample e2 = new CloneConstructorExample(e1);
e1.set(2, 222);
System.out.println(e2.get(2)); // 2

finalize()：

参考：https://blog.csdn.net/a4171175/article/details/90749839
finalize()是Object中的方法，当垃圾回收器将要回收对象所占内存之前被调用，即当一个对象被虚拟机宣告死亡时会先调用它finalize()方法，让此对象处理它生前的最后事情（这个对象可以趁这个时机挣脱死亡的命运）。要明白这个问题，先看一下虚拟机是如何判断一个对象该死的。

其他的一些方法

getClass()返回一个对象的运行时类。
notify()唤醒在此对象监视器上等待的单个线程
notifyAll()唤醒在此对象监视器上等待的所有线程
wait()导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法

注意：可以把任何一种数据类型的变量赋给Object类型的变量

         Object ss[]= {};
           Object o=ss;//正确
           Object oo=1;//正确