Java容器（List、Set、Map）知识点快速复习手册（上）

时间  2020-12-08
标签 html java git github 面试 算法 编程 设计模式 数组 安全 栏目 Java 繁體版
原文   原文链接

Java容器（List、Set、Map）知识点快速复习手册（上）

前言

本文快速回顾了Java中容器的知识点，用做面试复习，事半功倍。html

上篇：主要为容器概览，容器中用到的设计模式，List源码java

中篇：Map源码git

下篇：Set源码，容器总结github

其它知识点复习手册

  • Java基础知识点面试手册（上）面试

  • Java基础知识点面试手册（下）

概览

容器主要包括 Collection 和 Map 两种，Collection 又包含了 List、Set 以及 Queue。算法

Collection

Java容器（List、Set、Map）知识点快速复习手册（上）
Java容器（List、Set、Map）知识点快速复习手册（上）

数组和集合的区别:编程

  • 长度
  • 数组的长度固定
  • 集合的长度可变
  • 内容
  • 数组存储的是同一种类型的元素
  • 集合能够存储不一样类型的元素(可是通常咱们不这样干..)
  • 元素的数据类型
  • 数组能够存储基本数据类型,也能够存储引用类型
  • 集合只能存储引用类型(若存储的是简单的int，它会自动装箱成Integer)

1. Set（元素不可重复）

  • HashSet：基于HashMap实现，支持快速查找，但不支持有序性操做。

TreeSet：基于红黑树实现，支持有序性操做，可是查找效率不如 HashSet，HashSet 查找时间复杂度为 O(1)，TreeSet 则为 O(logN)；设计模式

LinkedHashSet：具备 HashSet 的查找效率，且内部使用链表维护元素的插入顺序。数组

2. List（有序(存储顺序和取出顺序一致)，可重复）

  • ArrayList：基于动态数组实现，支持随机访问；安全

  • Vector：和 ArrayList 相似，但它是线程安全的；

  • LinkedList：基于双向链表实现，只能顺序访问，可是能够快速地在链表中间插入和删除元素。不只如此，LinkedList 还能够用做栈、队列和双向队列。

3. Queue

  • LinkedList：能够用它来支持双向队列；

  • PriorityQueue：基于堆结构实现，能够用它来实现优先队列。

Map

Java容器（List、Set、Map）知识点快速复习手册（上）

  • HashMap：基于哈希实现；

  • HashTable：和 HashMap 相似，但它是线程安全的，这意味着同一时刻多个线程能够同时写入 HashTable 而且不会致使数据不一致。它是遗留类，不该该去使用它。

  • ConcurrentHashMap：支持线程安全，而且 ConcurrentHashMap 的效率会更高，由于 ConcurrentHashMap 引入了分段锁。

  • LinkedHashMap：使用链表来维护元素的顺序，顺序为插入顺序或者最近最少使用（LRU）顺序。

  • TreeMap：基于红黑树实现。

Fail-Fast 机制和 Fail-Safe 机制

https://blog.csdn.net/Kato_op/article/details/80356618

Fail-Fast

Fail-fast 机制是 java 集合(Collection)中的一种错误机制。 当多个线程对同一个集合的内容进行操做时，就可能会产生 fail-fast 事件。

  • 迭代器在遍历时直接访问集合中的内容,而且在遍历过程当中使用一个modCount变量,

  • 集合中在被遍历期间若是内容发生变化(增删改),就会改变modCount的值,

  • 每当迭代器使用 hashNext()/next()遍历下一个元素以前,都会执行checkForComodification()方法检测，modCount变量和expectedmodCount值是否相等,

  • 若是相等就返回遍历,不然抛出异常,终止遍历.

注意，若是集合发生变化时修改modCount值, 恰好有设置为了expectedmodCount值, 则异常不会抛出.(好比删除了数据,再添加一条数据)

因此，通常来讲，存在非同步的并发修改时，不可能做出任何坚定的保证。

迭代器的快速失败行为应该仅用于检测程序错误, 而不是用他来同步。

java.util包下的集合类都是Fail-Fast机制的,不能在多线程下发生并发修改(迭代过程当中被修改).

Fail-Safe

采用安全失败（Fail-Safe）机制的集合容器,在遍历时不是直接在集合内容上访问的，而是先copy原有集合内容,在拷贝的集合上进行遍历。

