Java 2.2 - Java 集合

当需要对集合进行自定义排序的时候，例如对 song 对象歌名 / 歌手顺序进行排序的时候，我们可以通过重写 comparable 的 compareTo 方法和使用自制的 Comparator 方法；或者以两个 Comparator 来实现排序，这种方法代表我们只能使用两个参数版的 Collection.sort()。

定制排序的编写方法：

1、comparable（对于没有实现 Comparable 接口的类，必须实现其才能通过重写 compareTo 方法进行排序）

重写方法

2、 Comparator 定制排序

（11）无序性和不可重复性的含义是什么？

无序性

无序性不等于随机性，无序性是指存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值进行添加的。

不可重复性

是指添加的元素按照 equals() 进行判断的时候，返回值为false。

（12）HashSet、LinkedHashSet、TreeSet三者有何异同？

它们是 Set 接口的三个实现类，它们都能保证元素唯一且都不是线程安全的。

它们的区别在于底层的数据结构不同。HashSet 的底层数据结构为 HashMap；LinkedHashSet 的底层是 HashMap 和链表，取出元素的顺序满足 FIFO；TreeSet 的底层数据结构为红黑树，排序的方法有自然排序和定制排序。

（13）Queue 和 Deque 有什么区别？

Queue 是单端队列，只能从队尾进行数据的添加，队首进行数据的删除。一般满足 FIFO。

Queue 拓展了 Collection 接口，根据因为容量不足而导致的数据操作失败，一类方法在失败后会抛出异常，一类方法在失败后会返回特殊值。

Deque 拓展了 Queue，它是一个双端队列，可以从队尾队首任意一端进行数据的添加和删除，同样根据数据操作失败后的处理分为两类方法。

Deque 还有 push() 和 pop() 方法可以用来模拟栈。

（14）ArrayDeque 和 LinkedList 的区别是什么？

ArrayDeque 和 LinkedList 都实现了 Deque 接口，它们都具有队列的功能。

（15）你知道 PriorityQueue 吗？

PriorityQueue 在 JDK1.5 中被引入，它与 Queue 的区别在于：队列是 FIFO 的；而优先队列先出队的元素是优先级最高的元素。

要点：

1、PriorityQueue 利用二叉堆的数据结构进行实现，底层使用可变长的数据来存储数据。

2、PriorityQueue 的时间复杂度为 O(logn)，即堆排序的时间复杂度。

3、PriorityQueue 不是线程安全的，且不能存储 null 和 non-comparable 对象。

4、PriorityQueue 默认是最小堆，但可以接收一个 Comparator 参数来自定义排序方法（优先级大小）。

PriorityQueue 在面试中经常出现于手撕算法中，尤其是堆排序、求第K大数等等，需要熟练掌握。

（16）HashMap 和 Hashtable 的区别是什么？

1、HashMap 不是线程安全的，Hashtable 是线程安全的。

2、HashMap 效率高于 Hashtable（因为线程安全问题）。

3、HashMap 可以存储 null key 和 null value；Hashtable 不支持存储 null key 和 null value。

4、HashMap 默认容量为11，每次扩充变成 2n+1; Hashtable 默认大小为 16，每次扩充变成 2n。

HashMap 如果给定容量，它会初始化为 2 的幂次大小；Hashtable 会直接使用你给定的大小。

5、HashMap 底层数据结构使用的是数组、链表和红黑树；Hashtable 未使用红黑树。

* HashMap 中使用 2 的幂作为哈希表的大小代码。

这里做一下讲解：

我们希望使用 2 的幂大小，在二进制看来，实际上就是使得其最高位的下一位变为1，其余都为0（除了本身就是 2 的幂大小的数，这就是为什么 n 需要先减1）

那么我们的做法是这样的：

1、第1次将该数右移1位，与原数做或运算，这样就会有2位变成1；

2、第2次将该数右移2位，与原数做或运算，这样就会有4位变成1；

3、第3次将该数右移4位，与原数做或运算，这样就会有8位变成1；

