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

时间  2019-11-29
标签 java 容器 list set map 知识 快速 复习 手册 栏目 Java 繁體版
原文   原文链接

前言

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

其它知识点复习手册

概览

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

Collection

在这里插入图片描述

在这里插入图片描述

数组和集合的区别:java

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

1. Set（元素不可重复）

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

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

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

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

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

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

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

3. Queue

  • LinkedList：能够用它来支持双向队列；设计模式

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

Map

在这里插入图片描述

  • HashMap：基于哈希实现；

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

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

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

  • TreeMap：基于红黑树实现。

Fail-Fast 机制和 Fail-Safe 机制

blog.csdn.net/Kato_op/art…

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的,能够在多线程下并发使用,并发修改

容器中使用的设计模式

迭代器模式

在这里插入图片描述

  • Iterator它是在ArrayList等集合的内部类的方式实现

Collection 实现了 Iterable 接口，其中的 iterator() 方法可以产生一个 Iterator 对象，经过这个对象就能够迭代遍历 Collection 中的元素。

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

List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
for (String item : list) {
    System.out.println(item);
}
复制代码

适配器模式

适配器模式解释：www.jianshu.com/p/93821721b…

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 位置上，复制的代价很高。 -序列化：只序列化数组中有元素填充那部份内容

概览

在这里插入图片描述

实现了 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++来编写的

在这里插入图片描述

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<? extends E> c)构造一个包含指定 collection 的元素的列表，这些元素按照该collection的迭代器返回它们的顺序排列的。

序列化

补充：transient讲解

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 存储节点信息

概览

在这里插入图片描述

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

private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;
}
复制代码

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

transient Node<E> first;
transient Node<E> last;
复制代码

在这里插入图片描述

ArrayList 与 LinkedList 比较

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

删除元素：remove

在这里插入图片描述

获取元素：get

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

替换元素：set

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

其余方法

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

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

HashMap

wiki.jikexueyuan.com/project/jav…

源码分析：segmentfault.com/a/119000001…

关键词

  • 初始容量16
  • 扩容是2倍，加载因子0.75
  • 头插法
  • 0桶存放null
  • 从 JDK 1.8 开始，一个桶存储的链表长度大于 8 时会将链表转换为红黑树（前提：键值对要超过64个）
  • 自动地将传入的容量转换为2的幂次方
    • 保证运算速度：确保用位运算代替模运算来计算桶下标。hash& (length-1)运算等价于对 length 取模。
    • hash均匀分布：数据在数组上分布就比较均匀，而且可以利用所有二进制位，也就是说碰撞的概率小，
  • table数组+Entry<K,V>[]链表（散列表），红黑树
  • 扩容操做须要把键值对从新插入新的 table 中，从新计算全部key有特殊机制（JDK1.8后）

存储结构

hashMap的一个内部类Node：

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next; //链表结构，存储下一个元素
复制代码

在这里插入图片描述

Node内部包含了一个 Entry 类型的数组table，数组中的每一个位置被当成一个桶。

transient Entry[] table;
复制代码

Entry 存储着键值对。它包含了四个字段，从 next 字段咱们能够看出 Entry 是一个链表。即数组中的每一个位置被当成一个桶，一个桶存放一个链表。

HashMap 使用拉链法来解决冲突，同一个链表中存放哈希值相同的 Entry。

static class Entry<K,V> implements Map.Entry<K,V> {
    final K key;
    V value;
    Entry<K,V> next;
    int hash;

    Entry(int h, K k, V v, Entry<K,V> n) {
        value = v;
        next = n;
        key = k;
        hash = h;
    }

    public final K getKey() {
        return key;
    }