原理:

因为迭代时是对原集合的拷贝的值进行遍历,因此在遍历过程当中对原集合所做的修改并不能被迭代器检测到,因此不会出发ConcurrentModificationException

缺点:

迭代器并不能访问到修改后的内容(简单来讲就是, 迭代器遍历的是开始遍历那一刻拿到的集合拷贝,在遍历期间原集合发生的修改迭代器是不知道的)

使用场景:

java.util.concurrent包下的容器都是Fail-Safe的,能够在多线程下并发使用,并发修改

容器中使用的设计模式

迭代器模式

Java容器（List、Set、Map）知识点快速复习手册（上）

  • Iterator它是在ArrayList等集合的内部类的方式实现
    Collection 实现了 Iterable 接口，其中的 iterator() 方法可以产生一个 Iterator 对象，经过这个对象就能够迭代遍历 Collection 中的元素。

从 JDK 1.5 以后可使用 foreach 方法来遍历实现了 Iterable 接口的聚合对象。

List<String> list =newArrayList<>();
list.add("a");
list.add("b");
for(String item : list){ 
    System.out.println(item);
}

适配器模式

适配器模式解释：https://www.jianshu.com/p/93821721bf08

java.util.Arrays#asList() 能够把数组类型转换为 List 类型。

@SafeVarargs
public  static <T>  List<T>  asList(T... a)

若是要将数组类型转换为 List 类型，应该注意的是 asList() 的参数为泛型的变长参数，所以不能使用基本类型数组做为参数，只能使用相应的包装类型数组。

Integer[ ]  arr =   {1, 2, 3};
List list = Arrays.asList(arr);

也可使用如下方式生成 List。

List  list = Arrays.asList(1 ,2, 3);

源码分析

ArrayList

关键词

  • 默认大小为 10
  • 扩容 1.5 倍，加载因子为 0.5
  • 基于动态数组实现
  • 删除元素时不会减小容量，若但愿减小容量则调用trimToSize()
  • 它不是线程安全的
  • 它能存放null值。
  • 扩容操做须要调用 Arrays.copyOf() 把原数组整个复制到新数组
  • 删除须要调用 System.arraycopy() 将 index+1 后面的元素都复制到 index 位置上，复制的代价很高。 -序列化：只序列化数组中有元素填充那部份内容

概览

Java容器（List、Set、Map）知识点快速复习手册（上）

实现了 RandomAccess 接口，所以支持随机访问。这是理所固然的，由于 ArrayList 是基于数组实现的。

public  class  ArrayList<E> extends  AbstractList<E>
        implements  List<E>,  RandomAccess,  Cloneable, java.io.Serializable

扩容

若是不够时，须要使用 grow() 方法进行扩容，新容量的大小为 oldCapacity+(oldCapacity>>1)，也就是旧容量的 1.5 倍。

扩容操做须要调用 Arrays.copyOf() 把原数组整个复制到新数组中

所以最好在建立 ArrayList 对象时就指定大概的容量大小，减小扩容操做的次数。

public boolean add(E e) {
   ensureCapacityInternal(size + 1);  // Increments modCount!!
   elementData[size++] = e;
   return true;
}

private void ensureCapacityInternal(int minCapacity) {
   if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
       minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
   }
   ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
   modCount++;
   // overflow-conscious code
   if (minCapacity - elementData.length > 0)
       grow(minCapacity);
}

private void grow(int minCapacity) {
   // overflow-conscious code
   int oldCapacity = elementData.length;
   int newCapacity = oldCapacity + (oldCapacity >> 1);
   if (newCapacity - minCapacity < 0)
       newCapacity = minCapacity;
   if (newCapacity - MAX_ARRAY_SIZE > 0)
       newCapacity = hugeCapacity(minCapacity);
   // minCapacity is usually close to size, so this is a win:
   elementData = Arrays.copyOf(elementData, newCapacity);
}

加入元素：add

add(E e)

首先去检查一下数组的容量是否足够

  • 足够：直接添加
  • 不足够：扩容
    扩容到原来的1.5倍，第一次扩容后，若是容量仍是小于minCapacity，就将容量扩充为minCapacity。

add(int index, E element)

步骤：

  • 检查角标
  • 空间检查，若是有须要进行扩容
  • 插入元素

删除元素：remove