4、第4次将该数右移8位，与原数做或运算，这样就会有16位变成1；

2、第5次将该数右移16位，与原数做或运算，这样就会有32位变成1；

这样就可以保证一个 int 类型的数在 + 1 之后一定是 2 的幂次大小，因为二进制数字如果都是1的话，那么他加一后就是首位为1其他位都是0，这个数字肯定是 2 的幂次方。

某次过程：

当某个数较小的时候，后面会有一些多余的运算但效率影响很小。

为什么 HashMap 的长度为什么需要是2的幂次方？

为了能让hashMap存取高效，尽量减少碰撞，也就是要尽量把数据分配均匀。在插入数据之前做取模运算，得到的余数就是将要存放的数据在哈希表中对应的下标。在HashMap中这个下标的取值算法是：(n - 1) & hash n是哈希表的长度。

（17）HashMap 和 HashSet 有什么区别？

（18）HashMap 和 TreeMap 有什么区别？

HashMap 和 TreeMap 都继承自 AbstractMap，但是 TreeMap 还实现了 NavigableMap 和 SortedMap 接口。

Navigable 接口让 TreeMap 有了对集合内元素进行搜索的能力；

SortedMap 接口让 TreeMap 有了对 key 进行排序的能力（默认升序）。

Lambda 表达式实现自定义排序：

综上，TreeMap 相比 HashMap 有了对集合内元素搜索的能力和按照 key 进行排序的能力。

（19）HashSet 如何检查重复？

当把对象加入到 HashSet 中时，首先会计算对象的 hashcode 是否存在相同值；如果不存在则加入，如果存在相同的 hashcode，则使用 equals 方法判断它们是否真的一致；如果相同，HashSet就不会让加入操作成功。

（20）HashMap 的底层实现

1.8之前

HashMap 底层是数组和链表结合在一起实现。

HashMap 通过 key 的 hashcode 经过扰动函数后得到 hash 值，再通过 (n - 1) & hash 得到 value 需要插入的位置。如果当前位置存在元素的话，则比较它们是否相同。如果不同则使用拉链法解决冲突，如果相同的话直接进行覆盖。

* 扰动函数

扰动函数指的就是 HashMap 的 hash 方法。使用 hash 方法的原因是防止一些实现比较差的 hashcode() 方法产生影响，减小碰撞概率。

1.8之后

当链表长度大于阈值（默认为8）（将链表转换为红黑树之前对数组的长度进行判断，如果数组长度小于 64 先进行扩容，大于 64 才进行红黑树转换）时，将链表转换为红黑树，减少搜索时间。

为什么不使用二叉搜索树？

原因：二叉搜索树在某种情况下会退化成线性结构，而红黑树是一个平衡的二叉搜索树，可以避免这种情况。

（21）HashMap 多线程操作导致死循环问题

这个问题就是前面说的那个头插法导致的死循环问题。

在 1.8 之后得到了解决

（22）HashMap 有哪几种常见的遍历方式？

HashMap 有七种遍历方式

1、使用迭代器（Iterator）EntrySet 的方式进行遍历；

public class EntrySet {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "Java");
        map.put(2, "JDK");
        map.put(3, "Spring Framework");
        map.put(4, "MyBatis framework");

        Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
        while(iterator.hasNext()){
            Map.Entry<Integer, String> entry = iterator.next();
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }
    }
}

2、使用迭代器（Iterator）KeySet 的方式进行遍历；

public class KeySet {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "Java");
        map.put(2, "JDK");
        map.put(3, "Spring Framework");
        map.put(4, "MyBatis framework");

        Iterator<Integer> iterator = map.keySet().iterator();
        while(iterator.hasNext()){
            Integer key = iterator.next();
            System.out.println(key);
            System.out.println(map.get(key));
        }
    }
}

3、使用 For Each EntrySet 的方式进行遍历；