    public final V getValue() {
        return value;
    }

    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }

    public final boolean equals(Object o) {
        if (!(o instanceof Map.Entry))
            return false;
        Map.Entry e = (Map.Entry)o;
        Object k1 = getKey();
        Object k2 = e.getKey();
        if (k1 == k2 || (k1 != null && k1.equals(k2))) {
            Object v1 = getValue();
            Object v2 = e.getValue();
            if (v1 == v2 || (v1 != null && v1.equals(v2)))
                return true;
        }
        return false;
    }

    public final int hashCode() {
        return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
    }

    public final String toString() {
        return getKey() + "=" + getValue();
    }
}
复制代码

构造器

在这里插入图片描述

构造时就会调用tableSizeFor()：返回一个大于输入参数且最近的2的整数次幂。

static final int tableSizeFor(int cap) {
    int n = cap - 1;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
复制代码

拉链法

应该注意到链表的插入是以头插法方式进行的

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> 前面。

查找须要分红两步进行：

  • 计算键值对所在的桶；
  • 在链表上顺序查找，时间复杂度显然和链表的长度成正比。

put 操做

  • 当咱们 put 的时候，若是 key 存在了，那么新的 value 会代替旧的 value
  • 若是 key 存在的状况下，该方法返回的是旧的 value，
  • 若是 key 不存在，那么返回 null。
public V put(K key, V value) {
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
    // 键为 null 单独处理
    if (key == null)
        return putForNullKey(value);
    int hash = hash(key);
    // 肯定桶下标
    int i = indexFor(hash, table.length);
    // 先找出是否已经存在键为 key 的键值对，若是存在的话就更新这个键值对的值为 value
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

    modCount++;
    // 插入新键值对
    addEntry(hash, key, value, i);
    return null;
}
复制代码

HashMap 容许插入键为 null 的键值对。可是由于没法调用 null 的 hashCode() 方法，也就没法肯定该键值对的桶下标，只能经过强制指定一个桶下标来存放。HashMap 使用第 0 个桶存放键为 null 的键值对。

private V putForNullKey(V value) {
    for (Entry<K,V> e = table[0]; e != null; e = e.next) {
        if (e.key == null) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }
    modCount++;
    addEntry(0, null, value, 0);
    return null;
}
复制代码

使用链表的头插法，也就是新的键值对插在链表的头部，而不是链表的尾部。

void addEntry(int hash, K key, V value, int bucketIndex) {
    if ((size >= threshold) && (null != table[bucketIndex])) {
        resize(2 * table.length);
        hash = (null != key) ? hash(key) : 0;
        bucketIndex = indexFor(hash, table.length);
    }

    createEntry(hash, key, value, bucketIndex);
}

void createEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex];
    // 头插法，链表头部指向新的键值对
    table[bucketIndex] = new Entry<>(hash, key, value, e);
    size++;
}
复制代码
Entry(int h, K k, V v, Entry<K,V> n) {
    value = v;
    next = n;
    key = k;
    hash = h;
}
复制代码

补充：hashmap里hash方法的高位优化：

www.cnblogs.com/liujinhong/…

note.youdao.com/yws/res/187…

设计者将key的哈希值的高位也作了运算(与高16位作异或运算，使得在作&运算时，此时的低位其实是高位与低位的结合)，这就增长了随机性，减小了碰撞冲突的可能性！

为什么要这么作？

table的长度都是2的幂，所以index仅与hash值的低n位有关，hash值的高位都被与操做置为0了。

这样作很容易产生碰撞。设计者权衡了speed, utility, and quality，将高16位与低16位异或来减小这种影响。设计者考虑到如今的hashCode分布的已经很不错了，并且当发生较大碰撞时也用树形存储下降了冲突。仅仅异或一下，既减小了系统的开销，也不会形成的由于高位没有参与下标的计算(table长度比较小时)，从而引发的碰撞。

肯定桶下标

不少操做都须要先肯定一个键值对所在的桶下标。

int hash = hash(key);
int i = indexFor(hash, table.length);
复制代码

4.1 计算 hash 值

