目录
为什么equals方法重写的话，建议也一起重写hashcode方法？
JDK源码系列 & JAVA语言数据类型Byte
总揽全局
先看类的继承结构
- 选中要查看的类名，mac按
control + h即可看到这个类的继承结构（但是只能看到继承，不能看到接口） -
- 上图：给了我们很多的信息。
- Object类是顶层，没有父类。
- 所有java编译后的classes文件全部从Object类中派生出来。
- 换句话就是，Java中的类，不论是显示写了继承Object还是没写，都会继承Object这个类。
- 也就是说，Java中所有的类都可以使用Object类中的所有公共方法（反射除外）。
看类的Diagram图
- 选中要查看的类名，右击，Diagrams =》Show Diagram，可以看到当前类有继承哪些类和接口。
-
-
- 上图，当然我们的Object类并没有继承任何接口和父类。
看类的注释
-
- 红色框是类的注释
- 会告诉你这个类是干嘛的
@author写这个类的作者是谁@see需要引用和参考其他代码@since这个类存在于哪个JDK版本
看类中的具体有啥
- 首先可以看看这个类中有哪些代码块、变量、方法。
-
-
- 上图是方法的注释
- 不是每个方法JDK开发者都给了注释
- 但是给了注释的方法，一定要读一下注释，这就相当于喝药的说明书，看看作者有什么想要告诉你的
开始阅读源码
静态代码块
//native修饰的方法，代表着要去调用C++中的方法，这里就不看了
private static native void registerNatives();
//在类加载过程中会给静态变量和静态代码块赋值
static {
registerNatives();
}getClass();
- 用于获取对象的运行时对象的类
-
/** * 用于获取对象的运行时对象的类 * 返回的Class对象是被 static synchronized 方法锁定的对象 * * Class * Object n = 0; * Class<? extends Object> c = n.getClass(); */ public final native Class<?> getClass();
什么是Class类？
- 当我们编写一个新的JAVA类时，JVM就会帮我们编译成class对象,存放在同名的.class文件中。在运行时，当需要生成这个类的对象，JVM就会检查此类是否已经装载内存中。若是没有装载，则把.class文件装入到内存中。若是装载，则根据class文件生成实例对象。
- 说白了，这个就是Object类的一种表现形式。
hashCode();
- hashcode就是通过hash函数得来的，通俗的说，就是通过某一种算法得到的，hashcode就是在hash表中有对应的位置。
什么是hash
- hash是一个函数，该函数中的实现就是一种算法，就是通过一系列的算法来得到一个hash值。
Hash函数有哪些？
对象的hashcode怎么得来的呢？
- 首先一个对象肯定有物理地址，通过对象的内部地址(也就是物理地址)转换成一个整数，然后该整数通过hash函数的算法就得到了hashcode，所以，hashcode是什么呢？就是在hash表中对应的位置。
- 举个例子，hash表中有 hashcode为1、hashcode为2、(...)3、4、5、6、7、8这样八个位置，有一个对象A，A的物理地址转换为一个整数17(这是假如)，就通过直接取余算法，17%8=1，那么A的hashcode就为1，且A就在hash表中1的位置。
hashcode的作用？
- HashCode的存在主要是为了查找的快捷性，HashCode是用来在散列存储结构中确定对象的存储地址的(后半句说的用hashcode来代表对象就是在hash表中的位置)。
- 为什么hashcode就查找的更快，比如：我们有一个能存放1000个数这样大的内存中，在其中要存放1000个不一样的数字，用最笨的方法，就是存一个数字，就遍历一遍，看有没有相同得数，当存了900个数字，开始存901个数字的时候，就需要跟900个数字进行对比，这样就很麻烦，很是消耗时间，用hashcode来记录对象的位置，来看一下。hash表中有1、2、3、4、5、6、7、8个位置，存第一个数，hashcode为1，该数就放在hash表中1的位置，存到100个数字，hash表中8个位置会有很多数字了，1中可能有20个数字，存101个数字时，他先查hashcode值对应的位置，假设为1，那么就有20个数字和他的hashcode相同，他只需要跟这20个数字相比较(equals)，如果每一个相同，那么就放在1这个位置，这样比较的次数就少了很多，实际上hash表中有很多位置，这里只是举例只有8个，所以比较的次数会让你觉得也挺多的，实际上，如果hash表很大，那么比较的次数就很少很少了。 通过对原始方法和使用hashcode方法进行对比，我们就知道了hashcode的作用，并且为什么要使用hashcode了。
equals和hashcode的关系
- hashcode用来判断在哪个桶内，equals用来判断这个数在这个桶内是否相等。
- 如果两个对象equals相等，那么这两个对象的HashCode一定也相同。
- 如果两个对象的HashCode相同，不代表两个对象就相同，只能说明这两个对象在散列存储结构中，存放于同一个位置。
为什么equals方法重写的话，建议也一起重写hashcode方法？
- 有个A类重写了equals方法，但是没有重写hashCode方法，看输出结果，对象a1和对象a2使用equals方法相等，按照上面的hashcode的用法，那么他们两个的hashcode肯定相等，但是这里由于没重写hashcode方法，他们两个hashcode并不一样，所以，我们在重写了equals方法后，尽量也重写了hashcode方法，通过一定的算法，使他们在equals相等时，也会有相同的hashcode值。
/**
* 返回对象的hash码值， 支持此方法是为了有利于hash表，例如HashMap
* 1、在程序运行期间，在同一个对象上调用该方法，必须返回相同的整数，
* 2、这个整数不需要在下一次运行期间保持一致。
* 3、如果equals方法返回的两个对象相等，那么hashCode必须相等。
* 4、如果equlas方法能发挥的两个对象不相等，那么hashCode尽量产生不同的值，
* 因为这样可以避免指针碰撞而提高hash表的性能。
* 5、类Object定义的hashCode方法确实为不同对象返回不同整数，
* 这通常采用对象的内部地址转化为整数实现，Java编程语言不需要实现这个技术，native
*/
public native int hashCode();equals(Object obj)
- 比较是否有其它对象跟它相等
/**
* 比较是否有其它对象跟它相等
* 自反性：对于任何非空引用值x ， x.equals(x)应该返回true
* 对称性：对于任何非空引用值x和y ， x.equals(y)应返回true当且仅当y.equals(x)返回true
* 传递性：对于任何非空引用值x 、 y和z ，如果x.equals(y)返回true并且y.equals(z)返回true ，那么x.equals(z)应该返回true
* 一致性：对于任何非空引用值x和y ， x.equals(y)多次调用始终返回true或始终返回false ，前提是没有修改对象上的equals比较中使用的信息。
* 非空性：对于任何非空引用值x ， x.equals(null)应返回false
*
* 对于任何非空引用值x和y，当且仅当x和y引用同一个对象（ x == y的值为true ）时，此方法才返回true 。
*/
public boolean equals(Object obj) {
return (this == obj);
}clone()
- 用于创建并返回一个对象的拷贝（浅拷贝）
- 浅拷贝：只会拷贝引用地址，而不会将引用的对象重新分配内存，
- 深拷贝：会连引用的对象也重新创建。
/**
* 创建并返回此对象的一个副本.
* 通常来说：
* x.clone() != x //true
* x.clone().getClass() == x.getClass() //true
* x.clone().equals(x) //true
* Object类本身没有实现Cloneable接口，如果对object对象进行拷贝，则会抛出运行时异常
*/
protected native Object clone() throws CloneNotSupportedException;toString()
- 返回对象的字符串表现形式
/**
* 返回对象的字符串表示形式.
* 通常来说，推荐该方法返回一个易于人读的字符串，建议用户子类重写该方法
* 字符串由对象是其实例的类的名称@对象哈希码的无符号十六进制表示组成
*/
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}notify()
- 唤醒在此监视器上等待的线程
/**
* 唤醒在此监视器上等待的线程.
* 监视器：锁
* 如果有N个线程等待，那么随机唤醒一个优先级最高的线程
* 调用wait()方法可以让一个线程在对象监视器上等待
* 这个方法只能被获取到锁的线程调用，如何获得锁：
* 1、执行对象的同步实例方法
* 2、使用 synchronized 内置锁
* 3、对于 Class 类型的对象，执行同步静态方法
* 仅仅只有一个线程在同一时刻获取到锁
*/
public final native void notify();notifyAll()
/**
* 唤醒在此对象监视器上等待的所有线程.
* 被唤醒的线程不是立马投入工作，除非当前线程释放了锁资源，
* 被唤醒的线程，他们等待线程调度器分配锁资源，也就是争抢锁
* 该方法，只有获取到锁资源的对象，才能调用
*/
public final native void notifyAll();wait()
- 调用wait()方法，当前线程进入等待状态。
/**
* 调用wait()方法，当前线程进入等待状态。只有调用notify()和notifyAll()方法来唤醒
* 相当于调用了wait(0)
* 获得锁资源的线程，才能调用wait()方法，调用完成后，线程释放锁资源，然后线程等待重新获取锁并执行
* 使用方式：
* synchronized (obj) {
* while ()
* obj.wait();
* }
*/
public final void wait() throws InterruptedException {
wait(0);
}wait(long timeout)
/**
* 当前线程处在等待（阻塞）状态，除非调用notify()和notifyAll()方法或者时间到了被唤醒
*
* 如果超时时间为0，则不会超时，类似wait()
* synchronized (obj) {
* while ()
* obj.wait(timeout);
* }
*/
public final native void wait(long timeout) throws InterruptedException;wait(long timeout, int nanos)
/**
* 类似wait(long timeout) 额外多了个nanos的超时时间（纳秒）timeout+nanos
* nanos取之范围在 0-999999
* 如果wait(0,0) 则不会超时，相当于wait()
* synchronized (obj) {
* while ()
* obj.wait(timeout, nanos);
* }
*/
public final void wait(long timeout, int nanos) throws InterruptedException {
if (timeout < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}
if (nanos >= 500000 || (nanos != 0 && timeout == 0)) {
timeout++;
}
wait(timeout);
}finalize()
/**
* 用于垃圾回收器处理进行资源清理时使用
*/
protected void finalize() throws Throwable { }总结
2558
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
