Java从萌新小白到顶级大牛(5完结)

处理注解

Java的注解本身对代码逻辑没有任何影响。根据@Retention的配置：

• SOURCE类型的注解在编译期就被丢掉了；
• CLASS类型的注解仅保存在class文件中，它们不会被加载进JVM；
• RUNTIME类型的注解会被加载进JVM，并且在运行期可以被程序读取。

如何使用注解完全由工具决定。SOURCE类型的注解主要由编译器使用，因此我们一般只使用，不编写。CLASS类型的注解主要由底层工具库使用，涉及到class的加载，一般我们很少用到。只有RUNTIME类型的注解不但要使用，还经常需要编写。

因此，我们只讨论如何读取RUNTIME类型的注解。

因为注解定义后也是一种class，所有的注解都继承自java.lang.annotation.Annotation，因此，读取注解，需要使用反射API。

Java提供的使用反射API读取Annotation的方法包括：

判断某个注解是否存在于Class、Field、Method或Constructor：

• Class.isAnnotationPresent(Class)
• Field.isAnnotationPresent(Class)
• Method.isAnnotationPresent(Class)
• Constructor.isAnnotationPresent(Class)

例如：

// 判断@Report是否存在于Person类:

Person.class.isAnnotationPresent(Report.class);

使用反射API读取Annotation：

• Class.getAnnotation(Class)
• Field.getAnnotation(Class)
• Method.getAnnotation(Class)
• Constructor.getAnnotation(Class)

例如：

// 获取Person定义的@Report注解:

Report report = Person.class.getAnnotation(Report.class);

int type = report.type();

String level = report.level();

使用反射API读取Annotation有两种方法。方法一是先判断Annotation是否存在，如果存在，就直接读取：

Class cls = Person.class;if (cls.isAnnotationPresent(Report.class)) {

    Report report = cls.getAnnotation(Report.class);

    ...

}

第二种方法是直接读取Annotation，如果Annotation不存在，将返回null：

Class cls = Person.class;Report report = cls.getAnnotation(Report.class);if (report != null) {

   ...

}

读取方法、字段和构造方法的Annotation和Class类似。但要读取方法参数的Annotation就比较麻烦一点，因为方法参数本身可以看成一个数组，而每个参数又可以定义多个注解，所以，一次获取方法参数的所有注解就必须用一个二维数组来表示。例如，对于以下方法定义的注解：

public void hello(@NotNull @Range(max=5) String name, @NotNull String prefix) {

}

要读取方法参数的注解，我们先用反射获取Method实例，然后读取方法参数的所有注解：

// 获取Method实例:

Method m = ...// 获取所有参数的Annotation:

Annotation[][] annos = m.getParameterAnnotations();// 第一个参数（索引为0）的所有Annotation:

Annotation[] annosOfName = annos[0];for (Annotation anno : annosOfName) {

    if (anno instanceof Range r) { // @Range注解

        r.max();

    }

    if (anno instanceof NotNull n) { // @NotNull注解

        //

    }

}

使用注解

注解如何使用，完全由程序自己决定。例如，JUnit是一个测试框架，它会自动运行所有标记为@Test的方法。

我们来看一个@Range注解，我们希望用它来定义一个String字段的规则：字段长度满足@Range的参数定义：

@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.FIELD)public @interface Range {

    int min() default 0;

    int max() default 255;

}

在某个JavaBean中，我们可以使用该注解：

public class Person {

    @Range(min=1, max=20)

    public String name;



    @Range(max=10)

    public String city;

}

但是，定义了注解，本身对程序逻辑没有任何影响。我们必须自己编写代码来使用注解。这里，我们编写一个Person实例的检查方法，它可以检查Person实例的String字段长度是否满足@Range的定义：

void check(Person person) throws IllegalArgumentException, ReflectiveOperationException {

    // 遍历所有Field:

    for (Field field : person.getClass().getFields()) {

        // 获取Field定义的@Range:

        Range range = field.getAnnotation(Range.class);

        // 如果@Range存在:

        if (range != null) {

            // 获取Field的值:

            Object value = field.get(person);

            // 如果值是String:

            if (value instanceof String s) {

                // 判断值是否满足@Range的min/max:

                if (s.length() < range.min() || s.length() > range.max()) {

                    throw new IllegalArgumentException("Invalid field: " + field.getName());

                }

            }

        }

    }

}

这样一来，我们通过@Range注解，配合check()方法，就可以完成Person实例的检查。注意检查逻辑完全是我们自己编写的，JVM不会自动给注解添加任何额外的逻辑。

练习

使用@Range注解来检查Java Bean的字段。如果字段类型是String，就检查String的长度，如果字段是int，就检查int的范围。

小结

可以在运行期通过反射读取RUNTIME类型的注解，注意千万不要漏写@Retention(RetentionPolicy.RUNTIME)，否则运行期无法读取到该注解。

可以通过程序处理注解来实现相应的功能：

• 对JavaBean的属性值按规则进行检查；
• JUnit会自动运行@Test标记的测试方法。

泛型

泛型是一种“代码模板”，可以用一套代码套用各种类型。

本节我们详细讨论Java的泛型编程。

什么是泛型

在讲解什么是泛型之前，我们先观察Java标准库提供的ArrayList，它可以看作“可变长度”的数组，因为用起来比数组更方便。

实际上ArrayList内部就是一个Object[]数组，配合存储一个当前分配的长度，就可以充当“可变数组”：

public class ArrayList {

    private Object[] array;

    private int size;

    public void add(Object e) {...}

    public void remove(int index) {...}

    public Object get(int index) {...}

}

如果用上述ArrayList存储String类型，会有这么几个缺点：

需要强制转型；

不方便，易出错。

例如，代码必须这么写：

ArrayList list = new ArrayList();list.add("Hello");// 获取到Object，必须强制转型为String:

String first = (String) list.get(0);

很容易出现ClassCastException，因为容易“误转型”：

list.add(new Integer(123));// ERROR: ClassCastException:

String second = (String) list.get(1);

要解决上述问题，我们可以为String单独编写一种ArrayList：

public class StringArrayList {

    private String[] array;

    private int size;

    public void add(String e) {...}

    public void remove(int index) {...}

    public String get(int index) {...}

}

这样一来，存入的必须是String，取出的也一定是String，不需要强制转型，因为编译器会强制检查放入的类型：

StringArrayList list = new StringArrayList();list.add("Hello");

String first = list.get(0);// 编译错误: 不允许放入非String类型:list.add(new Integer(123));

问题暂时解决。

然而，新的问题是，如果要存储Integer，还需要为Integer单独编写一种ArrayList：

public class IntegerArrayList {

    private Integer[] array;

    private int size;

    public void add(Integer e) {...}

    public void remove(int index) {...}

    public Integer get(int index) {...}

}

实际上，还需要为其他所有class单独编写一种ArrayList：

• LongArrayList
• DoubleArrayList
• PersonArrayList
• ...

这是不可能的，JDK的class就有上千个，而且它还不知道其他人编写的class。

为了解决新的问题，我们必须把ArrayList变成一种模板：ArrayList<T>，代码如下：

public class ArrayList<T> {

    private T[] array;

    private int size;

    public void add(T e) {...}

    public void remove(int index) {...}

    public T get(int index) {...}

}

T可以是任何class。这样一来，我们就实现了：编写一次模版，可以创建任意类型的ArrayList：

// 创建可以存储String的ArrayList:

ArrayList<String> strList = new ArrayList<String>();

// 创建可以存储Float的ArrayList:

ArrayList<Float> floatList = new ArrayList<Float>();

// 创建可以存储Person的ArrayList:

ArrayList<Person> personList = new ArrayList<Person>();

因此，泛型就是定义一种模板，例如ArrayList<T>，然后在代码中为用到的类创建对应的ArrayList<类型>：

ArrayList<String> strList = new ArrayList<String>();

由编译器针对类型作检查：

strList.add("hello"); // OK

String s = strList.get(0); // OK

strList.add(new Integer(123)); // compile error!

Integer n = strList.get(0); // compile error!

这样一来，既实现了编写一次，万能匹配，又通过编译器保证了类型安全：这就是泛型。

向上转型

在Java标准库中的ArrayList<T>实现了List<T>接口，它可以向上转型为List<T>：

public class ArrayList<T> implements List<T> {

    ...

}



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

即类型ArrayList<T>可以向上转型为List<T>。

要特别注意：不能把ArrayList<Integer>向上转型为ArrayList<Number>或List<Number>。

这是为什么呢？假设ArrayList<Integer>可以向上转型为ArrayList<Number>，观察一下代码：

// 创建ArrayList<Integer>类型：

ArrayList<Integer> integerList = new ArrayList<Integer>();

// 添加一个Integer：

integerList.add(new Integer(123));

// “向上转型”为ArrayList<Number>：

ArrayList<Number> numberList = integerList;

// 添加一个Float，因为Float也是Number：

numberList.add(new Float(12.34));

// 从ArrayList<Integer>获取索引为1的元素（即添加的Float）：

Integer n = integerList.get(1); // ClassCastException!

我们把一个ArrayList<Integer>转型为ArrayList<Number>类型后，这个ArrayList<Number>就可以接受Float类型，因为Float是Number的子类。但是，ArrayList<Number>实际上和ArrayList<Integer>是同一个对象，也就是ArrayList<Integer>类型，它不可能接受Float类型， 所以在获取Integer的时候将产生ClassCastException。

实际上，编译器为了避免这种错误，根本就不允许把ArrayList<Integer>转型为ArrayList<Number>。

 ArrayList<Integer>和ArrayList<Number>两者完全没有继承关系。

小结

泛型就是编写模板代码来适应任意类型；

泛型的好处是使用时不必对类型进行强制转换，它通过编译器对类型进行检查；

注意泛型的继承关系：可以把ArrayList<Integer>向上转型为List<Integer>（T不能变！），但不能把ArrayList<Integer>向上转型为ArrayList<Number>（T不能变成父类）。

使用泛型

使用ArrayList时，如果不定义泛型类型时，泛型类型实际上就是Object：

// 编译器警告:List list = new ArrayList();list.add("Hello");list.add("World");

String first = (String) list.get(0);

