java容器篇

Posted 2021-01-01 yonyong

容器
     -Collection 存储对象的集合；Map 存储键值对的映射表
     -Iterator(迭代器模式)
         -集合访问器，用于循环访问集合中的对象
         -所有实现了Collection接口的容器类都有iterator方法，用于返回一个实现了Iterator接口的对象。Iterator对象称作迭代器，Iterator接口方法能以迭代方式逐个访问集合中各个元素，并可以从Collection中除去适当的元素
     -Collection
         -set(特征：无序且不可重复)
             -TreeSet：基于红黑树实现，支持有序性操作，例如根据一个范围查找元素的操作。但是查找效率不如 HashSet，HashSet 查找的时间复杂度为 O(1)，TreeSet 则为 O(logN)。
             -HashSet:基于哈希表实现，支持快速查找，但不支持有序性操作。并且失去了元素的插入顺序信息，也就是说使用 Iterator 遍历 HashSet 得到的结果是不确定的
             -LinkedHashSet:具有 HashSet 的查找效率，且内部使用双向链表维护元素的插入顺序
             -红黑树：漫画看懂红黑树 链接：https://www.sohu.com/a/201923614_466939
         -list(特征：有序且可重复)
             -ArrayList：基于动态数组实现，支持随机访问。
                 -概览
                     -实现了 RandomAccess 接口，因此支持随机访问。这是理所当然的，因为 ArrayList 是基于数组实现的，其数组的默认大小为 10。
                 -序列化
                     -基于数组实现，并且具有动态扩容特性，因此保存元素的数组不一定都会被使用，那么就没必要全部进行序列
                      transient Object[] A; //transient关键字声明数组默认不会被序列化
                         -为什么定义A数组要用transient关键字修饰，使其默认不被序列化？
                             假如现在实际有了5个元素，而elementData的大小可能是10，那么在序列化时只需要储存5个元素，数组中的最后五个元素是没有实际意义的，不需要储存。所以ArrayList的设计者将elementData设计为transient，然后在writeObject方法中手动将其序列化，并且只序列化了实际存储的那些元素，而不是整个数组
                     -序列化时需要使用 ObjectOutputStream 的 writeObject() 将对象转换为字节流并输出。而 writeObject() 方法在传入的对象存在 writeObject() 的时候会去反射调用该对象的 writeObject() 来实现序列化。反序列化使用的是 ObjectInputStream 的 readObject() 方法，原理类似。
                     -java中序列化的目的：
                         -以某种存储形式使自定义对象持久化；
                         -将对象从一个地方传递到另一个地方。
                         -使程序更具维护性
                 -扩容
                     -添加元素时使用 ensureCapacityInternal() 方法来保证容量足够，如果不够时，需要使用 grow() 方法进行扩容，新容量的大小为 oldCapacity + (oldCapacity >> 1)，也就是旧容量的 1.5 倍
                     -扩容操作需要调用 Arrays.copyOf() 把原数组整个复制到新数组中，这个操作代价很高，因此最好在创建 ArrayList 对象时就指定大概的容量大小，减少扩容操作的次数
                 -删除元素
                     -需要调用 System.arraycopy() 将 index+1 后面的元素都复制到 index 位置上，该操作的时间复杂度为 O(N)， ArrayList 删除元素的代价是非常高的。
                 -fail-fast
                     -modCount 用来记录 ArrayList 结构发生变化的次数。结构发生变化是指添加或者删除至少一个元素的所有操作，或者是调整内部数组的大小，仅仅只是设置元素的值不算结构发生变化
                     -在进行序列化或者迭代等操作时，需要比较操作前后 modCount 是否改变，如果改变了需要抛出 ConcurrentModificationException。
                 -fail-fast与fail-safe
                     -fail-fast
                         -fail-fast机制在遍历一个集合时，当集合结构被修改，会抛出ConcurrentModificationException。
                         -java.util包下的集合类都是快速失败的，不能在多线程下发生并发修改（迭代过程中被修改）。
                     -fail-safe
                         -fail-safe任何对集合结构的修改都会在一个复制的集合上进行修改，不像fail-fast在原集合上修改，因此不会抛出ConcurrentModificationException
                         -java.util.concurrent包下的容器都是安全失败，可以在多线程下并发使用，并发修改。
                         -优点
                             -避免了ConcurrentModificationException
                         -缺点
                             -需要复制集合，产生大量的无效对象，开销大
                             -无法保证读取的数据是目前原始数据结构中的数据。
                             -迭代器并不能访问到修改后的内容，即：迭代器遍历的是开始遍历那一刻拿到的集合拷贝，在遍历期间原集合发生的修改迭代器是不知道的。
             -Vector：和 ArrayList 类似，但它是线程安全的。
                 -它的实现与 ArrayList 类似，但是使用了 synchronized 进行同步。因此是线程安全的
                 -与ArrayList比较
                     -Vector 是同步的，因此开销就比 ArrayList 要大，访问速度更慢。最好使用 ArrayList 而不是 Vector，因为同步操作完全可以由程序员自己来控制；
                     -Vector 每次扩容请求其大小的 2 倍空间，而 ArrayList 是 1.5 倍。
             -LinkedList：基于双向链表实现，只能顺序访问，但是可以快速地在链表中间插入和删除元素。不仅如此，LinkedList 还可以用作栈、队列和双向队列。
                 -概览
                     -基于双向链表实现，使用 Node 存储链表节点信息。
                       private static class Node<E> {
                             E item;
                             Node<E> next;
                             Node<E> prev;
                         }
                       每个链表存储了 first 和 last 指针
                       transient Node<E> first;
                       transient Node<E> last;
                 -与 ArrayList 的比较
                     -ArrayList 基于动态数组实现，LinkedList 基于双向链表实现；
                     -ArrayList 支持随机访问，LinkedList 不支持；
                     -LinkedList 在任意位置添加删除元素更快。
     -Map
         -TreeMap：基于红黑树实现
         -HashMap：基于哈希表实现。
             -存储结构
                 -内部包含了一个 Entry 类型的数组 table。
                     transient Entry[] table;
                     Entry 存储着键值对。它包含了四个字段，从 next 字段我们可以看出 Entry 是一个链表。即数组中的每个位置被当成一个桶，一个桶存放一个链表。HashMap 使用拉链法来解决冲突，同一个链表中存放哈希值相同的 Entry。
                     {{{{{{{entry结构图}}}}}}}
             - 拉链法的工作原理
                 HashMap<String, String> map = new HashMap<>();
                 map.put("K1", "V1");
                 map.put("K2", "V2");
                 map.put("K3", "V3");
                 新建一个 HashMap，默认大小为 16；
                 插入 <K1,V1> 键值对，先计算 K1 的 hashCode 为 115，使用除留余数法得到所在的桶下标 115%16=3。
                 插入 <K2,V2> 键值对，先计算 K2 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6。
                 插入 <K3,V3> 键值对，先计算 K3 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6，插在 <K2,V2> 前面。
                
                 -应该注意到链表的插入是以头插法方式进行的，例如上面的 <K3,V3> 不是插在 <K2,V2> 后面，而是插入在链表头部。
                 -查找需要分成两步进行：
                     -计算键值对所在的桶；
                     -在链表上顺序查找，时间复杂度显然和链表的长度成正比。
             -put操作
                 -HashMap 允许插入键为 null 的键值对。但是因为无法调用 null 的 hashCode() 方法，也就无法确定该键值对的桶下标，只能通过强制指定一个桶下标来存放。HashMap 使用第 0 个桶存放键为 null 的键值对。
             -确定桶下标
             -扩容
                 -基本原理
                 -重新计算桶下标
                 -计算数组容量
             -链表转红黑树
                 -从 JDK 1.8 开始，一个桶存储的链表长度大于 8 时会将链表转换为红黑树
             -与 HashTable 的比较
                 HashTable 使用 synchronized 来进行同步。
                 HashMap 可以插入键为 null 的 Entry。
                 HashMap 的迭代器是 fail-fast 迭代器。
                 HashMap 不能保证随着时间的推移 Map 中的元素次序是不变的。
         -HashTable：和 HashMap 类似，但它是线程安全的，这意味着同一时刻多个线程可以同时写入 HashTable 并且不会导致数据不一致。它是遗留类，不应该去使用它。现在可以使用 ConcurrentHashMap 来支持线程安全，并且 ConcurrentHashMap 的效率会更高，因为 ConcurrentHashMap 引入了分段锁。
         -LinkedHashMap：使用双向链表来维护元素的顺序，顺序为插入顺序或者最近最少使用（LRU）顺序。