Java 集合相关面试题

Java 集合相关面试体

1. 介绍Collection框架的接口

如图所示：图中，实现边框是实现类、折线边框是抽象类，而点线边框是接口

Collection接口是集合类的跟接口，Java中没有提供这个接口的直接实现类。但是却让其被继承产生了两个接口，就是Set和List。
Set：不能包含重复的元素，无序。
List：可以包含重复的元素，有序。

Map是Java.util包中的另一个接口，和Collection无关。Map包含了k-v对。Map不能包含重复的key，但可以有重复的value

Iterator，所有的集合类，都实现了Iterator接口，这是一个用于遍历集合中元素的接口，主要包含以下三种方法：
hasNext()是否还有下一个元素
next()返回下一个元素
remove（）删除当前元素

2. Java中什么是集合框架、集合框架有哪些、集合框架的优点。

集合框架是为表示和操作集合而规定的一种统一的标准的体系结构。任何集合框架都包括三大块内容：对外的接口、接口的实现、对集合运算的算法。
集合框架有：Collection、Set、List、Map。
集合框架的有点：

1. 使降低开发成本。
2. 代码质量会提高。
3. 降低代码维护成本。
4. 复用性。

3. 集合中的泛型有什么有点？

JDK1.5之后引入泛型，所有的集合接口和实现类都大量的使用它。

1. 泛型允许我们为集合提供一个可以容纳的对象类型，因此，如果你添加其他类型的任何元素，它会在编译时报错。
2. 泛型使得代码整洁，我们不需要使用显示转换和instanceOf操作符。
3. 在运行时不会产生类型检查的字节码指令。

4. 为何Collection不从Cloneable和Serializable接口继承？

序列化：把对象转换为字节序列的过程称为对象的序列化。
反序列化：把字节序列恢复为对象的过程称为对象的反序列化。

1. Collection表示一个集合，包含了一组对象。如何存储和维护这些对象是由具体实现来决定的。因为集合的具体形式多种多样，如List允许重复，而Set不允许。
2. 而克隆和序列化只对具体的实体和对象有意义，总不能把一个接口或者抽象类克隆、序列化、反序列化。所以具体的collection实现类是否可以克隆、序列化应该由其自身决定，而不能由其超类强行赋予。
3. 如果Collection实现了Cloneable和Serializable接口，则最终导致的灵活性降低和限制增多。

5. Collection框架中实现比较要实现什么接口

实现比较有两种方式：第一种，实体类实现Comparable接口，并实现compareTo(T t)方法，称之为内部比较器。
第二种，创建一个外部比较器，这个外部比较器要实现Comparator接口的compare（T t1, T t2）方法
第一种，实现Comparable接口

package com.company.lianxi;

import java.util.ArrayList;
import java.util.Collections;

/**
 * @author BigZ
 * @date 19-6-18 下午6:23
 */
public class StudentComparable implements Comparable<StudentComparable> {

    private String name;
    private int age;

    public StudentComparable(){}

    public StudentComparable(String name, int age){
        this.age = age;
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(StudentComparable o) {
        if (getAge() > o.getAge()){
            return 1;
        } else if (getAge() < o.getAge()){
            return -1;
        } else {
            return 0;
        }
    }

    @Override
    public String toString(){
        return "{" + name + "," + age + "}";
    }

    public static void main(String[] args){
        StudentComparable tom = new StudentComparable("tom", 12);
        StudentComparable jimi = new StudentComparable("jimi", 8);
        StudentComparable lora = new StudentComparable("lora", 15);

        ArrayList<StudentComparable> arrayList = new ArrayList<>();
        arrayList.add(tom);
        arrayList.add(jimi);
        arrayList.add(lora);

        Collections.sort(arrayList);
        System.out.println(arrayList);
    }
}

// 运行结果
[{jimi,8}, {tom,12}, {lora,15}]

第二种，实现Comparator接口
先定义一个Student类，无需实现任何接口

package com.company.lianxi;

/**
 * @author BigZ
 * @date 19-6-18 下午6:38
 */
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

再定义一个外部比较器类，实现Comparator接口：

package com.company.lianxi;

import java.util.Comparator;

/**
 * @author BigZ
 * @date 19-6-18 下午6:37
 */
public class MyComparator implements Comparator<Student> {