final int hash(Object k) {
    int h = hashSeed;
    if (0 != h && k instanceof String) {
        return sun.misc.Hashing.stringHash32((String) k);
    }

    h ^= k.hashCode();

    // This function ensures that hashCodes that differ only by
    // constant multiples at each bit position have a bounded
    // number of collisions (approximately 8 at default load factor).
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}
复制代码
public final int hashCode() {
    return Objects.hashCode(key) ^ Objects.hashCode(value);
}
复制代码

4.2 取模

令 x = 1<<\4，即 \x 为 2 的 4 次方，它具备如下性质：

x   : 00010000
x-1 : 00001111
复制代码

令一个数 y 与 x-1 作与运算，能够去除 y 位级表示的第 4 位以上数：

y       : 10110010
x-1     : 00001111
y&(x-1) : 00000010
复制代码

这个性质和 y 对 x 取模效果是同样的：

y   : 10110010
x   : 00010000
y%x : 00000010
复制代码

咱们知道，位运算的代价比求模运算小的多，所以在进行这种计算时用位运算的话能带来更高的性能。

肯定桶下标的最后一步是将 key 的 hash 值对桶个数取模：hash%capacity，若是能保证 capacity 为 2 的 n 次方，那么就能够将这个操做转换为位运算。

static int indexFor(int h, int length) {
    return h & (length-1);
}
复制代码

当 length 老是 2 的 n 次方时，h& (length-1)运算等价于对 length 取模，也就是 h%length，可是 & 比 % 具备更高的效率。这看上去很简单，其实比较有玄机的，咱们举个例子来讲明：

h & (table.length-1) hash table.length-1
8 & (15-1)： 0100 & 1110 = 0100
9 & (15-1)： 0101 & 1110 = 0100
8 & (16-1)： 0100 & 1111 = 0100
9 & (16-1)： 0101 & 1111 = 0101

  • 从上面的例子中能够看出：当它们和 15-1（1110）“与”的时候，8 和 9产生了相同的结果，也就是说它们会定位到数组中的同一个位置上去，这就产生了碰撞，8 和 9 会被放到数组中的同一个位置上造成链表，那么查询的时候就须要遍历这个链 表，获得8或者9，这样就下降了查询的效率。

  • 同时，咱们也能够发现，当数组长度为 15 的时候，hash 值会与 15-1（1110）进行“与”，那么最后一位永远是 0，而 0001，0011，0101，1001，1011，0111，1101 这几个位置永远都不能存放元素了，空间浪费至关大，数组可使用的位置比数组长度小了不少，这意味着进一步增长了碰撞的概率。

  • 而当数组长度为16时，即为2的n次方时，2n-1 获得的二进制数的每一个位上的值都为 1，这使得在低位上&时，获得的和原 hash 的低位相同，加之 hash(int h)方法对 key 的 hashCode 的进一步优化，加入了高位计算，就使得只有相同的 hash 值的两个值才会被放到数组中的同一个位置上造成链表。

因此说，当数组长度为 2 的 n 次幂的时候，不一样的 key 算得得 index 相同的概率较小，那么数据在数组上分布就比较均匀，也就是说碰撞的概率小

扩容-基本原理

设 HashMap 的 table 长度为 M，须要存储的键值对数量为 N，若是哈希函数知足均匀性的要求，那么每条链表的长度大约为 N/M，所以平均查找次数的复杂度为 O(N/M)。

为了让查找的成本下降，应该尽量使得 N/M 尽量小，所以须要保证 M 尽量大，也就是说 table 要尽量大。HashMap 采用动态扩容来根据当前的 N 值来调整 M 值，使得空间效率和时间效率都能获得保证。

和扩容相关的参数主要有：capacity、size、threshold 和 load_factor。

参数 含义
capacity table 的容量大小，默认为 16。须要注意的是 capacity 必须保证为 2 的 n 次方。
size 键值对数量。
threshold size 的临界值，当 size 大于等于 threshold 就必须进行扩容操做。
loadFactor 装载因子，table 可以使用的比例，threshold = capacity * loadFactor。 
static final int DEFAULT_INITIAL_CAPACITY = 16;