步骤：

  • 检查角标
  • 删除元素
  • 计算出须要移动的个数，并移动
  • 设置为null，让GC回收（因此说不是马上回收，而是等待GC回收）
public E remove(int index) {
   rangeCheck(index);
   modCount++;
   E oldValue = elementData(index);
   int numMoved = size - index - 1;
   if (numMoved > 0)
       System.arraycopy(elementData, index+1, elementData, index, numMoved);
   elementData[--size] = null; // clear to let GC do its work
   return oldValue;
}

须要调用 System.arraycopy() 将 index+1 后面的元素都复制到 index 位置上，复制的代价很高。

复制数组：System.arraycopy()

看到arraycopy()，咱们能够发现：该方法是由C/C++来编写的

Java容器（List、Set、Map）知识点快速复习手册（上）

Fail-Fast

modCount 用来记录 ArrayList 结构发生变化的次数。结构发生变化是指添加或者删除至少一个元素的全部操做，或者是调整内部数组的大小，仅仅只是设置元素的值不算结构发生变化。

在进行序列化或者迭代等操做时，须要比较操做先后 modCount 是否改变，若是改变了须要抛出 ConcurrentModificationException。

private void writeObject(java.io.ObjectOutputStream s)
   throws java.io.IOException{
   // Write out element count, and any hidden stuff
   int expectedModCount = modCount;
   s.defaultWriteObject();

   // Write out size as capacity for behavioural compatibility with clone()
   s.writeInt(size);

   // Write out all elements in the proper order.
   for (int i=0; i<size; i++) {
       s.writeObject(elementData[i]);
   }

   if (modCount != expectedModCount) {
       throw new ConcurrentModificationException();
   }
}

构造器

ArrayList 提供了三种方式的构造器：

  • public ArrayList()能够构造一个默认初始容量为10的空列表；
  • public ArrayList(int initialCapacity)构造一个指定初始容量的空列表；
  • public ArrayList(Collection c)构造一个包含指定 collection 的元素的列表，这些元素按照该collection的迭代器返回它们的顺序排列的。

序列化

补充：transient讲解

http://www.importnew.com/21517.html

你只须要实现Serilizable接口，将不须要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。

ArrayList 基于数组实现，而且具备动态扩容特性，所以保存元素的数组不必定都会被使用，那么就不必所有进行序列化。

保存元素的数组 elementData 使用 transient 修饰，该关键字声明数组默认不会被序列化。

transient Object[] elementData; // non-private to simplify nested class access

ArrayList 实现了 writeObject() 和 readObject() 来控制只序列化数组中有元素填充那部份内容。

private void readObject(java.io.ObjectInputStream s)
   throws java.io.IOException, ClassNotFoundException {
   elementData = EMPTY_ELEMENTDATA;

   // Read in size, and any hidden stuff
   s.defaultReadObject();

   // Read in capacity
   s.readInt(); // ignored

   if (size > 0) {
       // be like clone(), allocate array based upon size not capacity
       ensureCapacityInternal(size);

       Object[] a = elementData;
       // Read in all elements in the proper order.
       for (int i=0; i<size; i++) {
           a[i] = s.readObject();
       }
   }
}
private void writeObject(java.io.ObjectOutputStream s)
   throws java.io.IOException{
   // Write out element count, and any hidden stuff
   int expectedModCount = modCount;
   s.defaultWriteObject();

   // Write out size as capacity for behavioural compatibility with clone()
   s.writeInt(size);

   // Write out all elements in the proper order.
   for (int i=0; i<size; i++) {
       s.writeObject(elementData[i]);
   }

   if (modCount != expectedModCount) {
       throw new ConcurrentModificationException();
   }
}

序列化时须要使用 ObjectOutputStream 的 writeObject() 将对象转换为字节流并输出。而 writeObject() 方法在传入的对象存在 writeObject() 的时候会去反射调用该对象的 writeObject() 来实现序列化。反序列化使用的是 ObjectInputStream 的 readObject() 方法，原理相似。

ArrayList list = new ArrayList();
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
oos.writeObject(list);

Vector

关键词

  • 默认大小为 10（与Arraylist相同）
  • 扩容 2 倍，加载因子是 1（Arraylist是扩容 1.5 倍，加载因子为 0.5）
  • 其它几乎与ArrayList彻底相同，惟一的区别在于 Vector 是同步的，所以开销就比 ArrayList 要大，访问速度更慢。
  • 使用了 synchronized 进行同步
  • Vector是jdk1.2的类了，比较老旧的一个集合类。应使用JUC的CopyOnWriteArrayList代替

