Java基础之基础类

java java基础

String相关

hashCode()原理

hashcode
如何重写hashCode算法
hashCode 方法及 equals 方法的规范

关于相应的哈希算法，一个简单的算法如下:

• 永远不要让哈希算法返回一个常值，这时哈希表将退化成链表，查找时间复杂度也从 O(1) 退化到 O(N)
• 如果参数是boolean型，计算(f ? 1 : 0)
• 如果参数是byte, char, short或者int型，计算(int) f
• 如果参数是long型，计算(int) (f ^ (f >>> 32)) 高32位保持不变，低32位和高32位做异或
• 如果参数是float型，计算Float.floatToIntBits(f)
• 如果参数是double型，计算Double.doubleToLongBits(f)得到long类型的值，再根据公式计算出相应的hash值
• 如果参数是Object型，那么应计算其有用的成员变量的hash值，并按照下面的公式计算最终的hash值
• 如果参数是个数组，那么把数组中的每个值都当做单独的值，分别按照上面的方法单独计算hash值，最后按照下面的公式计算最终的hash值

组合公式：result = 31 * result + c

比如，String 类的 hashCode 方法如下（JDK 1.8）：

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;
}

equals()实现

原则

• 自反性（Reflexive）：一个对象与自身相等，即 x=x。对任何非空对象 x， x.equals(x) 必定为 true。
• 对称性（Symmetric）：对象之间的等价关系是可交换的，即 a=b⇔b=a。对任何非空对象 x、y， x.equals(y) 为 true，当且仅当 y.equals(x) 为 true。
• 传递性（Transitive）：(a=b)∧(b=c)⇒(a=c)。对任何非空对象 x、y、z， 若 x.equals(y) 为 true 且 y.equals(z) 为 true，则 x.equals(z) 为 true。

除了遵循这三原则之外，还要遵循：

• 一致性（Consistent）：对任何非空对象 x、y，只要所比较的信息未变，则连续调用 x.equals(y) 总是得到一致的结果。这要求了 equals 所依赖的值必须是可靠的。
• 对任何非空对象 x， x.equals(null) 必定为 false。

1、如果两个对象equals，Java运行时环境会认为他们的hashcode一定相等。
2、如果两个对象不equals，他们的hashcode有可能相等。
3、如果两个对象hashcode相等，他们不一定equals。
4、如果两个对象hashcode不相等，他们一定不equals。

string实现

value是一个char类型的数组，用于存放字符串中的每个字符
判断条件：

• 若当前对象和比较的对象是同一个对象，即return true。也就是Object中的equals方法。

• 若当前传入的对象是String类型，则比较两个字符串的长度，即value.length的长度。

  • 若长度不相同，则return false
  • 若长度相同，则按照数组value中的每一位进行比较，不同，则返回false。若每一位都相同，则返回true。
• 若当前传入的对象不是String类型，则直接返回false

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String) anObject;
        int n = length();
        if (n == anotherString.length()) {
            int i = 0;
            while (n-- != 0) {
                if (charAt(i) != anotherString.charAt(i))
                        return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

Object相关

深拷贝&浅拷贝

Java 浅拷贝和深拷贝的理解和实现方式

浅拷贝

• 对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。因为是两份不同的数据，所以对其中一个对象的该成员变量值进行修改，不会影响另一个对象拷贝得到的数据。
• 对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。

实现方式

• 拷贝构造方法指的是该类的构造方法参数为该类的对象。使用拷贝构造方法可以很好地完成浅拷贝，直接通过一个现有的对象创建出与该对象属性相同的新的对象。
• 通过重写clone()方法进行浅拷贝
  1、Object类虽然有这个方法，但是这个方法是受保护的（被protected修饰），所以我们无法直接使用。
  2、使用clone方法的类必须实现Cloneable接口，否则会抛出异常CloneNotSupportedException。
  对于这两点，我们的解决方法是，在要使用clone方法的类中重写clone()方法，通过super.clone()调用Object类中的原clone方法。

深拷贝

对于深拷贝来说，不仅要复制对象的所有基本数据类型的成员变量值，还要为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。

实现方式

• 通过重写clone方法来实现深拷贝
  每一层的每个对象都进行浅拷贝=深拷贝。最后在最顶层的类的重写的clone方法中调用所有的clone方法即可实现深拷贝

• 通过对象序列化实现深拷贝
  将对象序列化为字节序列后，默认会将该对象的整个对象图进行序列化，再通过反序列即可完美地实现深拷贝。
  要注意的是，如果某个属性被transient修饰，那么该属性就无法被拷贝了。