static final int MAXIMUM_CAPACITY = 1 << 30;

static final float DEFAULT_LOAD_FACTOR = 0.75f;

transient Entry[] table;

transient int size;

int threshold;

final float loadFactor;

transient int modCount;
复制代码

从下面的添加元素代码中能够看出，当须要扩容时，令 capacity 为原来的两倍。

void addEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex];
    table[bucketIndex] = new Entry<>(hash, key, value, e);
    if (size++ >= threshold)
        resize(2 * table.length);
}
复制代码

扩容使用 resize() 实现，须要注意的是，扩容操做一样须要把 oldTable 的全部键值对从新插入 newTable 中，所以这一步是很费时的。

void resize(int newCapacity) {
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
    if (oldCapacity == MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        return;
    }
    Entry[] newTable = new Entry[newCapacity];
    transfer(newTable);
    table = newTable;
    threshold = (int)(newCapacity * loadFactor);
}

void transfer(Entry[] newTable) {
    Entry[] src = table;
    int newCapacity = newTable.length;
    for (int j = 0; j < src.length; j++) {
        Entry<K,V> e = src[j];
        if (e != null) {
            src[j] = null;
            do {
                Entry<K,V> next = e.next;
                int i = indexFor(e.hash, newCapacity);
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            } while (e != null);
        }
    }
}
复制代码

扩容-从新计算桶下标

Rehash优化：my.oschina.net/u/3568600/b…

在进行扩容时，须要把键值对从新放到对应的桶上。HashMap 使用了一个特殊的机制，能够下降从新计算桶下标的操做。

假设原数组长度 capacity 为 16，扩容以后 new capacity 为 32：

capacity     : 00010000
new capacity : 00100000
复制代码

对于一个 Key，

  • 它的哈希值若是在第 5 位上为 0，那么取模获得的结果和以前同样；
  • 若是为 1，那么获得的结果为原来的结果 +16。

总结：

通过rehash以后，元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置

所以，咱们在扩充HashMap的时候，不须要像JDK1.7的实现那样从新计算hash，只须要看看原来的hash值新增的那个bit是1仍是0就行了，是0的话索引没变，是1的话索引变成“原索引+oldCap”，能够看看下图为16扩充为32的resize示意图：

在这里插入图片描述

计算数组容量

HashMap 构造函数容许用户传入的容量不是 2 的 n 次方，由于它能够自动地将传入的容量转换为 2 的 n 次方。

先考虑如何求一个数的掩码，对于 10010000，它的掩码为 11111111，可使用如下方法获得：

mask |= mask >> 1    11011000
mask |= mask >> 2    11111110
mask |= mask >> 4    11111111
复制代码

mask+1 是大于原始数字的最小的 2 的 n 次方。

num     10010000
mask+1 100000000
复制代码

如下是 HashMap 中计算数组容量的代码：

