第6章 - Java 集合

第6章 - Java 集合

作者：vwFisher
时间：2019-09-04
GitHub代码：https://github.com/vwFisher/JavaBasicGuide

目录

---

• 1 Java集合类(集合框架)
  • 1.1 集合类概述
  • 1.2 Iterable、Iterator、ListIterator
    • 1.2.1 Iterable
    • 1.2.2 Iterator - 迭代器
    • 1.2.3 ListIterator
  • 1.3 Collection - 单列集合
    • 1.3.1 List - 列表
      • 1.3.1.1 ArrayList类
      • 1.3.1.2 LinkedList类
      • 1.3.1.2 Vector类
      • 1.3.1.4 ArrayList和LinkedList的区别
      • 1.3.1.5 RandomAccess接口
    • 1.3.2 Set接口的常用方法
      • 1.3.2.1 HashSet类
      • 1.3.2.2 LinkedHashSet类(HashSet的子类)
      • 1.3.2.3 TreeSet类
    • 1.3.3 Collection泛型
      • 1.3.3.4 使用Collection技巧
  • 1.4 Map - 双列集合
    • 1.4.1 Map接口的实现类
      • 1.4.1.1 HashMap类
      • 1.4.1.2 TreeMap类
      • 1.4.1.3 Hashtable类
      • 1.4.1.4 Properties(Hashtable子类)
      • 1.4.1.5 LinkedHashMap(HashMap子类)
    • 1.4.2 遍历Map数据总结
  • 1.3 Collections(集合框架工具类)

---

1 Java集合类(集合框架)

1.1 集合类概述

对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定。就使用集合容器进行存储。Java语言的java.util包中提供了一些集合类，这些集合类又被称为容器(数组也是个容器)

集合类特点：主要是用来存储对象容器，长度是可变的，不可以存储基本数据类型值

与数组对比：集合长度可变，用来存放对象。而数组长度固定，用来存放基本类型的数据

常见的集合有List集合、Set集合、 Map集合、其中List与Set实现了Collection接口，来看看类结构图

集合结构图.png

如图所示:

一、集合接口: 8个接口(短虚线表示), 表示不同集合类型, 是集合框架的基础

Iterator, ListIterator,
Collection, List, Set, Map
SortedSet, SortedMap

二、抽象类: 5个抽象类(长虚线表示), 对集合接口的部分实现, 可扩展为自定义集合类

AbstractCollection, AbstractList, AbstractSet, 
AbstractMap、AbstractSequentialList

三、实现类: 13个实现类(实线表示), 对接口的具体实现

Vector, Stack, ArrayList, LinkedList
HashSet, TreeSet, LinkedHashSet
HashMap, LinkedHashMap, TreeMap, Hashtable, Properties
WeakHashMap, IdentityHashMap

四、接口详解

1. Collection接口 是一组允许重复的对象
2. Set接口 继承 Collection。但不允许重复。使用自己内部的一个排列机制
3. List接口 继承 Collection。允许重复，以元素插人的次序来放置元素，不会重新排列
4. Map接口 是一组成对的键－值对象。即所持有的是 key-value (键值对)。Map中不能有重复的key。拥有自己的内部排列机制

五、关于null对象

1. 可以包括null：ArrayList、LinkedList、Verctor、HashSet、LinkedHashSet、HashMap、LinkedHashMap

2. 不可以包括null：TreeSet、TreeMap、Hashtable(键和值)

六、集合的特点对比

1.接口对比

• Set子接口：无序，不允许重复。检索元素效率低, 删除和插入效率高, 插入和删除不会引起元素位置改变. <对应类有 HashSet, TreeSet>
• List子接口：有序，可以有重复元素。和数组类似, List可以动态增长, 查找元素效率高, 插入删除元素效率低, 因为会引起其他元素位置改变. <相应类有 ArrayList, LinkedList, Vector>

2.实例比较