    @Override
    public int compare(Student o1, Student o2) {

        if (o1.getAge() > o2.getAge()){
            return 1;
        } else if (o1.getAge() < o2.getAge()){
            return -1;
        }
        return 0;
    }

    public static void main(String[] args){

        Student marry = new Student("marry", 12);
        Student tom = new Student("tom", 12);
        Student jackson = new Student("jackson", 88);

        MyComparator comparator = new MyComparator();
        System.out.println(comparator.compare(marry, tom));
        System.out.println(comparator.compare(tom, jackson));

    }
}

6. ArrayList和Vector的区别（是否有序、是否重复、数据结构、底层实现）

共同点：
ArrayList和Vector都是实现了List接口，都是有序集合、并且可存放重复的元素、底层是通过数组来实现、这种数据结构查询速度快，増删速度慢。
不同点：
第一，线程安全。Vector实现成安全的，而ArrayList是线程不安全的。单线程下使用ArrayList比较高效，多线程下使用Vector来保证数据安全。
第二，数据增长。ArrayList和Vector都有一个初始的容量大小。扩容时ArraList每次值增长原来的0.5被，而Vector每次增长原来的一倍。ArrayList和Vector都可以设置初始空间大小，Vector还可以设置增长的空间大小，而ArrayList则不能。

7. HashMap和HashTable的区别

HashMap和HashTable都实现了Map接口，并且都是key-value的数据解构。

1. HashMap允许key和value为null，而HashTable不允许
2. HashTable是同步的，而HashMap不是。HashTable适合多线程环境下，HashMap适合单线程环境。
3. HashTable是自JDK1.0出现的，继承Dictionary类，而HashMap是自JDK1.2后出现，继承AbstractMap类。

8. List和Map区别（数据解构、存储特点）

数据结构：
List存储的是单列数据的集合，而Map存储的是K-V类型的数据集合。
存储上：
List存储的是有序可重复的数据，而Map的key不能重复，且无序，但是value可以重复。

9. List、Map、Set三个接口，存取元素时，各有什么特点。

List与Set具有相似性，它们都是单列元素的集合，所以，它们有一个功共同的父接口，叫Collection。Set里面不允许有重复的元素，所谓重复，即不能有两个相等（注意，不是仅仅是相同）的对象 ，即假设Set集合中有了一个A对象，现在我要向Set集合再存入一个B对象，但B对象与A对象equals相等，则B对象存储不进去。所以，Set集合的add方法有一个boolean的返回值，当集合中没有某个元素，此时add方法可成功加入该元素时，则返回true，当集合含有与某个元素equals相等的元素时，此时add方法无法加入该元素，返回结果为false。Set取元素时，没法说取第几个，只能以Iterator接口取得所有的元素，再逐一遍历各个元素。

List表示有先后顺序的集合， 注意，不是那种按年龄、按大小、按价格之类的排序。当我们多次调用add(Obj e)方法时，每次加入的对象就像火车站买票有排队顺序一样，按先来后到的顺序排序。有时候，也可以插队，即调用add(int index,Obj e)方法，就可以指定当前对象在集合中的存放位置。一个对象可以被反复存储进List中，每调用一次add方法，这个对象就被插入进集合中一次，其实，并不是把这个对象本身存储进了集合中，而是在集合中用一个索引变量指向这个对象，当这个对象被add多次时，即相当于集合中有多个索引指向了这个对象，如图x所示。List除了可以以Iterator接口取得所有的元素，再逐一遍历各个元素之外，还可以调用get(index i)来明确说明取第几个。

Map与List和Set不同，它是双列的集合，其中有put方法，定义如下：put(obj key,obj value)，每次存储时，要存储一对key/value，不能存储重复的key，这个重复的规则也是按equals比较相等。取则可以根据key获得相应的value，即get(Object key)返回值为key 所对应的value。另外，也可以获得所有的key的结合（map.keySet()），还可以获得所有的value的结合（map.values()），还可以获得key和value组合成的Map.Entry对象的集合（map.entrySet()）。

List 以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值，value可多值。

10. 为何Map接口不继承Collection接口？

尽管Map接口和它的实现也是集合框架的一部分，但是Map不是集合，集合也不是Map。Map存储的是k-v对，但是Collection存储的是单列数据。

11. Iterator是什么？

迭代器是一种设计模式，它是一个对象，可以遍历并选择序列中的对象，而开发人员不需要了解该序列底层的结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。
java中的Iterator功能比较简单，并且只能单向移动。

1. 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next（）方法时，它返回序列的第一个元素。
2. 使用next()方法获得序列中的下一个元素。
3. 使用hasNext()检查序列中是否还有元素。
4. 使用remove（）将迭代器新返回的元素删除。

12. Enumeration和Iterator接口的区别？

1. Enumeration的速度是Iterator的两倍，也使用更少的内存。
2. Enumeration是非常基础的，也满足了基础的需要。但是，与Enumeration相比，Iterator更加安全，因为当一个集合正在被遍历的时候，它会阻止其它线程去修改集合。
3. 迭代器取代了Java集合框架中的Enumeration。迭代器允许调用者从集合中移除元素，而Enumeration不能做到。

13. 为何没有像Iterator.add()这样的方法，向集合中添加元素？

语义不明，已知的是，Iterator的协议不能确保迭代的次序。然而要注意，ListIterator没有提供一个add操作，它要确保迭代的顺序。

14. 为何迭代器没有一个方法可以直接获取下一个元素，而不需要移动游标？

它可以在当前Iterator的顶层实现，但是它用得很少，如果将它加到接口中，每个继承都要去实现它，这没有意义。

15. Iterator和ListIterator之间有什么区别？

1. Iterator可以遍历Set和List集合，而ListIterator只能遍历List。
2. Iterator只能单向遍历，而ListIterator可以双向遍历。
3. ListIterator继承于Iterator，然后添加了额外的功能，例如添加一个元素、替换一个元素、获取前面或者后面元素的索引位置。

16. 遍历一个List有哪些不同的方式？

List<String> strList = new ArrayList<>();
//使用for-each循环
for(String obj : strList){
  System.out.println(obj);
}
//using iterator
Iterator<String> it = strList.iterator();
while(it.hasNext()){
  String obj = it.next();
  System.out.println(obj);
}

使用迭代器更加线程安全，因为它可以确保，在当前遍历的集合元素被更改的时候，它会抛出ConcurrentModificationException。

17. 通过迭代器fail-fast属性，你明白了什么？

每次我们尝试获取下一个元素的时候，Iterator fail-fast属性检查当前集合结构里的任何改动。如果发现任何改动，它抛出ConcurrentModificationException。Collection中所有Iterator的实现都是按fail-fast来设计的（ConcurrentHashMap和CopyOnWriteArrayList这类并发集合类除外）。

18. fail-fast与fail-safe有什么区别？

1. Java.util包中的所有集合类都被设计为fail-fast的，而java.util.concurrent中的集合类都为fail-safe的。
2. Fail-fast迭代器抛出ConcurrentModificationException，而fail-safe迭代器从不抛出ConcurrentModificationException。

19. 在迭代一个集合的时候，如何避免ConcurrentModificationException？

在遍历一个集合的时候，我们可以使用并发集合类来避免ConcurrentModificationException，比如使用CopyOnWriteArrayList，而不是ArrayList。

20. 为何Iterator接口没有具体的实现？

Iterator接口定义了遍历集合的方法，但它的实现则是集合实现类的责任。每个能够返回用于遍历的Iterator的集合类都有它自己的Iterator实现内部类。

这就允许集合类去选择迭代器是fail-fast还是fail-safe的。比如，ArrayList迭代器是fail-fast的，而CopyOnWriteArrayList迭代器是fail-safe的。

21. UnsupportedOperationException是什么？

UnsupportedOperationException是用于表明操作不支持的异常。在JDK类中已被大量运用，在集合框架java.util.Collections.UnmodifiableCollection将会在所有add和remove操作中抛出这个异常。

22. hashCode()和equals()方法有何重要性？

HashMap使用Key对象的hashCode()和equals()方法去决定key-value对的索引。当我们试着从HashMap中获取值的时候，这些方法也会被用到。如果这些方法没有被正确地实现，在这种情况下，两个不同Key也许会产生相同的hashCode()和equals()输出，HashMap将会认为它们是相同的，然后覆盖它们，而非把它们存储到不同的地方。同样的，所有不允许存储重复数据的集合类都使用hashCode()和equals()去查找重复，所以正确实现它们非常重要。equals()和hashCode()的实现应该遵循以下规则：

（1）如果o1.equals(o2)，那么o1.hashCode() == o2.hashCode()总是为true的。

（2）如果o1.hashCode() == o2.hashCode()，并不意味着o1.equals(o2)会为true。

23. HashMap实现原理？

参考：https://www.cnblogs.com/chengxiao/p/6059914.html

24. 能否使用任何类作为Map的key？

https://blog.csdn.net/u010954806/article/details/79174095
我们可以使用任何类作为Map的key。然而在使用它们之前，需要考虑以下几点：

1. 类的所有实例需要遵守与equals()和hashCode()相关的规则。如22
2. 如果类重写了equals()方法，也就必须重写hashCode()方法。

25. Map接口提供了哪些不同的集合视图？

Map接口提供的三个集合视图：

1. Set keyset()：返回map中包含的所有key的一个Set视图。集合是受map支持的，map的变化会在集合中反映出来，反之亦然。当一个迭代器正在遍历一个集合时，若map被修改了（除迭代器自身的移除操作以外），迭代器的结果会变为未定义。集合支持通过Iterator的Remove、Set.remove、removeAll、retainAll和clear操作进行元素移除，从map中移除对应的映射。它不支持add和addAll操作。

2. Collection values()：返回一个map中包含的所有value的一个Collection视图。这个collection受map支持的，map的变化会在collection中反映出来，反之亦然。当一个迭代器正在遍历一个collection时，若map被修改了（除迭代器自身的移除操作以外），迭代器的结果会变为未定义。集合支持通过Iterator的Remove、Set.remove、removeAll、retainAll和clear操作进行元素移除，从map中移除对应的映射。它不支持add和addAll操作。

3. Set> entrySet()：返回一个map钟包含的所有映射的一个集合视图。这个集合受map支持的，map的变化会在collection中反映出来，反之亦然。当一个迭代器正在遍历一个集合时，若map被修改了（除迭代器自身的移除操作，以及对迭代器返回的entry进行setValue外），迭代器的结果会变为未定义。集合支持通过Iterator的Remove、Set.remove、removeAll、retainAll和clear操作进行元素移除，从map中移除对应的映射。它不支持add和addAll操作。

26. 如何决定选用HashMap还是TreeMap？

TreeMap的Key值是要求实现java.lang.Comparable，所以迭代的时候TreeMap默认是按照Key值升序排序的，TreeMap的实现也是基于红黑树结构。

而HashMap的Key值实现散列hashCode(),分布是散列的均匀的，不支持排序；数据结构主要是桶(数组),链表或红黑树。

大多情况下HashMap有更好的性能，所以大多不需要排序的时候我们会使用HashMap.

27. Array和ArrayList有何区别，什么时候适合用Array。

Array可以容纳基本类型和对象，而ArrayList只能容纳对象。

Array是指定大小的，而ArrayList大小是固定的。

Array没有提供ArrayList那么多功能，比如addAll、removeAll和iterator等。尽管ArrayList明显是更好的选择，但也有些时候Array比较好用。

（1）如果列表的大小已经指定，大部分情况下是存储和遍历它们。

（2）对于遍历基本数据类型，尽管Collections使用自动装箱来减轻编码任务，在指定大小的基本类型的列表上工作也会变得很慢。

（3）如果你要使用多维数组，使用[][]比List>更容易。

28. ArrayList和LinkedList有何区别？

ArrayList和LinkedList两者都实现了List接口，但是它们之间有些不同。

（1）ArrayList是由Array所支持的基于一个索引的数据结构，所以它提供对元素的随机访问，复杂度为O(1)，但LinkedList存储一系列的节点数据，每个节点都与前一个和下一个节点相连接。所以，尽管有使用索引获取元素的方法，内部实现是从起始点开始遍历，遍历到索引的节点然后返回元素，时间复杂度为O(n)，比ArrayList要慢。

（2）与ArrayList相比，在LinkedList中插入、添加和删除一个元素会更快，因为在一个元素被插入到中间的时候，不会涉及改变数组的大小，或更新索引。

（3）LinkedList比ArrayList消耗更多的内存，因为LinkedList中的每个节点存储了前后节点的引用。

29. 哪些集合类提供对元素的随机访问？

ArrayList、HashMap、TreeMap和HashTable类提供对元素的随机访问。

30. EnumSet是什么？

java.util.EnumSet是使用枚举类型的集合实现。当集合创建时，枚举集合中的所有元素必须来自单个指定的枚举类型，可以是显示的或隐示的。EnumSet是不同步的，不允许值为null的元素。它也提供了一些有用的方法，比如copyOf(Collection c)、of(E first,E…rest)和complementOf(EnumSet s)。

31. 哪些集合类是线程安全的？

Vector、HashTable、Properties和Stack是同步类，所以它们是线程安全的，可以在多线程环境下使用。Java1.5并发API包括一些集合类，允许迭代时修改，因为它们都工作在集合的克隆上，所以它们在多线程环境中是安全的。

32. 并发集合类是什么？

Java1.5并发包（java.util.concurrent）包含线程安全集合类，允许在迭代时修改集合。迭代器被设计为fail-safe的，不会抛出ConcurrentModificationException。一部分类为：CopyOnWriteArrayList、 ConcurrentHashMap、CopyOnWriteArraySet。

33. BlockingQueue是什么？

参考：1. https://www.cnblogs.com/tjudzj/p/4454490.html
参考：2. https://www.cnblogs.com/zaizhoumo/p/7786793.html

Java.util.concurrent.BlockingQueue是一个阻塞队列。
1）当Queue为空时，获取元素线程被阻塞直到Queue变为非空。
2）当Queue满时，添加元素线程被阻塞直到Queue不满。
3）BlockingQueue不允许元素为null，如果入队一个null元素，会抛NullPointerException。
4）BlockingQueue接口是Java集合框架的一部分，主要用于实现生产者-消费者模式。Java提供了集中BlockingQueue的实现，比如ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue,、SynchronousQueue等。

33. 队列和栈是什么，列出它们的区别？

栈和队列两者都被用来预存储数据。

1. 队列(Queue)：是限定只能在表的一端进行插入和在另一端进行删除操作的线性表
2. 栈(Stack)：是限定只能在表的一端进行插入和删除操作的线性表
3. 队列先进先出(FIFO)，栈先进后出(FILO)
4. Stack是一个扩展自Vector的类，而Queue是一个接口。

34. Collections类是什么？

参考： https://zhidao.baidu.com/question/237396144.html

Java.util.Collections是一个工具类仅包含静态方法，它们操作或返回集合。它包含操作集合的多态算法，返回一个由指定集合支持的新集合和其它一些内容。这个类包含集合框架算法的方法，比如折半搜索、排序、混编和逆序等。

35. Comparable和Comparator接口是什么？

如果我们想使用Array或Collection的排序方法时，需要在自定义类里实现Java提供Comparable接口。Comparable接口有compareTo(T OBJ)方法，它被排序方法所使用。我们应该重写这个方法，如果“this”对象比传递的对象参数更小、相等或更大时，它返回一个负整数、0或正整数。但是，在大多数实际情况下，我们想根据不同参数进行排序。比如，作为一个CEO，我想对雇员基于薪资进行排序，一个HR想基于年龄对他们进行排序。这就是我们需要使用Comparator接口的情景，因为Comparable.compareTo(Object o)方法实现只能基于一个字段进行排序，我们不能根据对象排序的需要选择字段。Comparator接口的compare(Object o1, Object o2)方法的实现需要传递两个对象参数，若第一个参数比第二个小，返回负整数；若第一个等于第二个，返回0；若第一个比第二个大，返回正整数。

36. Comparable和Comparator接口有何区别？

Comparable和Comparator接口被用来对对象集合或者数组进行排序。Comparable接口被用来提供对象的自然排序，我们可以使用它来提供基于单个逻辑的排序。
Comparator接口被用来提供不同的排序算法，我们可以选择需要使用的Comparator来对给定的对象集合进行排序。
Comparable被称为内部比较器，Comparator被称为外部比较器。

37. 我们如何对一组对象进行排序？

1. 如果我们需要对一个对象数组进行排序，我们可以使用Arrays.sort()方法。
2. 如果我们需要排序一个对象列表，我们可以使用Collections.sort()方法。
3. 两个类都有用于自然排序（使用Comparable）或基于标准的排序（使用Comparator）的重载方法sort()。
4. Collections内部使用数组排序方法，所有它们两者都有相同的性能，只是Collections需要花时间将列表转换为数组。

38. 当一个集合被作为参数传递给一个函数时，如何才可以确保函数不能修改它？

在作为参数传递之前，我们可以使用Collections.unmodifiableCollection(Collection c)方法创建一个只读集合，这将确保改变集合的任何操作都会抛出UnsupportedOperationException。

39.我们如何从给定集合那里创建一个synchronized的集合？

我们可以使用Collections.synchronizedCollection(Collection c)根据指定集合来获取一个synchronized（线程安全的）集合。

40.集合框架里实现的通用算法有哪些？

Java集合框架提供常用的算法实现，比如排序和搜索。Collections类包含这些方法实现。大部分算法是操作List的，但一部分对所有类型的集合都是可用的。部分算法有排序、搜索、混编、最大最小值。

41.大写的O是什么？举几个例子？

大写的O描述的是，一个算法的复杂度。Collection类就是实际的数据结构，我们通常基于时间、内存和性能，使用大写的O来选择集合实现。比如：例子1：ArrayList的get(index i)是一个常量时间操作，它不依赖list中元素的数量。所以它的性能是O(1)。例子2：一个对于数组或列表的线性搜索的性能是O(n)，因为我们需要遍历所有的元素来查找需要的元素。

42.与Java集合框架相关的有哪些最好的实践？

（1）根据需要选择正确的集合类型。比如，如果指定了大小，我们会选用Array而非ArrayList。如果我们想根据插入顺序遍历一个Map，我们需要使用TreeMap。如果我们不想重复，我们应该使用Set。

（2）一些集合类允许指定初始容量，所以如果我们能够估计到存储元素的数量，我们可以使用它，就避免了重新哈希或大小调整。

（3）基于接口编程，而非基于实现编程，它允许我们后来轻易地改变实现。

（4）总是使用类型安全的泛型，避免在运行时出现ClassCastException。

（5）使用JDK提供的不可变类作为Map的key，可以避免自己实现hashCode()和equals()。

（6）尽可能使用Collections工具类，或者获取只读、同步或空的集合，而非编写自己的实现。它将会提供代码重用性，它有着更好的稳定性和可维护性。

43. HashMap 和 ConcurrentHashMap 的区别？

https://www.cnblogs.com/heyonggang/p/9112731.html
https://blog.csdn.net/sinbadfreedom/article/details/80375048
https://www.cnblogs.com/shan1393/p/8999458.html

44. 当两个对象的 hashCode 相同会发生什么？

【这个问题基本上就是分界点了】

一些面试者会回答因为hashcode相同，所以两个对象是相等的，HashMap将会抛出异常，或者不会存储它们。
如果之前的问题回答的好，面试官的印象比较好，可能会提醒他们有equals()和hashCode()两个方法，并告诉他们两个对象就算hashcode相同，但是它们可能并不相等。
如果掌握的不太好，一些面试者可能就此放弃。那下面的问题也就不了了之了，等于放弃了一个很好的机会。
而这个问题的答案是：因为hashcode相同，所以它们的bucket位置相同，‘碰撞’会发生。因为HashMap使用链表存储对象，这个Entry(包含有键值对的Map.Entry对象)会存储在链表中。这个时候要理解根据hashcode来划分的数组，如果数组的坐标相同，则进入链表这个数据结构中了，一般的添加都在最前面，也就是和数组下标直接相连的地方，链表长度到达8的时候，jdk1.8上升为红黑树，这样说，无疑是直接的加分项。有的面试官直接跳入数据结构，有的会直接继续挖掘。

45. 有哪些顺序的 HashMap 实现类？

Hashmap和Hashtable 都不是有序的。

TreeMap和LinkedHashmap都是有序的。（TreeMap默认是key升序，LinkedHashmap默认是数据插入顺序）

TreeMap是基于比较器Comparator来实现有序的。

LinkedHashmap是基于链表来实现数据插入有序的。

https://blog.csdn.net/weixin_34290390/article/details/86841631

46. HashSet 的工作原理是什么？

https://blog.csdn.net/guoweimelon/article/details/50804799