static final int tableSizeFor(int cap) {
    int n = cap - 1;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
复制代码

链表转红黑树

并非桶子上有8位元素的时候它就能变成红黑树，它得同时知足咱们的键值对大于64才行的

这是为了不在哈希表创建初期，多个键值对刚好被放入了同一个链表中而致使没必要要的转化。

HashTable

关键词：

  • Hashtable的迭代器不是 fail-fast，HashMap 的迭代器是 fail-fast 迭代器。
  • Hashtable 的 key 和 value 都不容许为 null，HashMap 能够插入键为 null 的 Entry。
  • HashTable 使用 synchronized 来进行同步。
  • 基于 Dictionary 类（遗留类）
  • HashMap 不能保证随着时间的推移 Map 中的元素次序是不变的。

HashMap 与 HashTable

在这里插入图片描述

  • HashTable 基于 Dictionary 类（遗留类），而 HashMap 是基于 AbstractMap。
    • Dictionary 是任何可将键映射到相应值的类的抽象父类，
    • 而AbstractMap是基于Map接口的实现，它以最大限度地减小实现此接口所需的工做。
  • HashMap 的 key 和 value 都容许为 null，而 Hashtable 的 key 和 value 都不容许为 null
  • HashMap 的迭代器是 fail-fast 迭代器，而 Hashtable 的 enumerator 迭代器不是 fail-fast 的。
  • 因为 Hashtable 是线程安全的也是 synchronized，因此在单线程环境下它比 HashMap 要慢。
  • Hashtable 中的几乎全部的 public 的方法都是synchronized的，而有些方法也是在内部经过 synchronized 代码块来实现。
    • 可是在 Collections 类中存在一个静态方法：synchronizedMap()，该方法建立了一个线程安全的 Map 对象，并把它做为一个封装的对象来返回。
    • 也可使用 ConcurrentHashMap，它是 HashTable 的替代，并且比 HashTable 可扩展性更好

ConcurrentHashMap

谈谈ConcurrentHashMap1.7和1.8的不一样实现：

www.importnew.com/23610.html

详细源码分析（还未细看）：

blog.csdn.net/yan_wenlian…

segmentfault.com/a/119000001…

主要针对jdk1.7的实现来介绍

关键词

  • key和value都不容许为null
  • Hashtable是将全部的方法进行同步，效率低下。而ConcurrentHashMap经过部分锁定+CAS算法来进行实现线程安全的
  • get方法是非阻塞，无锁的。重写Node类，经过volatile修饰next来实现每次获取都是最新设置的值
  • 在高并发环境下，统计数据(计算size...等等)实际上是无心义的，由于在下一时刻size值就变化了。
  • 实现形式不一样：
    • 1.7：Segment + HashEntry的方式进行实现
    • 1.8：与HashMap相同（散列表（数组+链表）+红黑树）采用Node数组 + CAS + Synchronized来保证并发安全进行实现

存储结构

jdk1.7

jdk1.7中采用Segment + HashEntry的方式进行实现

在这里插入图片描述

Segment：其继承于 ReentrantLock 类，从而使得 Segment 对象能够充当锁的角色。

Segment 中包含HashBucket的数组，其能够守护其包含的若干个桶。

static final class HashEntry<K,V> {
    final int hash;
    final K key;
    volatile V value;
    volatile HashEntry<K,V> next;
}
复制代码

ConcurrentHashMap采用了分段锁，每一个分段锁维护着几个桶，多个线程能够同时访问不一样分段锁上的桶，从而使其并发度更高（并发度就是 Segment 的个数）。

jdk1.8

在这里插入图片描述

  • JDK 1.7 使用分段锁机制来实现并发更新操做，核心类为 Segment，它继承自重入锁 ReentrantLock，并发程度与 Segment 数量相等。

  • JDK 1.8 使用了 CAS 操做来支持更高的并发度，在 CAS 操做失败时使用内置锁 synchronized。

  • 而且 JDK 1.8 的实现也在链表过长时会转换为红黑树。

1.8中放弃了Segment臃肿的设计，取而代之的是采用Node数组 + CAS + Synchronized来保证并发安全进行实现

添加元素：put

在这里插入图片描述

只让一个线程对散列表进行初始化！

获取元素：get

从顶部注释咱们能够读到，get方法是不用加锁的，是非阻塞的。

Node节点是重写的，设置了volatile关键字修饰，导致它每次获取的都是最新设置的值

获取大小：size

每一个 Segment 维护了一个 count 变量来统计该 Segment 中的键值对个数。

在执行 size 操做时，须要遍历全部 Segment 而后把 count 累计起来。

ConcurrentHashMap 在执行 size操做时先尝试不加锁，若是连续两次不加锁操做获得的结果一致，那么能够认为这个结果是正确的。

尝试次数使用 RETRIES_BEFORE_LOCK 定义，该值为 2，retries 初始值为 -1，所以尝试次数为 3。

若是尝试的次数超过 3 次，就须要对每一个 Segment 加锁。

删除元素：remove

在这里插入图片描述

为何用这么方式删除呢，细心的同窗会发现上面定义的HashEntry的key和next都是final类型的，因此不能改变next的指向，因此又复制了一份指向删除的结点的next。

Collections.synchronizedMap()与ConcurrentHashMap的区别

参考：blog.csdn.net/lanxiangru/…

  • Collections.synchronizedMap()和Hashtable同样，实现上在调用map全部方法时，都对整个map进行同步，而ConcurrentHashMap的实现却更加精细，它对map中的全部桶加了锁，同步操做精确控制到桶，因此，即便在遍历map时，其余线程试图对map进行数据修改，也不会抛出ConcurrentModificationException。
  • ConcurrentHashMap从类的命名就能看出，它是个HashMap。而Collections.synchronizedMap()能够接收任意Map实例，实现Map的同步。好比TreeMap。

总结

ConcurrentHashMap 的高并发性主要来自于三个方面：

  • 用分离锁实现多个线程间的更深层次的共享访问。
  • 用 HashEntery对象的不变性来下降执行读操做的线程在遍历链表期间对加锁的需求。
  • 经过对同一个 Volatile 变量的写 / 读访问，协调不一样线程间读 / 写操做的内存可见性。

LinkedHashMap

wiki.jikexueyuan.com/project/jav…

segmentfault.com/a/119000001…

关键词

  • 容许使用 null 值和 null 键
  • 此实现不是同步的（linkedlist，lilnkedhashset也不是同步的）
  • 维护着一个运行于全部条目的双向链表。定义了迭代顺序，该迭代顺序能够是插入顺序或者是访问顺序。
  • 初始容量对遍历没有影响：遍历的双向链表，而不是散列表
  • 在访问顺序的状况下，使用get方法也是结构性的修改（会致使Fail-Fast）

概论

在这里插入图片描述

在这里插入图片描述

成员变量

该 Entry 除了保存当前对象的引用外，还保存了其上一个元素 before 和下一个元素 after的引用，从而在哈希表的基础上又构成了双向连接列表。

/**
* LinkedHashMap的Entry元素。
* 继承HashMap的Entry元素，又保存了其上一个元素before和下一个元素after的引用。
 */
static class Entry<K,V> extends HashMap.Node<K,V> {
        Entry<K,V> before, after;
        Entry(int hash, K key, V value, Node<K,V> next) {
            super(hash, key, value, next);
        }
    }
复制代码

构造器

在这里插入图片描述

  • 经过源代码能够看出，在 LinkedHashMap 的构造方法中，实际调用了父类 HashMap 的相关构造方法来构造一个底层存放的 table 数组，但额外能够增长 accessOrder 这个参数，若是不设置

    • 默认为 false，表明按照插入顺序进行迭代；
    • 固然能够显式设置为 true，表明以访问顺序进行迭代。

  • 在构建新节点时，构建的是LinkedHashMap.Entry 再也不是Node.

获取元素：get

LinkedHashMap 重写了父类 HashMap 的 get 方法，实际在调用父类 getEntry() 方法取得查找的元素后，再判断当排序模式 accessOrder 为 true 时，记录访问顺序，将最新访问的元素添加到双向链表的表头，并从原来的位置删除。

因为的链表的增长、删除操做是常量级的，故并不会带来性能的损失。

遍历元素

为啥注释说：初始容量对遍历没有影响？

由于它遍历的是LinkedHashMap内部维护的一个双向链表，而不是散列表(固然了，链表双向链表的元素都来源于散列表)

LinkedHashMap应用

wiki.jikexueyuan.com/project/jav…

LRU最近最少使用（访问顺序）

用这个类有两大好处：

  • 它自己已经实现了按照访问顺序或插入顺序的存储
  • LinkedHashMap 自己有removeEldestEntry方法用于判断是否须要移除最不常读取的数，可是，原始方法默认不须要移除，咱们须要override这样一个方法。

Java里面实现LRU缓存一般有两种选择：

  • 使用LinkedHashMap
  • 本身设计数据结构，使用链表+HashMap

如下是使用 LinkedHashMap 实现的一个 LRU 缓存：

  • 设定最大缓存空间 MAX_ENTRIES 为 3；
  • 使用 LinkedHashMap 的构造函数将 accessOrder 设置为 true，开启 LRU 顺序；
  • 覆盖 removeEldestEntry() 方法实现，在节点多于 MAX_ENTRIES 就会将最近最久未使用的数据移除。
class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private static final int MAX_ENTRIES = 3;

    protected boolean removeEldestEntry(Map.Entry eldest) {
        return size() > MAX_ENTRIES;
    }

    LRUCache() {
        super(MAX_ENTRIES, 0.75f, true);
    }
}
复制代码
public static void main(String[] args) {
    LRUCache<Integer, String> cache = new LRUCache<>();
    cache.put(1, "a");
    cache.put(2, "b");
    cache.put(3, "c");
    cache.get(1);
    cache.put(4, "d");
    System.out.println(cache.keySet());
}
复制代码
[3, 1, 4]
复制代码