• HashSet: 以哈希表的形式存放元素, 插入删除速度很快.
• TreeSet: 以二叉树的形式存放元素
• ArrayList: 动态数组
• LinkedList: 链表、队列、堆栈
• Vector是一种老的动态数组：是线程同步的, 效率很低, 一般不赞成使用

七、Java容器的线程安全与非线程安全?

1.谈谈哪些是线程安全的容器, 哪些非线程安全的容器.

• 线程安全：Vector、HashTable、StringBuffer
• 非线程安全：ArrayList、LinkedList、HashMap、TreeMap、StringBuilder

2.线程安全有什么好处, 有什么坏处

线程安全即在多线程操作同一个 Vector 或 HashTable 对象时不会有任何问题. 但是线程安全必须要使用很多 synchronized 关键字来同步控制, 所以必然会导致性能的降低. Java后续版本出才出现了众多非线程安全的容器

3.安全与性能如何取舍.

如果是多个线程操作同一个对象, 那么使用线程安全的Vector; 否则, 就使用效率更高的ArrayList

4.补充说明, 非线程安全 != 不安全.

有人在使用过程中有一个不正确的观点: 我的程序是多线程的, 不能使用ArrayList要使用Vector, 这样才安全. 非线程安全并不是多线程环境下就不能使用. 注意我上面有说到: 多线程操作同一个对象. 注意是同一个对象. 如果是每个线程中new一个ArrayList, 而这个ArrayList只在这一个线程中使用, 那么肯定是没问题的

1.2 Iterable、Iterator、ListIterator

1.2.1 Iterable

一个集合对象要表明自己支持迭代，能有使用foreach语句的特权，就必须实现Iterable接口，表明是可迭代的！然而实现Iterable接口，就必需为foreach语句提供一个迭代器。来看看接口定义内容