public class foreachEntrySet {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "Java");
        map.put(2, "JDK");
        map.put(3, "Spring Framework");
        map.put(4, "MyBatis framework");

        for(Map.Entry<Integer,String> entry : map.entrySet()){
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }
    }
}

4、使用 For Each KeySet 的方式进行遍历；

public class foreachKeySet {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "Java");
        map.put(2, "JDK");
        map.put(3, "Spring Framework");
        map.put(4, "MyBatis framework");

        for(Integer key : map.keySet()){
            System.out.println(key);
            System.out.println(map.get(key));
        }
    }
}

5、使用 Lambda 表达式的方式进行遍历；

public class lambda {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "Java");
        map.put(2, "JDK");
        map.put(3, "Spring Framework");
        map.put(4, "MyBatis framework");
        
        map.forEach((key, value) ->{
            System.out.println(key);
            System.out.println(value);
        });
    }
}

6、使用 Streams API 单线程的方式进行遍历；

public class streams1 {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "Java");
        map.put(2, "JDK");
        map.put(3, "Spring Framework");
        map.put(4, "MyBatis framework");

        map.entrySet().stream().forEach((entry) -> {
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        });
    }
}

7、使用 Streams API 多线程的方式进行遍历。

public class streams {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "Java");
        map.put(2, "JDK");
        map.put(3, "Spring Framework");
        map.put(4, "MyBatis framework");

        map.entrySet().parallelStream().forEach((entry) -> {
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        });
    }
}

性能：

可以看出 EntrySet 的执行完成时间最短，性能最好；然后是 stream 和 keySet，性能最差的是 lambda表达式。

结论：entrySet 的性能比 keySet 的性能要高出一倍之多，所以我们应该尽量使用 entrySet 来进行Map 集合的遍历。

（23）ConcurrentHashMap 和 Hashtable 的区别是什么？

它们都是线程安全的，但是在实现线程安全的方式不同。

实现线程安全的方式

ConcurrentHashMap

1.7 的时候，ConcurrentHashMap 对整个桶数组进行了分割分段（Segment，分段锁），每一把锁只锁容器内其中一部分数据，多线程访问不同数据段内的数据的时候不存在冲突，可以提高并发访问率。

1.8 的时候，ConcurrentHashMap 摒弃了 Segment，转而使用 Node数组 + 链表 + 红黑树的数据结构进行实现，并发控制使用 synchronized 和 CAS 进行操作。整个就是 HashMap 进行优化且线程安全的升级版本。

Hashtable

也是使用 synchronized 来保证线程安全，效率非常低下。当一个线程访问同步方法是，另一个线程也访问该方法，另一个线程可能进入阻塞或者轮询，这会导致竞争越来越激烈，效率越来越低。

（24）ConcurrentHashMap 线程安全的具体实现方法 / 底层具体实现？

1.8 之前

首先将数据分为 segment 的段进行存储，给每一段数据都配一把锁，当其中一个线程占用锁访问一段数据的时候，其他段的数据可以被访问。

数据结构：Segment 数组和 HashEntry 数组

Segment 集成了 ReentrantLock，所以 Segment 是一种可重入锁。HashEntry 用于存储键值对数据。

一个 ConcurrentHashMap 包含一个 Segment 数组，该数组默认大小为 16，也就是默认最高可并发线程数为 16（并发写）。

Segment 的结构和 HashMap 类似，是一种由数组和链表结构，一个 Segment 包含一个 HashEntry 数组，每个 HashEntry 数组保存链表元素。每个 Segment 守护对应的 HashEntry 数组。这也就是说对 HashEntry 数组内的元素进行修改的时候，首先获得对应的 Segment 的锁。

1.8 之后

ConcurrentHashMap 取消了 Segment 分段锁，采用 Node + CAS + synchronized 来保证并发安全，数据结构和 HashMap 1.8 的结构类似。Java 8 中，锁的粒度更细，synchronized 只锁定当前链表或红黑树的首节点，这样只要 hash 不冲突，就不会发生并发，就不会影响其他 Node 的读写，效率大幅提升。