实现详细代码请参考文章：补充知识点-缓存

FIFO（插入顺序）

还能够在插入顺序的LinkedHashMap直接重写下removeEldestEntry方法便可轻松实现一个FIFO缓存

TreeMap

关键词

  • 红黑树
  • 非同步
  • key不能为null
  • 实现了NavigableMap接口，而NavigableMap接口继承着SortedMap接口，是有序的（HahMap是Key无序的）
  • TreeMap的基本操做 containsKey、get、put 和 remove 的时间复杂度是 log(n) 。
  • 适用于查找性能要求不那么高，反而对有序性要求比较高的应用场景
  • 使用Comparator或者Comparable来比较key是否相等与排序的问题

概览

在这里插入图片描述

获取元素：get

详细看：

segmentfault.com/a/119000001…

总结：

  • 若是在构造方法中传递了Comparator对象，那么就会以Comparator对象的方法进行比较。不然，则使用Comparable的compareTo(T o)方法来比较。
  • 值得说明的是：若是使用的是compareTo(T o)方法来比较，key必定是不能为null，而且得实现了Comparable接口的。
  • 即便是传入了Comparator对象，不用compareTo(T o)方法来比较，key也是不能为null的

删除元素：remove

删除节点而且平衡红黑树

HashSet

wiki.jikexueyuan.com/project/jav…