String second = (String) list.get(1);

此时，只能把<T>当作Object使用，没有发挥泛型的优势。

当我们定义泛型类型<String>后，List<T>的泛型接口变为强类型List<String>：

// 无编译器警告:List<String> list = new ArrayList<String>();list.add("Hello");list.add("World");// 无强制转型:

String first = list.get(0);

String second = list.get(1);

当我们定义泛型类型<Number>后，List<T>的泛型接口变为强类型List<Number>：

List<Number> list = new ArrayList<Number>();list.add(new Integer(123));list.add(new Double(12.34));

Number first = list.get(0);

Number second = list.get(1);

编译器如果能自动推断出泛型类型，就可以省略后面的泛型类型。例如，对于下面的代码：

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

编译器看到泛型类型List<Number>就可以自动推断出后面的ArrayList<T>的泛型类型必须是ArrayList<Number>，因此，可以把代码简写为：

// 可以省略后面的Number，编译器可以自动推断泛型类型：

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

泛型接口

除了ArrayList<T>使用了泛型，还可以在接口中使用泛型。例如，Arrays.sort(Object[])可以对任意数组进行排序，但待排序的元素必须实现Comparable<T>这个泛型接口：

public interface Comparable<T> {

    /**

     * 返回负数: 当前实例比参数o小

     * 返回0: 当前实例与参数o相等

     * 返回正数: 当前实例比参数o大

     */

    int compareTo(T o);

}

可以直接对String数组进行排序：

// sort

import java.util.Arrays;



public class Main {

    public static void main(String[] args) {

        String[] ss = new String[] { "Orange", "Apple", "Pear" };

        Arrays.sort(ss);

        System.out.println(Arrays.toString(ss));



    }

}

这是因为String本身已经实现了Comparable<String>接口。如果换成我们自定义的Person类型试试：

// sort

import java.util.Arrays;



public class Main {

    public static void main(String[] args) {

        Person[] ps = new Person[] {

            new Person("Bob", 61),

            new Person("Alice", 88),

            new Person("Lily", 75),

        };

        Arrays.sort(ps);

        System.out.println(Arrays.toString(ps));



    }

}



class Person {

    String name;

    int score;

    Person(String name, int score) {

        this.name = name;

        this.score = score;

    }

    public String toString() {

        return this.name + "," + this.score;

    }

}

运行程序，我们会得到ClassCastException，即无法将Person转型为Comparable。我们修改代码，让Person实现Comparable<T>接口：

// sort

import java.util.Arrays;



public class Main {

    public static void main(String[] args) {

        Person[] ps = new Person[] {

            new Person("Bob", 61),

            new Person("Alice", 88),

            new Person("Lily", 75),

        };

        Arrays.sort(ps);

        System.out.println(Arrays.toString(ps));

    }

}



class Person implements Comparable<Person> {

    String name;

    int score;

    Person(String name, int score) {

        this.name = name;

        this.score = score;

    }

    public int compareTo(Person other) {

        return this.name.compareTo(other.name);

    }

    public String toString() {

        return this.name + "," + this.score;

    }

}

运行上述代码，可以正确实现按name进行排序。

也可以修改比较逻辑，例如，按score从高到低排序。请自行修改测试。

小结

使用泛型时，把泛型参数<T>替换为需要的class类型，例如：ArrayList<String>，ArrayList<Number>等；

可以省略编译器能自动推断出的类型，例如：List<String> list = new ArrayList<>();；

不指定泛型参数类型时，编译器会给出警告，且只能将<T>视为Object类型；

可以在接口中定义泛型类型，实现此接口的类必须实现正确的泛型类型。

编写泛型

编写泛型类比普通类要复杂。通常来说，泛型类一般用在集合类中，例如ArrayList<T>，我们很少需要编写泛型类。

如果我们确实需要编写一个泛型类，那么，应该如何编写它？

可以按照以下步骤来编写一个泛型类。

首先，按照某种类型，例如：String，来编写类：

public class Pair {

    private String first;

    private String last;

    public Pair(String first, String last) {

        this.first = first;

        this.last = last;

    }

    public String getFirst() {

        return first;

    }

    public String getLast() {

        return last;

    }

}

然后，标记所有的特定类型，这里是String：

public class Pair {

    private String first;

    private String last;

    public Pair(String first, String last) {

        this.first = first;

        this.last = last;

    }

    public String getFirst() {

        return first;

    }

    public String getLast() {

        return last;

    }

}

最后，把特定类型String替换为T，并申明<T>：

public class Pair<T> {

    private T first;

    private T last;

    public Pair(T first, T last) {

        this.first = first;

        this.last = last;

    }

    public T getFirst() {

        return first;

    }

    public T getLast() {

        return last;

    }

}

熟练后即可直接从T开始编写。

静态方法

编写泛型类时，要特别注意，泛型类型<T>不能用于静态方法。例如：

public class Pair<T> {

    private T first;

    private T last;

    public Pair(T first, T last) {

        this.first = first;

        this.last = last;

    }

    public T getFirst() { ... }

    public T getLast() { ... }



    // 对静态方法使用<T>:

    public static Pair<T> create(T first, T last) {

        return new Pair<T>(first, last);

    }

}

上述代码会导致编译错误，我们无法在静态方法create()的方法参数和返回类型上使用泛型类型T。

有些同学在网上搜索发现，可以在static修饰符后面加一个<T>，编译就能通过：

public class Pair<T> {

    private T first;

    private T last;

    public Pair(T first, T last) {

        this.first = first;

        this.last = last;

    }

    public T getFirst() { ... }

    public T getLast() { ... }



    // 可以编译通过:

    public static <T> Pair<T> create(T first, T last) {

        return new Pair<T>(first, last);

    }

}

但实际上，这个<T>和Pair<T>类型的<T>已经没有任何关系了。

对于静态方法，我们可以单独改写为“泛型”方法，只需要使用另一个类型即可。对于上面的create()静态方法，我们应该把它改为另一种泛型类型，例如，<K>：

public class Pair<T> {

    private T first;

    private T last;

    public Pair(T first, T last) {

        this.first = first;

        this.last = last;

    }

    public T getFirst() { ... }

    public T getLast() { ... }



    // 静态泛型方法应该使用其他类型区分:

    public static <K> Pair<K> create(K first, K last) {

        return new Pair<K>(first, last);

    }

}

这样才能清楚地将静态方法的泛型类型和实例类型的泛型类型区分开。

多个泛型类型

泛型还可以定义多种类型。例如，我们希望Pair不总是存储两个类型一样的对象，就可以使用类型<T, K>：

public class Pair<T, K> {

    private T first;

    private K last;

    public Pair(T first, K last) {

        this.first = first;

        this.last = last;

    }

    public T getFirst() { ... }

    public K getLast() { ... }

}

使用的时候，需要指出两种类型：

Pair<String, Integer> p = new Pair<>("test", 123);

Java标准库的Map<K, V>就是使用两种泛型类型的例子。它对Key使用一种类型，对Value使用另一种类型。

小结

编写泛型时，需要定义泛型类型<T>；

静态方法不能引用泛型类型<T>，必须定义其他类型（例如<K>）来实现静态泛型方法；

泛型可以同时定义多种类型，例如Map<K, V>。

擦拭法

泛型是一种类似”模板代码“的技术，不同语言的泛型实现方式不一定相同。

Java语言的泛型实现方式是擦拭法（Type Erasure）。

所谓擦拭法是指，虚拟机对泛型其实一无所知，所有的工作都是编译器做的。

例如，我们编写了一个泛型类Pair<T>，这是编译器看到的代码：

public class Pair<T> {

    private T first;

    private T last;

    public Pair(T first, T last) {

        this.first = first;

        this.last = last;

    }

    public T getFirst() {

        return first;

    }

    public T getLast() {

        return last;

    }

}

而虚拟机根本不知道泛型。这是虚拟机执行的代码：

public class Pair {

    private Object first;

    private Object last;

    public Pair(Object first, Object last) {

        this.first = first;

        this.last = last;

    }

    public Object getFirst() {

        return first;

    }

    public Object getLast() {

        return last;

    }

}

因此，Java使用擦拭法实现泛型，导致了：

• 编译器把类型<T>视为Object；
• 编译器根据<T>实现安全的强制转型。

使用泛型的时候，我们编写的代码也是编译器看到的代码：

Pair<String> p = new Pair<>("Hello", "world");

String first = p.getFirst();

String last = p.getLast();

而虚拟机执行的代码并没有泛型：

Pair p = new Pair("Hello", "world");

String first = (String) p.getFirst();

String last = (String) p.getLast();

所以，Java的泛型是由编译器在编译时实行的，编译器内部永远把所有类型T视为Object处理，但是，在需要转型的时候，编译器会根据T的类型自动为我们实行安全地强制转型。

了解了Java泛型的实现方式——擦拭法，我们就知道了Java泛型的局限：

局限一：<T>不能是基本类型，例如int，因为实际类型是Object，Object类型无法持有基本类型：

Pair<int> p = new Pair<>(1, 2); // compile error!

局限二：无法取得带泛型的Class。观察以下代码：

public class Main {

    public static void main(String[] args) {

        Pair<String> p1 = new Pair<>("Hello", "world");

        Pair<Integer> p2 = new Pair<>(123, 456);

        Class c1 = p1.getClass();

        Class c2 = p2.getClass();

        System.out.println(c1==c2); // true

        System.out.println(c1==Pair.class); // true



    }

}



class Pair<T> {

    private T first;

    private T last;

    public Pair(T first, T last) {

        this.first = first;

        this.last = last;

    }

    public T getFirst() {

        return first;

    }

    public T getLast() {

        return last;

    }

}

因为T是Object，我们对Pair<String>和Pair<Integer>类型获取Class时，获取到的是同一个Class，也就是Pair类的Class。

换句话说，所有泛型实例，无论T的类型是什么，getClass()返回同一个Class实例，因为编译后它们全部都是Pair<Object>。

局限三：无法判断带泛型的类型：

Pair<Integer> p = new Pair<>(123, 456);

// Compile error:

if (p instanceof Pair<String>) {

}

原因和前面一样，并不存在Pair<String>.class，而是只有唯一的Pair.class。