替代方案

可使用 Collections.synchronizedList(); 获得一个线程安全的 ArrayList。

List<String> list = new ArrayList<>();
List<String> synList = Collections.synchronizedList(list);

也可使用 concurrent 并发包下的 CopyOnWriteArrayList 类。

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

CopyOnWriteArrayList

关键词

  • 写操做在一个复制的数组上进行，读操做仍是在原始数组中进行，读写分离，互不影响。
  • 写操做须要加锁，防止并发写入时致使写入数据丢失。
  • 写操做结束以后须要把原始数组指向新的复制数组。
  • 适用于读操做远大于写操做的场景。

读写分离

public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

final void setArray(Object[] a) {
    array = a;
}
@SuppressWarnings("unchecked")
private E get(Object[] a, int index) {
    return (E) a[index];
}

适用场景

CopyOnWriteArrayList 在写操做的同时容许读操做，大大提升了读操做的性能，所以很适合读多写少的应用场景。

缺陷

  • 内存占用：在写操做时须要复制一个新的数组，使得内存占用为原来的两倍左右；
  • 数据不一致：读操做不能读取实时性的数据，由于部分写操做的数据还未同步到读数组中。
    因此 CopyOnWriteArrayList 不适合内存敏感以及对实时性要求很高的场景。

LinkedList

关键词

  • 双向链表
  • 默认大小为 10
  • 带 Head 和 Tail 指针
  • Node 存储节点信息

概览

Java容器（List、Set、Map）知识点快速复习手册（上）

基于双向链表实现，内部使用 Node 来存储链表节点信息。

private static class Node<E> {
   E item;
   Node<E> next;
   Node<E> prev;
}

每一个链表存储了 Head 和 Tail 指针：

transient Node<E> first;
transient Node<E> last;

Java容器（List、Set、Map）知识点快速复习手册（上）

ArrayList 与 LinkedList 比较

  • ArrayList 基于动态数组实现，LinkedList 基于双向链表实现；
  • ArrayList 支持随机访问，LinkedList 不支持；
  • LinkedList 在任意位置添加删除元素更快。

删除元素：remove

Java容器（List、Set、Map）知识点快速复习手册（上）

获取元素：get

  • 下标小于长度的一半，从头遍历
  • 反之，从尾部遍历

替换元素：set

set方法和get方法其实差很少，根据下标来判断是从头遍历仍是从尾遍历

其余方法

LinkedList实现了Deque接口，所以，咱们能够操做LinkedList像操做队列和栈同样

LinkedList的方法比ArrayList的方法多太多了，这里我就不一一说明了。具体可参考：

参考

  • https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Java%20%E5%AE%B9%E5%99%A8.md
  • Eckel B. Java 编程思想 [M]. 机械工业出版社, 2002.
  • Java Collection Framework
  • Iterator 模式
  • Java 8 系列之从新认识 HashMap
  • What is difference between HashMap and Hashtable in Java?
  • Java 集合之 HashMap
  • The principle of ConcurrentHashMap analysis
  • 探索 ConcurrentHashMap 高并发性的实现机制
  • HashMap 相关面试题及其解答
  • Java 集合细节（二）：asList 的缺陷
  • Java Collection Framework – The LinkedList Class

关注我

本人目前为后台开发工程师，主要关注Python爬虫，后台开发等相关技术。

原创博客主要内容：

  • 笔试面试复习知识点手册
  • Leetcode算法题解析（前150题）
  • 剑指offer算法题解析
  • Python爬虫相关实战
  • 后台开发相关实战

同步更新如下几大博客：

  • Csdn：

http://blog.csdn.net/qqxx6661

拥有专栏：Leetcode题解（Java/Python）、Python爬虫开发

  • 知乎：

https://www.zhihu.com/people/yang-zhen-dong-1/

拥有专栏：码农面试助攻手册

  • 掘金：

https://juejin.im/user/5b48015ce51d45191462ba55

  • 简书：

https://www.jianshu.com/u/b5f225ca2376

  • 我的公众号：Rude3Knife

Java容器（List、Set、Map）知识点快速复习手册（上）

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程