public interface Iterable {
    Iterator iterator(); // 返回迭代器Iterator
    default void forEach(Consumer action) { // 提供forEach语法糖
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }
    default Spliterator spliterator() { // 创建并返回一个可分割迭代器
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

1.2.2 Iterator - 迭代器

Iterator就是迭代器，规定迭代接口定义。

public interface Iterator {
    boolean hasNext(); // 如果仍有元素可以迭代, 则返回true
    E next(); // 返回迭代的下一个元素
    // 从迭代器指向的collection中移除迭代器返回的最后一个元素(可选操作)，由子类定义，默认不支持
    default void remove() { 
        throw new UnsupportedOperationException("remove");
    }
    default void forEachRemaining(Consumer action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

1.2.3 ListIterator

ListIterator也是接口，是对Iterator的接口定义的扩展

public interface ListIterator extends Iterator {
    boolean hasNext();
    E next();
    boolean hasPrevious();
    E previous();
    int previousIndex();
    void remove();
    void set(E e);
    void add(E e);
}

1.3 Collection - 单列集合

Collection(单列集合)：一次添加一个元素。它是一个接口，定义了单列集合接口约束。是单列集合的顶层定义，List与Set接口都实现Collection，接口定义如下：

Collection实现Iterable接口，即包含提供迭代器方法，也包括forEach语法糖遍历方法。

添加：
    boolean add(E e); // 添加一个元素
    boolean addAll(Collection c); // 添加元素集合
删除：
    boolean remove(Object o);  // 删除一个元素
    boolean removeAll(Collection c);  // 删除元素集合
    void clear(); // 清空
判断：
    boolean contains(Object o);  // 判断是否包含一个元素
    boolean containsAll(Collection c);  // 判断是否包含元素集合
    boolean isEmpty(); // 判断集合是否有元素
    boolean equals(Object o); // 判断与指定对象，比较方式由子类实现，一般与haseCode函数相关
获取
    int hashCode(); // 获取该集合对象的hashCode
    int size(); // 获取该集合元素的大小(数量)
    Iterator iterator(); // 获取迭代器对象
    boolean retainAll(Collection c); // 与元素集合C，取交集
转化数组：
    Object[] toArray(); // 将集合转成Object数组
     T[] toArray(T[] a); // 将集合转成自定义对象数组
default方法：
    default boolean removeIf(Predicate filter) {
        Objects.requireNonNull(filter);
        boolean removed = false;
        final Iterator each = iterator();
        while (each.hasNext()) {
            if (filter.test(each.next())) {
                each.remove();
                removed = true;
            }
        }
        return removed;
    }
    @Override
    default Spliterator spliterator() { // 创建并返回一个可分割迭代器
        return Spliterators.spliterator(this, 0);
    }
    default Stream stream() { // 转化成Stream对象
        return StreamSupport.stream(spliterator(), false);
    }
    default Stream parallelStream() { // 转化成并行Stream对象
        return StreamSupport.stream(spliterator(), true);
    }
    AbstractCollection是实现Collection的抽象类，通过结合Iterator接口约束，对一些方法的实现。

1.3.1 List - 列表

AbstractList是实现List的抽象类，通过结合ListIterator接口约束，对一些方法的实现。

List特点: 有序(存入和取出的顺序一致), 元素都有索引(角标), 元素可以重复

List:(是有序的) 
    |-- ArrayList：内部是数组数据结构, 是不同步的. 替代了Vector. 查询的速度快.
    |-- LinkedList：内部是链表数据结构, 是不同步的. 增删元素的速度很快. 
    |-- Vector：内部是数组数据结构, 是同步的. 增删, 查询都很慢

List接口继承了Collection接口，在Collection基础上，扩展定义列表的接口规范。扩展定义的方法：

    void add(int index, E element); // 在索引位置插入元素(索引从0开始)
    boolean addAll(int index, Collection c); // 在指定索引位置插入元素集合
    E set(int index, E element); // 指定元素替换列表中指定索引位置的元素, 返回被替换的元素
    E remove(int index); // 移除指定索引位置的元素, 返回被移除的元素
    E get(int index); // 用于获取指定索引位置的元素
    int indexOf(Object o); // 返回列表中对象最后一次出现的索引位置, 如果集合中不包含该元素, 则返回-1
    int lastIndexOf(Object o); // 返回列表中对象最后一次出现的索引位置, 如果集合中不包含该元素, 则返回-1 
    ListIterator listIterator(); // 用来获取一个包含所有对象的ListIterator列表迭代器
    ListIterator listIterator(int index); 
    List subList(int fromIndex, int toIndex); // 获取子集合列表，从fromIndex -> toIndex
    default void replaceAll(UnaryOperator operator) {
        Objects.requireNonNull(operator);
        final ListIterator li = this.listIterator();
        while (li.hasNext()) {
            li.set(operator.apply(li.next()));
        }
    }
    @SuppressWarnings({"unchecked", "rawtypes"})
    default void sort(Comparator c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }
    @Override
    default Spliterator spliterator() {
        return Spliterators.spliterator(this, Spliterator.ORDERED);
    }

1.3.1.1 ArrayList类

(basic.coll.collection.list.ArrayListDemo)

1. 底层数据结构：Object对象类型的数组，允许所有元素，包括null
2. 优点：可以根据索引位置对集合进行快速的随机访问
3. 缺点：向指定的索引位置插入对象或删除对象的速度较慢
4. 使用场景：读 多于 写的场景
5. 扩容机制：正常情况下会扩容1.5倍，特殊情况下(新扩展数组大小已经达到了最大值)则只取最大值。
6. 扩容时机：调用add()方法的重载时，第一步是检查容量，如果容量不够则进行扩容

类定义：

public class ArrayList extends AbstractList 
  implements List, RandomAccess, Cloneable, Serializable

继承了AbstractList、实现List接口、支持随机访问、拷贝、序列化

重要的类属性：

private static final int DEFAULT_CAPACITY = 10; // 缺省容量
private static final Object[] EMPTY_ELEMENTDATA = {}; // 空对象数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 缺省空对象数组
transient Object[] elementData; // 元素数组(trabsuebt，该变量不包括在序列化的表示中)
private int size; // 实际元素大小，默认为0
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; // 最大数组容量

构造函数：

public ArrayList(int initialCapacity)
public ArrayList()
public ArrayList(Collection c)

核心函数实现分析 add()：

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 取保数组又合适的大小
        elementData[size++] = e;
        return true;
    }
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++; // 修改次数的记录：修改加1
        // 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); // 1.5倍扩容
        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); // 拷贝扩容
    }
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

正常情况下会扩容1.5倍，特殊情况下（新扩展数组大小已经达到了最大值）则只取最大值。modCount意思是修改次数，在集合几个容器中基本上都有。

其他需要说明的，indexOf()、set()、get()、remove()函数实现，第一步一般都是检查索引是否合法。remove移除指定下标的元素，此时会把指定下标到数组末尾的元素向前移动一个单位，并且会把数组最后一个元素设置为null，这样是为了方便之后将整个数组不被使用时，会被GC

1.3.1.2 LinkedList类

(basic.coll.collection.list.LInkedListDemo)

1. 底层数据结构：采用Node对象，双向链表结构，有一个头结点和一个尾结点(JDK1.6之前为循环链表，JDK1.7取消了循环)
2. 优点：插入、删除效率比较高。
3. 缺点：对于随机访问集合中的对象, 效率较慢
4. 使用场景：写 多于 读的场景。也可以拿来实现堆栈和队列

类定义：

public class LinkedList extends AbstractSequentialList 
  implements List, Deque, Cloneable, java.io.Serializable

与ArrayList不同的，主要在于AbstractSequentialListh和Deque。Deque定义双向队列的接口方法。

类的属性

transient int size = 0; // 容量
transient Node first; // 首节点
transient Node last; // 尾节点
private static class Node { // Node节点的定义
    E item; // 当前元素
    Node next; // 前一个节点指针
    Node prev; // 后一个节点指针
}

说明：LinkedList的属性非常简单，一个头结点、一个尾结点、一个表示链表中实际元素个数的变量。都有transient关键字修饰，这也意味着在序列化时该域是不会序列化的。

构造函数：

public LinkedList()
public LinkedList(Collection c)

实现的Deque方法说明：

void addFirst(E e)  将指定元素插入此列表的开头
void addLast(E e)   将指定元素添加到此列表的结尾
boolean offer(E e)  将指定元素添加到此列表的末尾(最后一个元素)
boolean offerFirst(E e) 在此列表的开头插入指定的元素
boolean offerLast(E e)  在此列表末尾插入指定的元素
void push(E e)  将元素推入此列表所表示的堆栈
E element() 获取但不移除此列表的头(第一个元素)
E getFirst()    返回此列表的第一个元素
E getLast() 返回此列表的最后一个元素
E peek()    获取但不移除此列表的头(第一个元素)
E peekFirst()   获取但不移除此列表的第一个元素; 如果此列表为空, 则返回 null
E peekLast()    获取但不移除此列表的最后一个元素; 如果此列表为空, 则返回 null
E poll()    获取并移除此列表的头(第一个元素)
E pollFirst()   获取并移除此列表的第一个元素; 如果此列表为空, 则返回 null
E pollLast()    获取并移除此列表的最后一个元素; 如果此列表为空, 则返回 null
E pop() 从此列表所表示的堆栈处弹出一个元素
E remove()  获取并移除此列表的头(第一个元素)
E removeFirst() 移除并返回此列表的第一个元素
boolean removeFirstOccurrence(Object o) 从此列表中移除第一次出现的指定元素(从头部到尾部遍历列表时)
E removeLast()  移除并返回此列表的最后一个元素
boolean removeLastOccurrence(Object o)  从此列表中移除最后一次出现的指定元素(从头部到尾部遍历列表时)
Iterator descendingIterator()    返回以逆向顺序在此双端队列的元素上进行迭代的迭代器

核心函数实现分析 addAll()：