局限四：不能实例化T类型：

public class Pair<T> {

    private T first;

    private T last;

    public Pair() {

        // Compile error:

        first = new T();

        last = new T();

    }

}

上述代码无法通过编译，因为构造方法的两行语句：

first = new T();last = new T();

擦拭后实际上变成了：

first = new Object();last = new Object();

这样一来，创建new Pair<String>()和创建new Pair<Integer>()就全部成了Object，显然编译器要阻止这种类型不对的代码。

要实例化T类型，我们必须借助额外的Class<T>参数：

public class Pair<T> {

    private T first;

    private T last;

    public Pair(Class<T> clazz) {

        first = clazz.newInstance();

        last = clazz.newInstance();

    }

}

上述代码借助Class<T>参数并通过反射来实例化T类型，使用的时候，也必须传入Class<T>。例如：

Pair<String> pair = new Pair<>(String.class);

因为传入了Class<String>的实例，所以我们借助String.class就可以实例化String类型。

不恰当的覆写方法

有些时候，一个看似正确定义的方法会无法通过编译。例如：

public class Pair<T> {

    public boolean equals(T t) {

        return this == t;

    }

}

这是因为，定义的equals(T t)方法实际上会被擦拭成equals(Object t)，而这个方法是继承自Object的，编译器会阻止一个实际上会变成覆写的泛型方法定义。

换个方法名，避开与Object.equals(Object)的冲突就可以成功编译：

public class Pair<T> {

    public boolean same(T t) {

        return this == t;

    }

}

泛型继承

一个类可以继承自一个泛型类。例如：父类的类型是Pair<Integer>，子类的类型是IntPair，可以这么继承：

public class IntPair extends Pair<Integer> {

}

使用的时候，因为子类IntPair并没有泛型类型，所以，正常使用即可：

IntPair ip = new IntPair(1, 2);

前面讲了，我们无法获取Pair<T>的T类型，即给定一个变量Pair<Integer> p，无法从p中获取到Integer类型。

但是，在父类是泛型类型的情况下，编译器就必须把类型T（对IntPair来说，也就是Integer类型）保存到子类的class文件中，不然编译器就不知道IntPair只能存取Integer这种类型。

在继承了泛型类型的情况下，子类可以获取父类的泛型类型。例如：IntPair可以获取到父类的泛型类型Integer。获取父类的泛型类型代码比较复杂：

import java.lang.reflect.ParameterizedType;

import java.lang.reflect.Type;



public class Main {

    public static void main(String[] args) {

        Class<IntPair> clazz = IntPair.class;

        Type t = clazz.getGenericSuperclass();

        if (t instanceof ParameterizedType) {

            ParameterizedType pt = (ParameterizedType) t;

            Type[] types = pt.getActualTypeArguments(); // 可能有多个泛型类型

            Type firstType = types[0]; // 取第一个泛型类型

            Class<?> typeClass = (Class<?>) firstType;

            System.out.println(typeClass); // Integer

        }



    }

}



class Pair<T> {

    private T first;

    private T last;

    public Pair(T first, T last) {

        this.first = first;

        this.last = last;

    }

    public T getFirst() {

        return first;

    }

    public T getLast() {

        return last;

    }

}



class IntPair extends Pair<Integer> {

    public IntPair(Integer first, Integer last) {

        super(first, last);

    }

}

因为Java引入了泛型，所以，只用Class来标识类型已经不够了。实际上，Java的类型系统结构如下：

                      ┌────┐
                      │Type│
                      └────┘
                         ▲
                         │
   ┌────────────┬────────┴─────────┬───────────────┐
   │            │                  │               │
┌─────┐┌─────────────────┐┌────────────────┐┌────────────┐
│Class││ParameterizedType││GenericArrayType││WildcardType│
└─────┘└─────────────────┘└────────────────┘└────────────┘

小结

Java的泛型是采用擦拭法实现的；

擦拭法决定了泛型<T>：

• 不能是基本类型，例如：int；
• 不能获取带泛型类型的Class，例如：Pair<String>.class；
• 不能判断带泛型类型的类型，例如：x instanceof Pair<String>；
• 不能实例化T类型，例如：new T()。

泛型方法要防止重复定义方法，例如：public boolean equals(T obj)；

子类可以获取父类的泛型类型<T>。

extends通配符

我们前面已经讲到了泛型的继承关系：Pair<Integer>不是Pair<Number>的子类。

假设我们定义了Pair<T>：

public class Pair<T> { ... }

然后，我们又针对Pair<Number>类型写了一个静态方法，它接收的参数类型是Pair<Number>：

public class PairHelper {

    static int add(Pair<Number> p) {

        Number first = p.getFirst();

        Number last = p.getLast();

        return first.intValue() + last.intValue();

    }

}

上述代码是可以正常编译的。使用的时候，我们传入：

int sum = PairHelper.add(new Pair<Number>(1, 2));

注意：传入的类型是Pair<Number>，实际参数类型是(Integer, Integer)。

既然实际参数是Integer类型，试试传入Pair<Integer>：

public class Main {

    public static void main(String[] args) {

        Pair<Integer> p = new Pair<>(123, 456);

        int n = add(p);

        System.out.println(n);

    }



    static int add(Pair<Number> p) {

        Number first = p.getFirst();

        Number last = p.getLast();

        return first.intValue() + last.intValue();

    }



}



class Pair<T> {

    private T first;

    private T last;

    public Pair(T first, T last) {

        this.first = first;

        this.last = last;

    }

    public T getFirst() {

        return first;

    }

    public T getLast() {

        return last;

    }

}

直接运行，会得到一个编译错误：

incompatible types: Pair<Integer> cannot be converted to Pair<Number>

原因很明显，因为Pair<Integer>不是Pair<Number>的子类，因此，add(Pair<Number>)不接受参数类型Pair<Integer>。

但是从add()方法的代码可知，传入Pair<Integer>是完全符合内部代码的类型规范，因为语句：

Number first = p.getFirst();

Number last = p.getLast();

实际类型是Integer，引用类型是Number，没有问题。问题在于方法参数类型定死了只能传入Pair<Number>。

有没有办法使得方法参数接受Pair<Integer>？办法是有的，这就是使用Pair<? extends Number>使得方法接收所有泛型类型为Number或Number子类的Pair类型。我们把代码改写如下：

public class Main {

    public static void main(String[] args) {

        Pair<Integer> p = new Pair<>(123, 456);

        int n = add(p);

        System.out.println(n);

    }



    static int add(Pair<? extends Number> p) {

        Number first = p.getFirst();

        Number last = p.getLast();

        return first.intValue() + last.intValue();

    }



}



class Pair<T> {

    private T first;

    private T last;

    public Pair(T first, T last) {

        this.first = first;

        this.last = last;

    }

    public T getFirst() {

        return first;

    }

    public T getLast() {

        return last;

    }

}

这样一来，给方法传入Pair<Integer>类型时，它符合参数Pair<? extends Number>类型。这种使用<? extends Number>的泛型定义称之为上界通配符（Upper Bounds Wildcards），即把泛型类型T的上界限定在Number了。

除了可以传入Pair<Integer>类型，我们还可以传入Pair<Double>类型，Pair<BigDecimal>类型等等，因为Double和BigDecimal都是Number的子类。

如果我们考察对Pair<? extends Number>类型调用getFirst()方法，实际的方法签名变成了：

<? extends Number> getFirst();

即返回值是Number或Number的子类，因此，可以安全赋值给Number类型的变量：

Number x = p.getFirst();

然后，我们不可预测实际类型就是Integer，例如，下面的代码是无法通过编译的：

Integer x = p.getFirst();

这是因为实际的返回类型可能是Integer，也可能是Double或者其他类型，编译器只能确定类型一定是Number的子类（包括Number类型本身），但具体类型无法确定。

我们再来考察一下Pair<T>的set方法：

public class Main {

    public static void main(String[] args) {

        Pair<Integer> p = new Pair<>(123, 456);

        int n = add(p);

        System.out.println(n);

    }



    static int add(Pair<? extends Number> p) {

        Number first = p.getFirst();

        Number last = p.getLast();

        p.setFirst(new Integer(first.intValue() + 100));

        p.setLast(new Integer(last.intValue() + 100));

        return p.getFirst().intValue() + p.getFirst().intValue();

    }



}



class Pair<T> {

    private T first;

    private T last;



    public Pair(T first, T last) {

        this.first = first;

        this.last = last;

    }



    public T getFirst() {

        return first;

    }

    public T getLast() {

        return last;

    }

    public void setFirst(T first) {

        this.first = first;

    }

    public void setLast(T last) {

        this.last = last;

    }

}

不出意外，我们会得到一个编译错误：

incompatible types: Integer cannot be converted to CAP#1

where CAP#1 is a fresh type-variable:

    CAP#1 extends Number from capture of ? extends Number

编译错误发生在p.setFirst()传入的参数是Integer类型。有些童鞋会问了，既然p的定义是Pair<? extends Number>，那么setFirst(? extends Number)为什么不能传入Integer？

原因还在于擦拭法。如果我们传入的p是Pair<Double>，显然它满足参数定义Pair<? extends Number>，然而，Pair<Double>的setFirst()显然无法接受Integer类型。

这就是<? extends Number>通配符的一个重要限制：方法参数签名setFirst(? extends Number)无法传递任何Number的子类型给setFirst(? extends Number)。

这里唯一的例外是可以给方法参数传入null：

p.setFirst(null); // ok, 但是后面会抛出NullPointerException

p.getFirst().intValue(); // NullPointerException

extends通配符的作用

如果我们考察Java标准库的java.util.List<T>接口，它实现的是一个类似“可变数组”的列表，主要功能包括：

public interface List<T> {

    int size(); // 获取个数

    T get(int index); // 根据索引获取指定元素

    void add(T t); // 添加一个新元素

    void remove(T t); // 删除一个已有元素

}

现在，让我们定义一个方法来处理列表的每个元素：

int sumOfList(List<? extends Integer> list) {

    int sum = 0;

    for (int i=0; i<list.size(); i++) {

        Integer n = list.get(i);

        sum = sum + n;

    }

    return sum;

}