segmentfault.com/a/119000001…

关键词：

  • 默认容量16，扩容两倍，加载因子0.75

  • 容许元素为null

  • 实现Set接口

  • 不保证迭代顺序

  • 非同步

  • 初始容量很是影响迭代性能

  • 底层其实是一个HashMap实例

    public HashSet() {map = new HashMap<>();}

若是添加的是在 HashSet 中不存在的，则返回 true；若是添加的元素已经存在，返回 false。

对于 HashSet 中保存的对象，请注意正确重写其 equals 和 hashCode 方法，以保证放入的对象的惟一性。

HashSet 和 HashMap 的区别

重要：

1. HashMap中使用键对象来计算hashcode值

2. HashSet使用成员对象来计算hashcode值，对于两个对象来讲hashcode可能相同，因此equals()方法用来判断对象的相等性，若是两个对象不一样的话，那么返回false

在这里插入图片描述

TreeSet

关键词

  • 实现NavigableSet接口
  • 能够实现排序功能
  • 底层其实是一个TreeMap实例
  • 非同步
  • 不容许为null

LinkedHashSet

关键词

  • 迭代是有序的
  • 容许为null
  • 底层其实是一个HashMap+双向链表实例(其实就是LinkedHashMap)
  • 非同步
  • 性能比HashSet差一丢丢，由于要维护一个双向链表
  • 初始容量与迭代无关（与LinkedHashMap相同），由于LinkedHashSet迭代的是双向链表

