2. Java泛型、equals()、hashcode

博客链接： Coding Lemon’s blog Java知识、面试总结、LeetCode题目解析等持续更新

1.泛型

  Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
  Java的泛型是伪泛型，这是因为Java在编译期间，所有的泛型信息都会被擦掉，这也就是通常所说类型擦除 。

List<Integer> list = new ArrayList<>();

list.add(12);
//这里直接添加会报错
list.add("a");
Class<? extends List> clazz = list.getClass();
Method add = clazz.getDeclaredMethod("add", Object.class);
//但是通过反射添加，是可以的
add.invoke(list, "kl");

System.out.println(list);

泛型一般有三种使用方式:泛型类、泛型接口、泛型方法。

1.1 泛型类

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic<T>{ 
   
    private T key;

    public Generic(T key) { 
        this.key = key;
    }

    public T getKey(){ 
        return key;
    }
}
//实例化泛型
Generic<Integer> genericInteger = new Generic<Integer>(123456);

1.2 泛型接口

public interface Generator<T> {
    public T method();
}

实现泛型接口，不指定类型：

class GeneratorImpl<T> implements Generator<T>{
    @Override
    public T method() {
        return null;
    }
}

实现泛型接口，指定类型：

class GeneratorImpl<T> implements Generator<String>{
    @Override
    public String method() {
        return "hello";
    }
}

1.3 泛型方法

   public static < E > void printArray( E[] inputArray )
   {         
         for ( E element : inputArray ){        
            System.out.printf( "%s ", element );
         }
         System.out.println();
    }

使用：

// 创建不同类型数组： Integer, Double 和 Character
Integer[] intArray = { 1, 2, 3 };
String[] stringArray = { "Hello", "World" };
printArray( intArray  ); 
printArray( stringArray  ); 

常用的通配符为： T，E，K，V，？

• ？ 表示不确定的 java 类型
• T (type) 表示具体的一个java类型
• K V (key value) 分别代表java键值中的Key Value
• E (element) 代表Element

2. ==和equals()的区别

   == 比较的是两个对象的地址是不是相等，即判断两个对象是不是同一个对象。（基本数据类型== 比较的是值相等，引用数据类型==比较的是内存地址）

  因为 Java 只有值传递，所以，对于 == 来说，不管是比较基本数据类型，还是引用数据类型的变量，其本质比较的都是值，只是引用类型变量存的值是对象的地址。
  equals()也用于判断两个对象是否相等，它不能用于比较基本数据类型的变量。
  equals()方法存在两种使用情况：

• 情况1：类没有覆盖equals()方法。则通过equals()比较该类的两个对象时，等价于通过“== ”比较这两个对象。使用的默认是 Object类equals()方法(其实也是 == 判断)。

public boolean equals(Object obj) {
     return (this == obj);
}

• 情况 2：类覆盖了 equals()方法。一般，我们都覆盖 equals()方法来判断两个对象的内容相等；若它们的内容相等，则返回 true(即，认为这两个对象相等)。
  举例：

public class test1 {
    public static void main(String[] args) {
        String a = new String("ab"); // a 为一个引用
        String b = new String("ab"); // b为另一个引用,对象的内容一样
        String aa = "ab"; // 放在常量池中
        String bb = "ab"; // 从常量池中查找
        if (aa == bb) // true
            System.out.println("aa==bb");
        if (a == b) // false，非同一对象
            System.out.println("a==b");
        if (a.equals(b)) // true
            System.out.println("aEQb");
        if (42 == 42.0) { // true
            System.out.println("true");
        }
    }
}

附上String的equals()写法：

public boolean equals(Object anObject) {
    //如果是同一个对象，返回true
    if (this == anObject) {
        return true;
    }
    //必须是String类型的
    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;
}

3.equals与hashCode

3.1 hashCode()介绍

  hashCode()的作用是获取hash码，也称散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在hash表中的索引位置。hashCode定义在JDK的Object类种，这就意味着java中的任何类都包含有hashCode()函数。另外要注意的是：Object的hashCode方法是本地方法，该方法通常用啦将对象的内存地址转换为整数之后返回。

public native int hashCode();

散列表存储的是键值对（k-v），它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码。（可以快速找到所需要的的对象）

3.2 为什么要有hashCode

当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashcode 值作比较，如果没有相符的 hashcode，HashSet 会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调用 equals() 方法来检查 hashcode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。

3.3 为什么重写equals时必须重写hashCode方法？

  假如只重写equals而不重写hashcode，那么该类的hashcode方法就是Object默认的hashcode方法，由于默认的hashcode方法是根据对象的内存地址经哈希算法得来的，显然此时两个具有相同内容的对象不相等,故两者的hashcode不一定相等。
  然而重写了equals，且obj1.equals(obj2)返回true，根据hashcode的规则，两个对象相等其哈希值一定相等，所以矛盾就产生了，因此重写equals一定要重写hashcode，而且从该类重写后的hashcode方法中可以看出，重写后返回的新的哈希值与Student的两个属性有关。

关于hashcode的一些规定：

• 两个对象相等，hashcode一定相等
• 两个对象不等，hashcode不一定不等
• hashcode相等，两个对象不一定相等
• hashcode不等，两个对象一定不等

摘自https://github.com/Snailclimb/JavaGuide