为什么我们定义的方法参数类型是List<? extends Integer>而不是List<Integer>？从方法内部代码看，传入List<? extends Integer>或者List<Integer>是完全一样的，但是，注意到List<? extends Integer>的限制：

• 允许调用get()方法获取Integer的引用；
• 不允许调用set(? extends Integer)方法并传入任何Integer的引用（null除外）。

因此，方法参数类型List<? extends Integer>表明了该方法内部只会读取List的元素，不会修改List的元素（因为无法调用add(? extends Integer)、remove(? extends Integer)这些方法。换句话说，这是一个对参数List<? extends Integer>进行只读的方法（恶意调用set(null)除外）。

使用extends限定T类型

在定义泛型类型Pair<T>的时候，也可以使用extends通配符来限定T的类型：

public class Pair<T extends Number> { ... }

现在，我们只能定义：

Pair<Number> p1 = null;

Pair<Integer> p2 = new Pair<>(1, 2);

Pair<Double> p3 = null;

因为Number、Integer和Double都符合<T extends Number>。

非Number类型将无法通过编译：

Pair<String> p1 = null; // compile error!

Pair<Object> p2 = null; // compile error!

因为String、Object都不符合<T extends Number>，因为它们不是Number类型或Number的子类。

小结

使用类似<? extends Number>通配符作为方法参数时表示：

方法内部可以调用获取Number引用的方法，例如：Number n = obj.getFirst();；

方法内部无法调用传入Number引用的方法（null除外），例如：obj.setFirst(Number n);。

即一句话总结：使用extends通配符表示可以读，不能写。

使用类似<T extends Number>定义泛型类时表示：

泛型类型限定为Number以及Number的子类。

super通配符

我们前面已经讲到了泛型的继承关系：Pair<Integer>不是Pair<Number>的子类。

考察下面的set方法：

void set(Pair<Integer> p, Integer first, Integer last) {

    p.setFirst(first);

    p.setLast(last);

}

传入Pair<Integer>是允许的，但是传入Pair<Number>是不允许的。

和extends通配符相反，这次，我们希望接受Pair<Integer>类型，以及Pair<Number>、Pair<Object>，因为Number和Object是Integer的父类，setFirst(Number)和setFirst(Object)实际上允许接受Integer类型。

我们使用super通配符来改写这个方法：

void set(Pair<? super Integer> p, Integer first, Integer last) {

    p.setFirst(first);

    p.setLast(last);

}

注意到Pair<? super Integer>表示，方法参数接受所有泛型类型为Integer或Integer父类的Pair类型。

下面的代码可以被正常编译：

public class Main {

    public static void main(String[] args) {

        Pair<Number> p1 = new Pair<>(12.3, 4.56);

        Pair<Integer> p2 = new Pair<>(123, 456);

        setSame(p1, 100);

        setSame(p2, 200);

        System.out.println(p1.getFirst() + ", " + p1.getLast());

        System.out.println(p2.getFirst() + ", " + p2.getLast());

    }



    static void setSame(Pair<? super Integer> p, Integer n) {

        p.setFirst(n);

        p.setLast(n);

    }



}



class Pair<T> {

    private T first;

    private T last;



    public Pair(T first, T last) {

        this.first = first;

        this.last = last;

    }



    public T getFirst() {

        return first;

    }

    public T getLast() {

        return last;

    }

    public void setFirst(T first) {

        this.first = first;

    }

    public void setLast(T last) {

        this.last = last;

    }

}

考察Pair<? super Integer>的setFirst()方法，它的方法签名实际上是：

void setFirst(? super Integer);

因此，可以安全地传入Integer类型。

再考察Pair<? super Integer>的getFirst()方法，它的方法签名实际上是：

? super Integer getFirst();

这里注意到我们无法使用Integer类型来接收getFirst()的返回值，即下面的语句将无法通过编译：

Integer x = p.getFirst();

因为如果传入的实际类型是Pair<Number>，编译器无法将Number类型转型为Integer。

注意：虽然Number是一个抽象类，我们无法直接实例化它。但是，即便Number不是抽象类，这里仍然无法通过编译。此外，传入Pair<Object>类型时，编译器也无法将Object类型转型为Integer。

唯一可以接收getFirst()方法返回值的是Object类型：

Object obj = p.getFirst();

因此，使用<? super Integer>通配符表示：

允许调用set(? super Integer)方法传入Integer的引用；

不允许调用get()方法获得Integer的引用。

唯一例外是可以获取Object的引用：Object o = p.getFirst()。

换句话说，使用<? super Integer>通配符作为方法参数，表示方法内部代码对于参数只能写，不能读。

对比extends和super通配符

我们再回顾一下extends通配符。作为方法参数，<? extends T>类型和<? super T>类型的区别在于：

<? extends T>允许调用读方法T get()获取T的引用，但不允许调用写方法set(T)传入T的引用（传入null除外）；

<? super T>允许调用写方法set(T)传入T的引用，但不允许调用读方法T get()获取T的引用（获取Object除外）。

一个是允许读不允许写，另一个是允许写不允许读。

先记住上面的结论，我们来看Java标准库的Collections类定义的copy()方法：

public class Collections {

    // 把src的每个元素复制到dest中:

    public static <T> void copy(List<? super T> dest, List<? extends T> src) {

        for (int i=0; i<src.size(); i++) {

            T t = src.get(i);

            dest.add(t);

        }

    }

}

它的作用是把一个List的每个元素依次添加到另一个List中。它的第一个参数是List<? super T>，表示目标List，第二个参数List<? extends T>，表示要复制的List。我们可以简单地用for循环实现复制。在for循环中，我们可以看到，对于类型<? extends T>的变量src，我们可以安全地获取类型T的引用，而对于类型<? super T>的变量dest，我们可以安全地传入T的引用。

这个copy()方法的定义就完美地展示了extends和super的意图：

copy()方法内部不会读取dest，因为不能调用dest.get()来获取T的引用；

copy()方法内部也不会修改src，因为不能调用src.add(T)。

这是由编译器检查来实现的。如果在方法代码中意外修改了src，或者意外读取了dest，就会导致一个编译错误：

public class Collections {

    // 把src的每个元素复制到dest中:

    public static <T> void copy(List<? super T> dest, List<? extends T> src) {

        for (int i=0; i<src.size(); i++) {

            T t = src.get(i);

            dest.add(t);

        }

    }

}

这个copy()方法的另一个好处是可以安全地把一个List<Integer>添加到List<Number>，但是无法反过来添加：

// copy List<Integer> to List<Number> ok:

List<Number> numList = ...;

List<Integer> intList = ...;

Collections.copy(numList, intList);



// ERROR: cannot copy List<Number> to List<Integer>:

Collections.copy(intList, numList);

而这些都是通过super和extends通配符，并由编译器强制检查来实现的。

PECS原则

何时使用extends，何时使用super？为了便于记忆，我们可以用PECS原则：Producer Extends Consumer Super。

即：如果需要返回T，它是生产者（Producer），要使用extends通配符；如果需要写入T，它是消费者（Consumer），要使用super通配符。

还是以Collections的copy()方法为例：

public class Collections {

    public static <T> void copy(List<? super T> dest, List<? extends T> src) {

        for (int i=0; i<src.size(); i++) {

            T t = src.get(i); // src是producer

            dest.add(t); // dest是consumer

        }

    }

}

需要返回T的src是生产者，因此声明为List<? extends T>，需要写入T的dest是消费者，因此声明为List<? super T>。

无限定通配符

我们已经讨论了<? extends T>和<? super T>作为方法参数的作用。实际上，Java的泛型还允许使用无限定通配符（Unbounded Wildcard Type），即只定义一个?：

void sample(Pair<?> p) {

}

因为<?>通配符既没有extends，也没有super，因此：

• 不允许调用set(T)方法并传入引用（null除外）；
• 不允许调用T get()方法并获取T引用（只能获取Object引用）。

换句话说，既不能读，也不能写，那只能做一些null判断：

static boolean isNull(Pair<?> p) {

    return p.getFirst() == null || p.getLast() == null;

}

大多数情况下，可以引入泛型参数<T>消除<?>通配符：

static <T> boolean isNull(Pair<T> p) {

    return p.getFirst() == null || p.getLast() == null;

}

<?>通配符有一个独特的特点，就是：Pair<?>是所有Pair<T>的超类：

public class Main {

    public static void main(String[] args) {

        Pair<Integer> p = new Pair<>(123, 456);

        Pair<?> p2 = p; // 安全地向上转型

        System.out.println(p2.getFirst() + ", " + p2.getLast());

    }



}



class Pair<T> {

    private T first;

    private T last;



    public Pair(T first, T last) {

        this.first = first;

        this.last = last;

    }



    public T getFirst() {

        return first;

    }

    public T getLast() {

        return last;

    }

    public void setFirst(T first) {

        this.first = first;

    }

    public void setLast(T last) {

        this.last = last;

    }

}

上述代码是可以正常编译运行的，因为Pair<Integer>是Pair<?>的子类，可以安全地向上转型。

小结

使用类似<? super Integer>通配符作为方法参数时表示：

方法内部可以调用传入Integer引用的方法，例如：obj.setFirst(Integer n);；

方法内部无法调用获取Integer引用的方法（Object除外），例如：Integer n = obj.getFirst();。

即使用super通配符表示只能写不能读。

使用extends和super通配符要遵循PECS原则。

无限定通配符<?>很少使用，可以用<T>替换，同时它是所有<T>类型的超类。

泛型和反射

Java的部分反射API也是泛型。例如：Class<T>就是泛型：

// compile warning:

Class clazz = String.class;

String str = (String) clazz.newInstance();



// no warning:

Class<String> clazz = String.class;

String str = clazz.newInstance();

调用Class的getSuperclass()方法返回的Class类型是Class<? super T>：

Class<? super String> sup = String.class.getSuperclass();

构造方法Constructor<T>也是泛型：

Class<Integer> clazz = Integer.class;

Constructor<Integer> cons = clazz.getConstructor(int.class);

Integer i = cons.newInstance(123);

我们可以声明带泛型的数组，但不能用new操作符创建带泛型的数组：

Pair<String>[] ps = null; // ok

Pair<String>[] ps = new Pair<String>[2]; // compile error!