    public boolean addAll(Collection c) {
        return addAll(size, c);
    }
    public boolean addAll(int index, Collection c) {
        checkPositionIndex(index);
        Object[] a = c.toArray();
        int numNew = a.length;
        if (numNew == 0)
            return false;
        Node pred, succ;
        if (index == size) {
            succ = null;
            pred = last;
        } else {
            succ = node(index);
            pred = succ.prev;
        }
        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            Node newNode = new Node<>(pred, e, null);
            if (pred == null)
                first = newNode;
            else
                pred.next = newNode;
            pred = newNode;
        }
        if (succ == null) {
            last = pred;
        } else {
            pred.next = succ;
            succ.prev = pred;
        }
        size += numNew;
        modCount++;
        return true;
    }

addAll会把集合先转化为数组。考虑的是2点：

1. 传入的集合是对象(引用)，转化数组toArray，可以避免过程中，该集合对象被修改
2. 转化成数组遍历，比在集合中遍历速度要快，因为集合需要转化成迭代器来遍历

1.3.1.2 Vector类

(示例: basic.coll.collection.list.VectorDemo)

底层实现与ArrayList结构类似，操作方法大同小异，不同点在于：

1. Vector的方法都是用了synchronized，即线程安全的列表容器
2. 扩容，ArrayList是1.5倍扩容，而Vector有个属性capacityIncrement定义扩容数量，如果没有定义默就是2倍扩容