总结Set

HashSet：

  • 无序，容许为null，底层是HashMap(散列表+红黑树)，非线程同步

TreeSet：

  • 有序，不容许为null，底层是TreeMap(红黑树),非线程同步

LinkedHashSet：

  • 迭代有序，容许为null，底层是HashMap+双向链表，非线程同步

WeekHashMap

存储结构

WeakHashMap 的 Entry 继承自 WeakReference，被 WeakReference 关联的对象在下一次垃圾回收时会被回收。

WeakHashMap 主要用来实现缓存，经过使用 WeakHashMap 来引用缓存对象，由 JVM 对这部分缓存进行回收。

private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> 复制代码

ConcurrentCache

Tomcat 中的 ConcurrentCache 使用了 WeakHashMap 来实现缓存功能。

ConcurrentCache 采起的是分代缓存：

  • 常用的对象放入 eden 中，eden 使用 ConcurrentHashMap 实现，不用担忧会被回收（伊甸园）；
  • 不经常使用的对象放入 longterm，longterm 使用 WeakHashMap 实现，这些老对象会被垃圾收集器回收。
  • 当调用 get() 方法时，会先从 eden 区获取，若是没有找到的话再到 longterm 获取，当从 longterm 获取到就把对象放入 eden 中，从而保证常常被访问的节点不容易被回收。
  • 当调用 put() 方法时，若是 eden 的大小超过了 size，那么就将 eden 中的全部对象都放入 longterm 中，利用虚拟机回收掉一部分不常用的对象。
public final class ConcurrentCache<K, V> {

    private final int size;

    private final Map<K, V> eden;

    private final Map<K, V> longterm;

    public ConcurrentCache(int size) {
        this.size = size;
        this.eden = new ConcurrentHashMap<>(size);
        this.longterm = new WeakHashMap<>(size);
    }

    public V get(K k) {
        V v = this.eden.get(k);
        if (v == null) {
            v = this.longterm.get(k);
            if (v != null)
                this.eden.put(k, v);
        }
        return v;
    }

    public void put(K k, V v) {
        if (this.eden.size() >= size) {
            this.longterm.putAll(this.eden);
            this.eden.clear();
        }
        this.eden.put(k, v);
    }
}
复制代码

常见问题总结

Enumeration和Iterator接口的区别

Iterator替代了Enumeration，Enumeration是一个旧的迭代器了。

与Enumeration相比，Iterator更加安全，由于当一个集合正在被遍历的时候，它会阻止其它线程去修改集合。

区别有三点：

  • Iterator的方法名比Enumeration更科学
  • Iterator有fail-fast机制，比Enumeration更安全
  • Iterator可以删除元素，Enumeration并不能删除元素

ListIterator有什么特色

  • ListIterator继承了Iterator接口，它用于遍历List集合的元素。
  • ListIterator能够实现双向遍历,添加元素，设置元素

在这里插入图片描述

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

若是是单列的集合，咱们考虑用Collection下的子接口ArrayList和Set。

若是是映射，咱们就考虑使用Map

  • 是否须要同步：去找线程安全的集合类使用

  • 迭代时是否须要有序(插入顺序有序)：去找Linked双向列表结构的

  • 是否须要排序(天然顺序或者手动排序)：去找Tree红黑树类型的(JDK1.8)

  • 估算存放集合的数据量有多大，不管是List仍是Map，它们实现动态增加，都是有性能消耗的。在初始集合的时候给出一个合理的容量会减小动态增加时的消耗

  • 使用泛型，避免在运行时出现ClassCastException

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

参考

关注我

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

原创博客主要内容：

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

同步更新如下几大博客：

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