必须通过强制转型实现带泛型的数组：

@SuppressWarnings("unchecked")

Pair<String>[] ps = (Pair<String>[]) new Pair[2];

使用泛型数组要特别小心，因为数组实际上在运行期没有泛型，编译器可以强制检查变量ps，因为它的类型是泛型数组。但是，编译器不会检查变量arr，因为它不是泛型数组。因为这两个变量实际上指向同一个数组，所以，操作arr可能导致从ps获取元素时报错，例如，以下代码演示了不安全地使用带泛型的数组：

Pair[] arr = new Pair[2];

Pair<String>[] ps = (Pair<String>[]) arr;



ps[0] = new Pair<String>("a", "b");

arr[1] = new Pair<Integer>(1, 2);



// ClassCastException:

Pair<String> p = ps[1];

String s = p.getFirst();

要安全地使用泛型数组，必须扔掉arr的引用：

@SuppressWarnings("unchecked")

Pair<String>[] ps = (Pair<String>[]) new Pair[2];

上面的代码中，由于拿不到原始数组的引用，就只能对泛型数组ps进行操作，这种操作就是安全的。

带泛型的数组实际上是编译器的类型擦除：

Pair[] arr = new Pair[2];

Pair<String>[] ps = (Pair<String>[]) arr;



System.out.println(ps.getClass() == Pair[].class); // true



String s1 = (String) arr[0].getFirst();

String s2 = ps[0].getFirst();

所以我们不能直接创建泛型数组T[]，因为擦拭后代码变为Object[]：

// compile error:public class Abc<T> {

    T[] createArray() {

        return new T[5];

    }

}

必须借助Class<T>来创建泛型数组：

T[] createArray(Class<T> cls) {

    return (T[]) Array.newInstance(cls, 5);

}

我们还可以利用可变参数创建泛型数组T[]：

public class ArrayHelper {

    @SafeVarargs

    static <T> T[] asArray(T... objs) {

        return objs;

    }

}



String[] ss = ArrayHelper.asArray("a", "b", "c");

Integer[] ns = ArrayHelper.asArray(1, 2, 3);

谨慎使用泛型可变参数

在上面的例子中，我们看到，通过：

static <T> T[] asArray(T... objs) {

    return objs;

}

似乎可以安全地创建一个泛型数组。但实际上，这种方法非常危险。以下代码来自《Effective Java》的示例：​​​​​​​

import java.util.Arrays;



public class Main {

    public static void main(String[] args) {

        String[] arr = asArray("one", "two", "three");

        System.out.println(Arrays.toString(arr));

        // ClassCastException:

        String[] firstTwo = pickTwo("one", "two", "three");

        System.out.println(Arrays.toString(firstTwo));

    }



    static <K> K[] pickTwo(K k1, K k2, K k3) {

        return asArray(k1, k2);

    }



    static <T> T[] asArray(T... objs) {

        return objs;

    }



}

直接调用asArray(T...)似乎没有问题，但是在另一个方法中，我们返回一个泛型数组就会产生ClassCastException，原因还是因为擦拭法，在pickTwo()方法内部，编译器无法检测K[]的正确类型，因此返回了Object[]。

如果仔细观察，可以发现编译器对所有可变泛型参数都会发出警告，除非确认完全没有问题，才可以用@SafeVarargs消除警告。

 如果在方法内部创建了泛型数组，最好不要将它返回给外部使用。

更详细的解释请参考《Effective Javahttps://www.oreilly.com/library/view/effective-java-3rd/9780134686097/》“Item 32: Combine generics and varargs judiciously”。

小结

部分反射API是泛型，例如：Class<T>，Constructor<T>；

可以声明带泛型的数组，但不能直接创建带泛型的数组，必须强制转型；

可以通过Array.newInstance(Class<T>, int)创建T[]数组，需要强制转型；

同时使用泛型和可变参数时需要特别小心。

集合

本节我们将介绍Java的集合类型。集合类型也是Java标准库中被使用最多的类型。​​​​​​​

Java集合简介

什么是集合（Collection）？集合就是“由若干个确定的元素所构成的整体”。例如，5只小兔构成的集合：

┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐

│   (\_(\     (\_/)     (\_/)     (\_/)      (\(\   │

    ( -.-)    (•.•)     (>.<)     (^.^)     (='.')

│  C(")_(")  (")_(")   (")_(")   (")_(")   O(_")")  │

└ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘

在数学中，我们经常遇到集合的概念。例如：

有限集合：

• 一个班所有的同学构成的集合；
• 一个网站所有的商品构成的集合；
• ……

无限集合：

• 全体自然数集合：1，2，3，……
• 实数集合；
• 有理数集合；
• ​​​​​​​……

为什么要在计算机中引入集合呢？这是为了便于处理一组类似的数据，例如：

• 计算所有同学的总成绩和平均成绩；
• 列举所有的商品名称和价格；
• ……

在Java中，如果一个Java对象可以在内部持有若干其他Java对象，并对外提供访问接口，我们把这种Java对象称为集合。很显然，Java的数组可以看作是一种集合：

String[] ss = new String[10]; // 可以持有10个String对象

ss[0] = "Hello"; // 可以放入String对象

String first = ss[0]; // 可以获取String对象

既然Java提供了数组这种数据类型，可以充当集合，那么，我们为什么还需要其他集合类？这是因为数组有如下限制：

• 数组初始化后大小不可变；
• 数组只能按索引顺序存取。

因此，我们需要各种不同类型的集合类来处理不同的数据，例如：

• 可变大小的顺序链表；
• 保证无重复元素的集合；
• ...

Collection

Java标准库自带的java.util包提供了集合类：Collection，它是除Map外所有其他集合类的根接口。Java的java.util包主要提供了以下三种类型的集合：

• List：一种有序列表的集合，例如，按索引排列的Student的List；
• Set：一种保证没有重复元素的集合，例如，所有无重复名称的Student的Set；
• Map：一种通过键值（key-value）查找的映射表集合，例如，根据Student的name查找对应Student的Map。

Java集合的设计有几个特点：一是实现了接口和实现类相分离，例如，有序表的接口是List，具体的实现类有ArrayList，LinkedList等，二是支持泛型，我们可以限制在一个集合中只能放入同一种数据类型的元素，例如：

List<String> list = new ArrayList<>(); // 只能放入String类型

最后，Java访问集合总是通过统一的方式——迭代器（Iterator）来实现，它最明显的好处在于无需知道集合内部元素是按什么方式存储的。

由于Java的集合设计非常久远，中间经历过大规模改进，我们要注意到有一小部分集合类是遗留类，不应该继续使用：

• Hashtable：一种线程安全的Map实现；
• Vector：一种线程安全的List实现；
• Stack：基于Vector实现的LIFO的栈。

还有一小部分接口是遗留接口，也不应该继续使用：

• Enumeration<E>：已被Iterator<E>取代。

小结

Java的集合类定义在java.util包中，支持泛型，主要提供了3种集合类，包括List，Set和Map。Java集合使用统一的Iterator遍历，尽量不要使用遗留接口。

使用List

在集合类中，List是最基础的一种集合：它是一种有序列表。

List的行为和数组几乎完全相同：List内部按照放入元素的先后顺序存放，每个元素都可以通过索引确定自己的位置，List的索引和数组一样，从0开始。

数组和List类似，也是有序结构，如果我们使用数组，在添加和删除元素的时候，会非常不方便。例如，从一个已有的数组{'A', 'B', 'C', 'D', 'E'}中删除索引为2的元素：

┌───┬───┬───┬───┬───┬───┐
│ A │ B │ C │ D │ E │   │
└───┴───┴───┴───┴───┴───┘
              │   │
          ┌───┘   │
          │   ┌───┘
          │   │
          ▼   ▼
┌───┬───┬───┬───┬───┬───┐
│ A │ B │ D │ E │   │   │
└───┴───┴───┴───┴───┴───┘

这个“删除”操作实际上是把'C'后面的元素依次往前挪一个位置，而“添加”操作实际上是把指定位置以后的元素都依次向后挪一个位置，腾出来的位置给新加的元素。这两种操作，用数组实现非常麻烦。

因此，在实际应用中，需要增删元素的有序列表，我们使用最多的是ArrayList。实际上，ArrayList在内部使用了数组来存储所有元素。例如，一个ArrayList拥有5个元素，实际数组大小为6（即有一个空位）：

size=5

┌───┬───┬───┬───┬───┬───┐
│ A │ B │ C │ D │ E │   │
└───┴───┴───┴───┴───┴───┘

当添加一个元素并指定索引到ArrayList时，ArrayList自动移动需要移动的元素：

size=5

┌───┬───┬───┬───┬───┬───┐
│ A │ B │   │ C │ D │ E │
└───┴───┴───┴───┴───┴───┘

然后，往内部指定索引的数组位置添加一个元素，然后把size加1：

size=6

┌───┬───┬───┬───┬───┬───┐
│ A │ B │ F │ C │ D │ E │
└───┴───┴───┴───┴───┴───┘

继续添加元素，但是数组已满，没有空闲位置的时候，ArrayList先创建一个更大的新数组，然后把旧数组的所有元素复制到新数组，紧接着用新数组取代旧数组：

size=6

┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
│ A │ B │ F │ C │ D │ E │   │   │   │   │   │   │
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘

现在，新数组就有了空位，可以继续添加一个元素到数组末尾，同时size加1：

size=7

┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
│ A │ B │ F │ C │ D │ E │ G │   │   │   │   │   │
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘

可见，ArrayList把添加和删除的操作封装起来，让我们操作List类似于操作数组，却不用关心内部元素如何移动。

我们考察List<E>接口，可以看到几个主要的接口方法：

• 在末尾添加一个元素：boolean add(E e)
• 在指定索引添加一个元素：boolean add(int index, E e)
• 删除指定索引的元素：E remove(int index)
• 删除某个元素：boolean remove(Object e)
• 获取指定索引的元素：E get(int index)
• 获取链表大小（包含元素的个数）：int size()

但是，实现List接口并非只能通过数组（即ArrayList的实现方式）来实现，另一种LinkedList通过“链表”也实现了List接口。在LinkedList中，它的内部每个元素都指向下一个元素：

        ┌───┬───┐   ┌───┬───┐   ┌───┬───┐   ┌───┬───┐
HEAD ──>│ A │ ●─┼──>│ B │ ●─┼──>│ C │ ●─┼──>│ D │   │
        └───┴───┘   └───┴───┘   └───┴───┘   └───┴───┘

我们来比较一下ArrayList和LinkedList：

	ArrayList	LinkedList
获取指定元素	速度很快	需要从头开始查找元素
添加元素到末尾	速度很快	速度很快
在指定位置添加/删除	需要移动元素	不需要移动元素
内存占用	少	较大

通常情况下，我们总是优先使用ArrayList。

List的特点

使用List时，我们要关注List接口的规范。List接口允许我们添加重复的元素，即List内部的元素可以重复：

import java.util.ArrayList;

import java.util.List;



public class Main {

    public static void main(String[] args) {

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

        list.add("apple"); // size=1

        list.add("pear"); // size=2

        list.add("apple"); // 允许重复添加元素，size=3

        System.out.println(list.size());

    }

}

List还允许添加null：​​​​​​​

import java.util.ArrayList;

import java.util.List;



public class Main {

    public static void main(String[] args) {

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

        list.add("apple"); // size=1

        list.add(null); // size=2

        list.add("pear"); // size=3

        String second = list.get(1); // null

        System.out.println(second);

    }

}

创建List

除了使用ArrayList和LinkedList，我们还可以通过List接口提供的of()方法，根据给定元素快速创建List：

List<Integer> list = List.of(1, 2, 5);

但是List.of()方法不接受null值，如果传入null，会抛出NullPointerException异常。

遍历List

和数组类型，我们要遍历一个List，完全可以用for循环根据索引配合get(int)方法遍历：

import java.util.List;



public class Main {

    public static void main(String[] args) {

        List<String> list = List.of("apple", "pear", "banana");

        for (int i=0; i<list.size(); i++) {

            String s = list.get(i);

            System.out.println(s);

        }

    }

}

但这种方式并不推荐，一是代码复杂，二是因为get(int)方法只有ArrayList的实现是高效的，换成LinkedList后，索引越大，访问速度越慢。

所以我们要始终坚持使用迭代器Iterator来访问List。Iterator本身也是一个对象，但它是由List的实例调用iterator()方法的时候创建的。Iterator对象知道如何遍历一个List，并且不同的List类型，返回的Iterator对象实现也是不同的，但总是具有最高的访问效率。

Iterator对象有两个方法：boolean hasNext()判断是否有下一个元素，E next()返回下一个元素。因此，使用Iterator遍历List代码如下：

import java.util.Iterator;

import java.util.List;



public class Main {

    public static void main(String[] args) {

        List<String> list = List.of("apple", "pear", "banana");

        for (Iterator<String> it = list.iterator(); it.hasNext(); ) {

            String s = it.next();

            System.out.println(s);

        }

    }

}

有童鞋可能觉得使用Iterator访问List的代码比使用索引更复杂。但是，要记住，通过Iterator遍历List永远是最高效的方式。并且，由于Iterator遍历是如此常用，所以，Java的for each循环本身就可以帮我们使用Iterator遍历。把上面的代码再改写如下：

import java.util.List;



public class Main {

    public static void main(String[] args) {

        List<String> list = List.of("apple", "pear", "banana");

        for (String s : list) {

            System.out.println(s);

        }

    }

}

上述代码就是我们编写遍历List的常见代码。

实际上，只要实现了Iterable接口的集合类都可以直接用for each循环来遍历，Java编译器本身并不知道如何遍历集合对象，但它会自动把for each循环变成Iterator的调用，原因就在于Iterable接口定义了一个Iterator<E> iterator()方法，强迫集合类必须返回一个Iterator实例。

List和Array转换

把List变为Array有三种方法，第一种是调用toArray()方法直接返回一个Object[]数组：

import java.util.List;



public class Main {

    public static void main(String[] args) {

        List<String> list = List.of("apple", "pear", "banana");

        Object[] array = list.toArray();

        for (Object s : array) {

            System.out.println(s);

        }

    }

}

这种方法会丢失类型信息，所以实际应用很少。

第二种方式是给toArray(T[])传入一个类型相同的Array，List内部自动把元素复制到传入的Array中：

import java.util.List;



public class Main {

    public static void main(String[] args) {

        List<Integer> list = List.of(12, 34, 56);

        Integer[] array = list.toArray(new Integer[3]);

        for (Integer n : array) {

            System.out.println(n);

        }

    }

}

注意到这个toArray(T[])方法的泛型参数<T>并不是List接口定义的泛型参数<E>，所以，我们实际上可以传入其他类型的数组，例如我们传入Number类型的数组，返回的仍然是Number类型：

import java.util.List;



public class Main {

    public static void main(String[] args) {

        List<Integer> list = List.of(12, 34, 56);

        Number[] array = list.toArray(new Number[3]);

        for (Number n : array) {

            System.out.println(n);

        }

    }

}

但是，如果我们传入类型不匹配的数组，例如，String[]类型的数组，由于List的元素是Integer，所以无法放入String数组，这个方法会抛出ArrayStoreException。

如果我们传入的数组大小和List实际的元素个数不一致怎么办？根据List接口的文档，我们可以知道：

如果传入的数组不够大，那么List内部会创建一个新的刚好够大的数组，填充后返回；如果传入的数组比List元素还要多，那么填充完元素后，剩下的数组元素一律填充null。

实际上，最常用的是传入一个“恰好”大小的数组：

Integer[] array = list.toArray(new Integer[list.size()]);

最后一种更简洁的写法是通过List接口定义的T[] toArray(IntFunction<T[]> generator)方法：

Integer[] array = list.toArray(Integer[]::new);

这种函数式写法我们会在后续讲到。

反过来，把Array变为List就简单多了，通过List.of(T...)方法最简单：

Integer[] array = { 1, 2, 3 };List<Integer> list = List.of(array);

对于JDK 11之前的版本，可以使用Arrays.asList(T...)方法把数组转换成List。

要注意的是，返回的List不一定就是ArrayList或者LinkedList，因为List只是一个接口，如果我们调用List.of()，它返回的是一个只读List：

import java.util.List;



public class Main {

    public static void main(String[] args) {

        List<Integer> list = List.of(12, 34, 56);

        list.add(999); // UnsupportedOperationException

    }

}

对只读List调用add()、remove()方法会抛出UnsupportedOperationException。

练习

给定一组连续的整数，例如：10，11，12，……，20，但其中缺失一个数字，试找出缺失的数字：

import java.util.*;



public class Main {

    public static void main(String[] args) {

        // 构造从start到end的序列：

        final int start = 10;

        final int end = 20;

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

        for (int i = start; i <= end; i++) {

            list.add(i);

        }

        // 随机删除List中的一个元素:

        int removed = list.remove((int) (Math.random() * list.size()));

        int found = findMissingNumber(start, end, list);

        System.out.println(list.toString());

        System.out.println("missing number: " + found);

        System.out.println(removed == found ? "测试成功" : "测试失败");

    }

    static int findMissingNumber(int start, int end, List<Integer> list) {

        return 0;

    }



}

增强版：和上述题目一样，但整数不再有序，试找出缺失的数字：​​​​​​​

import java.util.*;



public class Main {

    public static void main(String[] args) {

        // 构造从start到end的序列：

        final int start = 10;

        final int end = 20;

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

        for (int i = start; i <= end; i++) {

            list.add(i);

        }

        // 洗牌算法shuffle可以随机交换List中的元素位置:

        Collections.shuffle(list);

        // 随机删除List中的一个元素:

        int removed = list.remove((int) (Math.random() * list.size()));

        int found = findMissingNumber(start, end, list);

        System.out.println(list.toString());

        System.out.println("missing number: " + found);

        System.out.println(removed == found ? "测试成功" : "测试失败");

    }

    static int findMissingNumber(int start, int end, List<Integer> list) {

        return 0;

    }



}

小结

List是按索引顺序访问的长度可变的有序表，优先使用ArrayList而不是LinkedList；

可以直接使用for each遍历List；

List可以和Array相互转换。

编写equals方法

我们知道List是一种有序链表：List内部按照放入元素的先后顺序存放，并且每个元素都可以通过索引确定自己的位置。

List还提供了boolean contains(Object o)方法来判断List是否包含某个指定元素。此外，int indexOf(Object o)方法可以返回某个元素的索引，如果元素不存在，就返回-1。

我们来看一个例子：

import java.util.List;



public class Main {

    public static void main(String[] args) {

        List<String> list = List.of("A", "B", "C");

        System.out.println(list.contains("C")); // true

        System.out.println(list.contains("X")); // false

        System.out.println(list.indexOf("C")); // 2

        System.out.println(list.indexOf("X")); // -1

    }

}

这里我们注意一个问题，我们往List中添加的"C"和调用contains("C")传入的"C"是不是同一个实例？

如果这两个"C"不是同一个实例，这段代码是否还能得到正确的结果？我们可以改写一下代码测试一下：

import java.util.List;



public class Main {

    public static void main(String[] args) {

        List<String> list = List.of("A", "B", "C");

        System.out.println(list.contains(new String("C"))); // true or false?

        System.out.println(list.indexOf(new String("C"))); // 2 or -1?

    }

}

因为我们传入的是new String("C")，所以一定是不同的实例。结果仍然符合预期，这是为什么呢？

因为List内部并不是通过==判断两个元素是否相等，而是使用equals()方法判断两个元素是否相等，例如contains()方法可以实现如下：

public class ArrayList {

    Object[] elementData;

    public boolean contains(Object o) {

        for (int i = 0; i < elementData.length; i++) {

            if (o.equals(elementData[i])) {

                return true;

            }

        }

        return false;

    }

}

因此，要正确使用List的contains()、indexOf()这些方法，放入的实例必须正确覆写equals()方法，否则，放进去的实例，查找不到。我们之所以能正常放入String、Integer这些对象，是因为Java标准库定义的这些类已经正确实现了equals()方法。

我们以Person对象为例，测试一下：

import java.util.List;



public class Main {

    public static void main(String[] args) {

        List<Person> list = List.of(

            new Person("Xiao Ming"),

            new Person("Xiao Hong"),

            new Person("Bob")

        );

        System.out.println(list.contains(new Person("Bob"))); // false

    }

}



class Person {

    String name;

    public Person(String name) {

        this.name = name;

    }

}

不出意外，虽然放入了new Person("Bob")，但是用另一个new Person("Bob")查询不到，原因就是Person类没有覆写equals()方法。

编写equals

如何正确编写equals()方法？equals()方法要求我们必须满足以下条件：

• 自反性（Reflexive）：对于非null的x来说，x.equals(x)必须返回true；
• 对称性（Symmetric）：对于非null的x和y来说，如果x.equals(y)为true，则y.equals(x)也必须为true；
• 传递性（Transitive）：对于非null的x、y和z来说，如果x.equals(y)为true，y.equals(z)也为true，那么x.equals(z)也必须为true；
• 一致性（Consistent）：对于非null的x和y来说，只要x和y状态不变，则x.equals(y)总是一致地返回true或者false；
• 对null的比较：即x.equals(null)永远返回false。

上述规则看上去似乎非常复杂，但其实代码实现equals()方法是很简单的，我们以Person类为例：

public class Person {

    public String name;

    public int age;

}

首先，我们要定义“相等”的逻辑含义。对于Person类，如果name相等，并且age相等，我们就认为两个Person实例相等。

因此，编写equals()方法如下：

public boolean equals(Object o) {

    if (o instanceof Person p) {

        return this.name.equals(p.name) && this.age == p.age;

    }

    return false;

}

对于引用字段比较，我们使用equals()，对于基本类型字段的比较，我们使用==。

如果this.name为null，那么equals()方法会报错，因此，需要继续改写如下：

public boolean equals(Object o) {

    if (o instanceof Person p) {

        boolean nameEquals = false;

        if (this.name == null && p.name == null) {

            nameEquals = true;

        }

        if (this.name != null) {

            nameEquals = this.name.equals(p.name);

        }

        return nameEquals && this.age == p.age;

    }

    return false;

}

如果Person有好几个引用类型的字段，上面的写法就太复杂了。要简化引用类型的比较，我们使用Objects.equals()静态方法：

public boolean equals(Object o) {

    if (o instanceof Person p) {

        return Objects.equals(this.name, p.name) && this.age == p.age;

    }

    return false;

}

因此，我们总结一下equals()方法的正确编写方法：

1. 先确定实例“相等”的逻辑，即哪些字段相等，就认为实例相等；
2. 用instanceof判断传入的待比较的Object是不是当前类型，如果是，继续比较，否则，返回false；
3. 对引用类型用Objects.equals()比较，对基本类型直接用==比较。

使用Objects.equals()比较两个引用类型是否相等的目的是省去了判断null的麻烦。两个引用类型都是null时它们也是相等的。

如果不调用List的contains()、indexOf()这些方法，那么放入的元素就不需要实现equals()方法。

练习

给Person类增加equals方法，使得调用indexOf()方法返回正常：

import java.util.List;

import java.util.Objects;



public class Main {

    public static void main(String[] args) {

        List<Person> list = List.of(

            new Person("Xiao", "Ming", 18),

            new Person("Xiao", "Hong", 25),

            new Person("Bob", "Smith", 20)

        );

        boolean exist = list.contains(new Person("Bob", "Smith", 20));

        System.out.println(exist ? "测试成功!" : "测试失败!");

    }

}



class Person {

    String firstName;

    String lastName;

    int age;

    public Person(String firstName, String lastName, int age) {

        this.firstName = firstName;

        this.lastName = lastName;

        this.age = age;

    }

}

小结

在List中查找元素时，List的实现类通过元素的equals()方法比较两个元素是否相等，因此，放入的元素必须正确覆写equals()方法，Java标准库提供的String、Integer等已经覆写了equals()方法；

编写equals()方法可借助Objects.equals()判断。

如果不在List中查找元素，就不必覆写equals()方法。

使用Map

我们知道，List是一种顺序列表，如果有一个存储学生Student实例的List，要在List中根据name查找某个指定的Student的分数，应该怎么办？

最简单的方法是遍历List并判断name是否相等，然后返回指定元素：

List<Student> list = ...

Student target = null;for (Student s : list) {

    if ("Xiao Ming".equals(s.name)) {

        target = s;

        break;

    }

}

System.out.println(target.score);

这种需求其实非常常见，即通过一个键去查询对应的值。使用List来实现存在效率非常低的问题，因为平均需要扫描一半的元素才能确定，而Map这种键值（key-value）映射表的数据结构，作用就是能高效通过key快速查找value（元素）。

用Map来实现根据name查询某个Student的代码如下：

import java.util.HashMap;

import java.util.Map;



public class Main {

    public static void main(String[] args) {

        Student s = new Student("Xiao Ming", 99);

        Map<String, Student> map = new HashMap<>();

        map.put("Xiao Ming", s); // 将"Xiao Ming"和Student实例映射并关联

        Student target = map.get("Xiao Ming"); // 通过key查找并返回映射的Student实例

        System.out.println(target == s); // true，同一个实例

        System.out.println(target.score); // 99

        Student another = map.get("Bob"); // 通过另一个key查找

        System.out.println(another); // 未找到返回null

    }

}



class Student {

    public String name;

    public int score;

    public Student(String name, int score) {

        this.name = name;

        this.score = score;

    }

}

通过上述代码可知：Map<K, V>是一种键-值映射表，当我们调用put(K key, V value)方法时，就把key和value做了映射并放入Map。当我们调用V get(K key)时，就可以通过key获取到对应的value。如果key不存在，则返回null。和List类似，Map也是一个接口，最常用的实现类是HashMap。

如果只是想查询某个key是否存在，可以调用boolean containsKey(K key)方法。

如果我们在存储Map映射关系的时候，对同一个key调用两次put()方法，分别放入不同的value，会有什么问题呢？例如：

import java.util.HashMap;

import java.util.Map;



public class Main {

    public static void main(String[] args) {

        Map<String, Integer> map = new HashMap<>();

        map.put("apple", 123);

        map.put("pear", 456);

        System.out.println(map.get("apple")); // 123

        map.put("apple", 789); // 再次放入apple作为key，但value变为789

        System.out.println(map.get("apple")); // 789

    }

}

重复放入key-value并不会有任何问题，但是一个key只能关联一个value。在上面的代码中，一开始我们把key对象"apple"映射到Integer对象123，然后再次调用put()方法把"apple"映射到789，这时，原来关联的value对象123就被“冲掉”了。实际上，put()方法的签名是V put(K key, V value)，如果放入的key已经存在，put()方法会返回被删除的旧的value，否则，返回null。

 始终牢记：Map中不存在重复的key，因为放入相同的key，只会把原有的key-value对应的value给替换掉。

此外，在一个Map中，虽然key不能重复，但value是可以重复的：

Map<String, Integer> map = new HashMap<>();

map.put("apple", 123);

map.put("pear", 123); // ok

遍历Map

对Map来说，要遍历key可以使用for each循环遍历Map实例的keySet()方法返回的Set集合，它包含不重复的key的集合：​​​​​​​

import java.util.HashMap;

import java.util.Map;



public class Main {

    public static void main(String[] args) {

        Map<String, Integer> map = new HashMap<>();

        map.put("apple", 123);

        map.put("pear", 456);

        map.put("banana", 789);

        for (String key : map.keySet()) {

            Integer value = map.get(key);

            System.out.println(key + " = " + value);

        }

    }

}

同时遍历key和value可以使用for each循环遍历Map对象的entrySet()集合，它包含每一个key-value映射：

import java.util.HashMap;

import java.util.Map;



public class Main {

    public static void main(String[] args) {

        Map<String, Integer> map = new HashMap<>();

        map.put("apple", 123);

        map.put("pear", 456);

        map.put("banana", 789);

        for (Map.Entry<String, Integer> entry : map.entrySet()) {

            String key = entry.getKey();

            Integer value = entry.getValue();

            System.out.println(key + " = " + value);

        }

    }

}

Map和List不同的是，Map存储的是key-value的映射关系，并且，它不保证顺序。在遍历的时候，遍历的顺序既不一定是put()时放入的key的顺序，也不一定是key的排序顺序。使用Map时，任何依赖顺序的逻辑都是不可靠的。以HashMap为例，假设我们放入"A"，"B"，"C"这3个key，遍历的时候，每个key会保证被遍历一次且仅遍历一次，但顺序完全没有保证，甚至对于不同的JDK版本，相同的代码遍历的输出顺序都是不同的！

 遍历Map时，不可假设输出的key是有序的！

练习

请编写一个根据name查找score的程序，并利用Map充当缓存，以提高查找效率：

import java.util.*;



public class Main {

    public static void main(String[] args) {

        List<Student> list = List.of(

            new Student("Bob", 78),

            new Student("Alice", 85),

            new Student("Brush", 66),

            new Student("Newton", 99));

        var holder = new Students(list);

        System.out.println(holder.getScore("Bob") == 78 ? "测试成功!" : "测试失败!");

        System.out.println(holder.getScore("Alice") == 85 ? "测试成功!" : "测试失败!");

        System.out.println(holder.getScore("Tom") == -1 ? "测试成功!" : "测试失败!");

    }

}



class Students {

    List<Student> list;

    Map<String, Integer> cache;



    Students(List<Student> list) {

        this.list = list;

        cache = new HashMap<>();

    }



    /**

     * 根据name查找score，找到返回score，未找到返回-1

     */

    int getScore(String name) {

        // 先在Map中查找:

        Integer score = this.cache.get(name);

        if (score == null) {

            // TODO:

        }

        return score == null ? -1 : score.intValue();

    }



    Integer findInList(String name) {

        for (var ss : this.list) {

            if (ss.name.equals(name)) {

                return ss.score;

            }

        }

        return null;

    }

}



class Student {

    String name;

    int score;



    Student(String name, int score) {

        this.name = name;

        this.score = score;

    }

}

小结

Map是一种映射表，可以通过key快速查找value。

可以通过for each遍历keySet()，也可以通过for each遍历entrySet()，直接获取key-value。

最常用的一种Map实现是HashMap。

编写equals和hashCode

我们知道Map是一种键-值（key-value）映射表，可以通过key快速查找对应的value。

以HashMap为例，观察下面的代码：

Map<String, Person> map = new HashMap<>();

map.put("a", new Person("Xiao Ming"));

map.put("b", new Person("Xiao Hong"));

map.put("c", new Person("Xiao Jun"));



map.get("a"); // Person("Xiao Ming")

map.get("x"); // null

HashMap之所以能根据key直接拿到value，原因是它内部通过空间换时间的方法，用一个大数组存储所有value，并根据key直接计算出value应该存储在哪个索引：

 

  ┌───┐
0 │   │
  ├───┤
1 │ ●─┼───> Person("Xiao Ming")
  ├───┤
2 │   │
  ├───┤
3 │   │
  ├───┤
4 │   │
  ├───┤
5 │ ●─┼───> Person("Xiao Hong")
  ├───┤
6 │ ●─┼───> Person("Xiao Jun")
  ├───┤
7 │   │
  └───┘

如果key的值为"a"，计算得到的索引总是1，因此返回value为Person("Xiao Ming")，如果key的值为"b"，计算得到的索引总是5，因此返回value为Person("Xiao Hong")，这样，就不必遍历整个数组，即可直接读取key对应的value。

当我们使用key存取value的时候，就会引出一个问题：

我们放入Map的key是字符串"a"，但是，当我们获取Map的value时，传入的变量不一定就是放入的那个key对象。

换句话讲，两个key应该是内容相同，但不一定是同一个对象。测试代码如下：

import java.util.HashMap;

import java.util.Map;



public class Main {

    public static void main(String[] args) {

        String key1 = "a";

        Map<String, Integer> map = new HashMap<>();

        map.put(key1, 123);



        String key2 = new String("a");

        map.get(key2); // 123



        System.out.println(key1 == key2); // false

        System.out.println(key1.equals(key2)); // true

    }

}

因为在Map的内部，对key做比较是通过equals()实现的，这一点和List查找元素需要正确覆写equals()是一样的，即正确使用Map必须保证：作为key的对象必须正确覆写equals()方法。

我们经常使用String作为key，因为String已经正确覆写了equals()方法。但如果我们放入的key是一个自己写的类，就必须保证正确覆写了equals()方法。

我们再思考一下HashMap为什么能通过key直接计算出value存储的索引。相同的key对象（使用equals()判断时返回true）必须要计算出相同的索引，否则，相同的key每次取出的value就不一定对。

通过key计算索引的方式就是调用key对象的hashCode()方法，它返回一个int整数。HashMap正是通过这个方法直接定位key对应的value的索引，继而直接返回value。

因此，正确使用Map必须保证：

作为key的对象必须正确覆写equals()方法，相等的两个key实例调用equals()必须返回true；

作为key的对象还必须正确覆写hashCode()方法，且hashCode()方法要严格遵循以下规范：

• 如果两个对象相等，则两个对象的hashCode()必须相等；
• 如果两个对象不相等，则两个对象的hashCode()尽量不要相等。

即对应两个实例a和b：

• 如果a和b相等，那么a.equals(b)一定为true，则a.hashCode()必须等于b.hashCode()；
• 如果a和b不相等，那么a.equals(b)一定为false，则a.hashCode()和b.hashCode()尽量不要相等。

上述第一条规范是正确性，必须保证实现，否则HashMap不能正常工作。

而第二条如果尽量满足，则可以保证查询效率，因为不同的对象，如果返回相同的hashCode()，会造成Map内部存储冲突，使存取的效率下降。

正确编写equals()的方法我们已经在编写equals方法一节中讲过了，以Person类为例：

public class Person {

    String firstName;

    String lastName;

    int age;

}

把需要比较的字段找出来：

• firstName
• lastName
• age

然后，引用类型使用Objects.equals()比较，基本类型使用==比较。

在正确实现equals()的基础上，我们还需要正确实现hashCode()，即上述3个字段分别相同的实例，hashCode()返回的int必须相同：

public class Person {

    String firstName;

    String lastName;

    int age;



    @Override

    int hashCode() {

        int h = 0;

        h = 31 * h + firstName.hashCode();

        h = 31 * h + lastName.hashCode();

        h = 31 * h + age;

        return h;

    }

}

注意到String类已经正确实现了hashCode()方法，我们在计算Person的hashCode()时，反复使用31*h，这样做的目的是为了尽量把不同的Person实例的hashCode()均匀分布到整个int范围。

和实现equals()方法遇到的问题类似，如果firstName或lastName为null，上述代码工作起来就会抛NullPointerException。为了解决这个问题，我们在计算hashCode()的时候，经常借助Objects.hash()来计算：

int hashCode() {

    return Objects.hash(firstName, lastName, age);

}

所以，编写equals()和hashCode()遵循的原则是：

equals()用到的用于比较的每一个字段，都必须在hashCode()中用于计算；equals()中没有使用到的字段，绝不可放在hashCode()中计算。

另外注意，对于放入HashMap的value对象，没有任何要求。

延伸阅读

既然HashMap内部使用了数组，通过计算key的hashCode()直接定位value所在的索引，那么第一个问题来了：hashCode()返回的int范围高达±21亿，先不考虑负数，HashMap内部使用的数组得有多大？

实际上HashMap初始化时默认的数组大小只有16，任何key，无论它的hashCode()有多大，都可以简单地通过：

int index = key.hashCode() & 0xf; // 0xf = 15

把索引确定在0～15，即永远不会超出数组范围，上述算法只是一种最简单的实现。

第二个问题：如果添加超过16个key-value到HashMap，数组不够用了怎么办？

添加超过一定数量的key-value时，HashMap会在内部自动扩容，每次扩容一倍，即长度为16的数组扩展为长度32，相应地，需要重新确定hashCode()计算的索引位置。例如，对长度为32的数组计算hashCode()对应的索引，计算方式要改为：

int index = key.hashCode() & 0x1f; // 0x1f = 31

由于扩容会导致重新分布已有的key-value，所以，频繁扩容对HashMap的性能影响很大。如果我们确定要使用一个容量为10000个key-value的HashMap，更好的方式是创建HashMap时就指定容量：

Map<String, Integer> map = new HashMap<>(10000);

虽然指定容量是10000，但HashMap内部的数组长度总是2n，因此，实际数组长度被初始化为比10000大的16384（214）。

最后一个问题：如果不同的两个key，例如"a"和"b"，它们的hashCode()恰好是相同的（这种情况是完全可能的，因为不相等的两个实例，只要求hashCode()尽量不相等），那么，当我们放入：

map.put("a", new Person("Xiao Ming"));

map.put("b", new Person("Xiao Hong"));

时，由于计算出的数组索引相同，后面放入的"Xiao Hong"会不会把"Xiao Ming"覆盖了？

当然不会！使用Map的时候，只要key不相同，它们映射的value就互不干扰。但是，在HashMap内部，确实可能存在不同的key，映射到相同的hashCode()，即相同的数组索引上，肿么办？

我们就假设"a"和"b"这两个key最终计算出的索引都是5，那么，在HashMap的数组中，实际存储的不是一个Person实例，而是一个List，它包含两个Entry，一个是"a"的映射，一个是"b"的映射：

  ┌───┐
0 │   │
  ├───┤
1 │   │
  ├───┤
2 │   │
  ├───┤
3 │   │
  ├───┤
4 │   │
  ├───┤
5 │ ●─┼───> List<Entry<String, Person>>
  ├───┤
6 │   │
  ├───┤
7 │   │
  └───┘

在查找的时候，例如：

Person p = map.get("a");

HashMap内部通过"a"找到的实际上是List<Entry<String, Person>>，它还需要遍历这个List，并找到一个Entry，它的key字段是"a"，才能返回对应的Person实例。

我们把不同的key具有相同的hashCode()的情况称之为哈希冲突。在冲突的时候，一种最简单的解决办法是用List存储hashCode()相同的key-value。显然，如果冲突的概率越大，这个List就越长，Map的get()方法效率就越低，这就是为什么要尽量满足条件二：

 如果两个对象不相等，则两个对象的hashCode()尽量不要相等。

hashCode()方法编写得越好，HashMap工作的效率就越高。

小结

要正确使用HashMap，作为key的类必须正确覆写equals()和hashCode()方法；

一个类如果覆写了equals()，就必须覆写hashCode()，并且覆写规则是：

如果equals()返回true，则hashCode()返回值必须相等；

如果equals()返回false，则hashCode()返回值尽量不要相等。

实现hashCode()方法可以通过Objects.hashCode()辅助方法实现。

使用EnumMap

因为HashMap是一种通过对key计算hashCode()，通过空间换时间的方式，直接定位到value所在的内部数组的索引，因此，查找效率非常高。

如果作为key的对象是enum类型，那么，还可以使用Java集合库提供的一种EnumMap，它在内部以一个非常紧凑的数组存储value，并且根据enum类型的key直接定位到内部数组的索引，并不需要计算hashCode()，不但效率最高，而且没有额外的空间浪费。

我们以DayOfWeek这个枚举类型为例，为它做一个“翻译”功能：​​​​​​​

import java.time.DayOfWeek;

import java.util.*;



public class Main {

    public static void main(String[] args) {

        Map<DayOfWeek, String> map = new EnumMap<>(DayOfWeek.class);

        map.put(DayOfWeek.MONDAY, "星期一");

        map.put(DayOfWeek.TUESDAY, "星期二");

        map.put(DayOfWeek.WEDNESDAY, "星期三");

        map.put(DayOfWeek.THURSDAY, "星期四");

        map.put(DayOfWeek.FRIDAY, "星期五");

        map.put(DayOfWeek.SATURDAY, "星期六");

        map.put(DayOfWeek.SUNDAY, "星期日");

        System.out.println(map);

        System.out.println(map.get(DayOfWeek.MONDAY));

    }

}

使用EnumMap的时候，我们总是用Map接口来引用它，因此，实际上把HashMap和EnumMap互换，在客户端看来没有任何区别。

小结

如果Map的key是enum类型，推荐使用EnumMap，既保证速度，也不浪费空间。

使用EnumMap的时候，根据面向抽象编程的原则，应持有Map接口。