对于Vector的子类Stack，Stack栈的特点：先进后出，主要实现了一下几个方法

1.3.1.4 ArrayList和LinkedList的区别

ArrayList：通过数组来实现的，读取性能很高，随机访问时间复杂度为O(1)，适用于读大于写的场景

LinkedList：通过双向队列来实现的，更新效率更高，写只需要修改前后两个节点的相关引用，但是读取效率比较低，需要最多遍历一半长度的队列，适用与写大于读的场景

    public E push(E item) // 向栈顶(数组末端)放入元素
    public synchronized E pop() // 弹出栈顶，移除数组末端元素，并放回
    public synchronized E peek() // 获取栈顶元素(数组末端元素)返回，不会移除

1.3.1.5 RandomAccess接口

查看源码我们发现实际上 RandomAccess 接口中什么都没有定义。所以，在我看来 RandomAccess 接口不过是一个标识罢了。标识什么？ 标识实现这个接口的类具有随机访问功能。

在 binarySearch（）方法中，它要判断传入的list 是否 RamdomAccess 的实例，如果是，调用indexedBinarySearch（）方法，如果不是，那么调用iteratorBinarySearch（）方法

public static  int binarySearch(List> list, T key) {
    if (list instanceof RandomAccess || list.size()

ArrayList 实现了 RandomAccess 接口， 而 LinkedList 没有实现。为什么呢？还是和底层数据结构有关！ArrayList 底层是数组，而 LinkedList 底层是链表。数组天然支持随机访问，时间复杂度为 O(1)，所以称为快速随机访问。链表需要遍历到特定位置才能访问特定位置的元素，时间复杂度为 O(n)，所以不支持快速随机访问。，ArrayList 实现了 RandomAccess 接口，就表明了他具有快速随机访问功能。 RandomAccess 接口只是标识，并不是说 ArrayList 实现 RandomAccess 接口才具有快速随机访问功能的！

对于 list 的遍历方式选择：

1. 实现了 RandomAccess 接口的list，优先选择普通 for 循环 ，其次 foreach,
2. 未实现 RandomAccess接口的list，优先选择iterator遍历（foreach遍历底层也是通过iterator实现的,），大size的数据，千万不要使用普通for循环

1.3.2 Set接口的常用方法

Set接口继承了Collection接口，在Collection基础上，扩展定义Set的接口规范。扩展定义的方法：

    int size();
    boolean isEmpty();
    boolean contains(Object o);
    Iterator iterator();
    Object[] toArray();
     T[] toArray(T[] a);
    boolean add(E e);
    boolean remove(Object o);
    boolean containsAll(Collection c);
    boolean addAll(Collection c);
    boolean retainAll(Collection c);
    boolean removeAll(Collection c);
    void clear();
    int hashCode();
    @Override
    default Spliterator spliterator() {
        return Spliterators.spliterator(this, Spliterator.DISTINCT);
    }

AbstractSet 是实现 Set 的抽象类，通过结合 Iterator 接口约束，对一些方法的实现。

Set:元素不可以重复, 是无序
|-- HashSet：内部数据结构是哈希表 , 是不同步的. 
    |-- LinkedHashSet：
|-- TreeSet：可以对Set集合中的元素进行排序. 是不同步的.  

由于Set集合中不允许存在重复值, 因此可以使用Set集合中的addAll()方法, 将Collection集合添加到Set集合中并除掉重复值

由于Set集合中的对象时无序的, 遍历Set结合的结果与插入Set集合的顺序并不相同

一、如何保证该集合的元素唯一性呢？

是通过对象的hashCode和equals方法来完成对象唯一性的.

1. 如果对象的hashCode值不同, 那么不用判断equals方法, 就直接存储到哈希表中.
2. 如果对象的hashCode值相同, 那么要再次判断对象的equals方法是否为true. 如果为true, 视为相同元素, 不存. 如果为false, 那么视为不同元素, 就进行存储.

记住: 如果元素要存储到HashSet集合中, 必须覆盖hashCode方法和equals方法.

一般情况下, 如果定义的类会产生很多对象, 比如人, 学生, 书, 通常都需要覆盖equals, hashCode方法.

二、建立对象判断是否相同的依据

if (this.hashCode() == obj.hashCode() && this.equals(obj))

三、哈希表确定元素是否相同

1. 判断的是两个元素的哈希值是否相同。如果相同，在判断两个对象的内容是否相同。
2. 判断哈希值相同，其实判断的是对象的hashCode的方法。判断内容相同，用的是equals方法。如果哈希值不同，就不需要判断equals

四、判断元素唯一性的方式

就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。

五、TreeSet对元素进行排序的 两种方式

1. 让元素自身具备比较功能，元就需要实现Comparable接口，覆盖compareTo方法。如果不要按照对象中具备的自然顺序进行排序。如果对象中不具备自然顺序。怎么办？
2. 让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。将该类对象作为参数传递给TreeSet集合的构造函数。

1.3.2.1 HashSet类

(示例: basic.coll.collection.set.HashSetDemo)

底层数据结构：采用HashMap的键，来作为对象的存储容器，允许null。因为Map的key不能重复，所以自然Set就不允许存在重复的元素。所以存储元素的时候, 使用的元素的hashCode方法来确定位置, 如果位置相同, 在通过元素的equals来确定是否相同。

1.3.2.2 LinkedHashSet类(HashSet的子类)

(示例: basic.coll.collection.set.LinkedHashSetDemo)

底层数据结构： 与HashSet类似，除了底层数据结构是采用LinkedHashMap。所以是有序的

1.3.2.3 TreeSet类

(示例: basic.coll.collection.set.TreeSetDemo)

1. 底层实现: 红黑树(自平衡的排序二叉树)。底层基于TreeMap的NavigableSet保存数据, 其中对象作为map的key, 所以不允许存在重复的键, 所以Set不可重复. HashSet集合数据结构是哈希表, 所以存储元素的时候, 使用的元素的hashCode方法来确定位置, 如果位置相同, 在通过元素的equals来确定是否相同。允许null
2. 优点: 删除和插入效率高
3. 缺点: 检索元素效率低
4. 语法: TreeSet