Java核心知识体系6：集合框架详解

Java核心知识体系1：泛型机制详解
Java核心知识体系2：注解机制详解
Java核心知识体系3：异常机制详解
Java核心知识体系4：AOP原理和切面应用
Java核心知识体系5：反射机制详解

1 集合框架图总览

image
我们来简单解读下上面这个框架图：

  • 所有集合类都位于java.util包下
  • Iterator是遍历集合的工具，我们经常通过Iterator迭代器来遍历集合。我们说Collection依赖于Iterator，是因为Collection的实现类都要实现iterator()函数，返回一个Iterator对象。ListIterator主要作用就是遍历List。
  • Java的集合类主要由两个接口派生而出：Collection和Map，作为Java集合框架的根接口，这两个接口包含了一些子接口和实现类。
  • 集合接口：即图中的 LinkIterator、List、Set、Queue、SortedMap、SortedMap 6个接口（即短虚线框部分），表示不同集合类型，是集合框架的基础。
  • 抽象类：即图中的 AbstractCollection、AbstractList、AbstractSet、AbstractMap、AbstractSequentialList 5个抽象类（长虚线框部分），抽象类只是对集合接口的部分实现，有需要的话可以继续扩展，完善自定义集合类。
  • 实现类：即图片中LinkHashMap、TreeMap等8个实现类（实线框部分），主要是对接口的具体实现。
  • Collection 接口包含一组允许重复的对象
  • Set 接口继承 Collection，但是集合内的元素不重复。Set的实现类有HastSet和TreeSet。HashSet依赖于HashMap，它实际上是通过HashMap实现的；TreeSet依赖于TreeMap，它实际上是通过TreeMap实现的。
  • List 接口继承 Collection，集合内元素允许重复，但维护了元素的插入顺序，所以是个有序队列。每一个元素都有它的索引。第一个元素的索引值是0。List的实现类有LinkedList, ArrayList, Vector, Stack。
  • Map接口是键－值对象顶层接口，下面还包含了一些子接口和实现类。AbstractMap是个抽象类，它实现了Map接口中的大部分API。而HashMap，TreeMap，WeakHashMap都是继承于AbstractMap。Hashtable虽然继承于Dictionary，但它实现了Map接口。
  • Set、List和Map是集合的三大类：
    • List：有序集合，集合中元素可重复，访问元素可以根据元素索引访问。
    • Set：无序集合，集合中元素不可以重复，访问集合中的元素只能根据元素自身信息来访问（因此元素不允许重复）。
    • Map：Key-value模式的键值对元素，访问时根据元素key来读取对应的value。
  • Arrays和Collections是操作数组、集合的两个工具类。

完成对上面框架的整体介绍之后，我们接着对每个类别进行详细的分析。

2 Collection接口

Collection接口是处理对象集合的根接口，其中定义了很多对元素进行操作的方法。Collection接口有两个主要的子接口List和Set，注意Map不是Collection的子接口，这个要牢记。
Collection接口中的方法如下:
image
其中，有几个比较常用的方法，比如方法add()添加一个元素到集合中，addAll()将指定集合中的所有元素添加到集合中，contains()方法检测集合中是否包含指定的元素，toArray()方法返回一个表示集合的数组。

另外，Collection中有一个iterator()函数，它的作用是返回一个Iterator接口。通常，我们通过Iterator迭代器来遍历集合。ListIterator是List接口所特有的，在List接口中，通过ListIterator()返回一个ListIterator对象。

Collection接口有两个常用的子接口，下面会详细介绍。

2.1 List接口

List集合代表一个有序集合，集合中每个元素都有其对应的顺序索引。List集合允许使用重复元素，可以通过索引来访问指定位置的集合元素。

List接口继承于Collection接口，它可以定义一个允许重复的有序集合。因为List中的元素是有序的，所以我们可以通过使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。

List接口为Collection直接接口。List所代表的是有序的Collection，即它用某种特定的插入顺序来维护元素顺序。用户可以对列表中每个元素的插入位置进行精确地控制，同时可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。实现List接口的集合主要有：ArrayList、LinkedList、Vector、Stack。

2.1.1 ArrayList

ArrayList是一个动态数组，也是我们最常用的集合。它允许任何符合规则的元素插入甚至包括null。每一个ArrayList都有一个初始容量（10），该容量代表了数组的大小。随着容器中的元素不断增加，容器的大小也会随着增加。在每次向容器中增加元素的同时都会进行容量检查，当快溢出时，就会进行扩容操作。所以如果我们明确所插入元素的多少，最好指定一个初始容量值，避免过多的进行扩容操作而浪费时间、效率。

size、isEmpty、get、set、iterator 和 listIterator 操作都以固定时间运行。add 操作以分摊的固定时间运行，也就是说，添加 n 个元素需要 O(n) 时间（由于要考虑到扩容，所以这不只是添加元素会带来分摊固定时间开销那样简单）。

ArrayList擅长于随机访问。同时ArrayList是非同步的。

2.1.2 LinkedList

同样实现List接口的LinkedList与ArrayList不同，ArrayList是一个动态数组，而LinkedList是一个双向链表。所以它除了有ArrayList的基本操作方法外还额外提供了get，remove，insert方法在LinkedList的首部或尾部。

由于实现的方式不同，LinkedList不能随机访问，它所有的操作都是要按照双重链表的需要执行。在列表中索引的操作将从开头或结尾遍历列表（从靠近指定索引的一端）。这样做的好处就是可以通过较低的代价在List中进行插入和删除操作。

与ArrayList一样，LinkedList也是非同步的。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：
List list = Collections.synchronizedList(new LinkedList(...));

2.1.3 Vector

与ArrayList相似，但是Vector是同步的。所以说Vector是线程安全的动态数组。它的操作与ArrayList几乎一样。
的

2.1.4 Stack

Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop 方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。
image

2.2 Set接口

Set是一种不包括重复元素的Collection。它维持它自己的内部排序，所以随机访问没有任何意义。与List一样，它同样允许null的存在但是仅有一个。由于Set接口的特殊性，所有传入Set集合中的元素都必须不同，同时要注意任何可变对象，如果在对集合中元素进行操作时，导致element1.equals(element2)为true，则必定会产生数据冲突的问题。Set接口有三个具体实现类，分别是

  • 散列集HashSet
  • 链式散列集LinkedHashSet
  • 树形集TreeSet

Set是一种不包含重复的元素的Collection，无序，即任意的两个元素element1和element2都有element1.equals(element2)为false，Set最多可以有一个null元素。需要注意的是，虽然Set中元素没有顺序性，但是元素在set中的位置是由该元素的HashCode决定的，所以具体的位置其实是固定的。

此外需要说明一点，在set接口中的不重复是有特殊要求的。
举一个例子:对象A和对象B，本来是不同的两个对象，正常情况下它们是能够放入到Set里面的，但是如果对象A和B的都重写了hashcode和equals方法，并且重写后的hashcode和equals方法是相同的话。那么A和B是不能同时放入到Set集合中去的，也就是Set集合中的去重和hashcode与equals方法直接相关。

为了更好地理解，请看下面的例子：

 private static void setWork() {
        Set<String> set = new HashSet<>();
        set.add("Brand1");
        set.add("Brand2");
        set.add("Brand1");
        System.out.println("Set Size:" + set.size());
        System.out.println("Set Elements:" + set.toString());
		
		//再次添加一个字符串对象 Brand2，然后通过equals方法比较，发现是相等的，所以添加失败返回false
        boolean result = set.add(new String("Brand2"));
        System.out.println(result);
        System.out.println(set);
    }

执行结果：
Set Size:2
Set Elements:[Brand1, Brand2]
false
[Brand1, Brand2]
可以看出，因为有hashcode和equals方法，用来比较指向的字符串对象所存储的字符串是否相等，所以第二个Brand1加进去是无效的。
程序通过new关键字来创建新的字符串对象Brand2，使用==运算符判断返回false，使用equals方法比较返回true，所以同样不能添加到Set集合中，最终还是两个元素。

2.2.1 HashSet

HashSet 是一个没有重复元素的集合。它是由HashMap实现的，不保证元素的顺序(这里所说的没有顺序是指：元素插入的顺序与输出的顺序不一致)，而且HashSet允许使用null 元素。HashSet是非同步的，如果多个线程同时访问一个哈希set，而其中至少一个线程修改了该set，那么它必须保持外部同步。 HashSet按Hash算法来存储集合的元素，因此具有很好的存取和查找性能。
HashSet的实现方式大致如下，通过一个HashMap存储元素，元素是存放在HashMap的Key中，而Value统一使用一个Object对象。
HashSet使用和理解中容易出现的误区:

  • HashSet中存放null值
    HashSet中是允许存入null值的，但是在HashSet中仅仅能够存入一个null值。
  • HashSet中存储元素的位置是固定的
    HashSet中存储的元素的是无序的，这个没什么好说的，但是由于HashSet底层是基于Hash算法实现的，使用了hashcode，所以HashSet中相应的元素的位置是固定的。
  • 必须小心操作可变对象（Mutable Object）。
    如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。

2.2.2 LinkedHashSet

LinkedHashSet继承自HashSet，其底层是基于LinkedHashMap来实现的，有序，非同步。LinkedHashSet集合同样是根据元素的hashCode值来决定元素的存储位置，但是它同时使用链表维护元素的次序。这样使得元素看起来像是以插入顺序保存的，也就是说，当遍历该集合时候，LinkedHashSet将会以元素的添加顺序访问集合的元素。

2.2.3 TreeSet

TreeSet是一个有序集合，其底层是基于TreeMap实现的，非线程安全。TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式，自然排序和定制排序，其中自然排序为默认的排序方式。当我们构造TreeSet时，若使用不带参数的构造函数，则TreeSet的使用自然比较器；若用户需要使用自定义的比较器，则需要使用带比较器的参数。
注意：TreeSet集合不是通过hashcode和equals函数来比较元素的.它是通过compare或者comparaeTo函数来判断元素是否相等.compare函数通过判断两个对象的id，相同的id判断为重复元素，不会被加入到集合中。

3 Map接口

Map与List、Set接口不同，它是由一系列键值对组成的集合，提供了key到Value的映射。同时它也没有继承Collection。在Map中它保证了key与value之间的一一对应关系。也就是说一个key对应一个value，所以它不能存在相同的key值，当然value值可以相同。

3.1 HashMap

以哈希表数据结构实现，查找对象时通过哈希函数计算其位置，它是为快速查询而设计的，其内部定义了一个hash表数组（Entry[] table），元素会通过哈希转换函数将元素的哈希地址转换成数组中存放的索引，如果有冲突，则使用散列链表的形式将所有相同哈希地址的元素串起来，可能通过查看HashMap.Entry的源码它是一个单链表结构。

3.2 LinkedHashMap

LinkedHashMap是HashMap的一个子类，它保留插入的顺序，如果需要输出的顺序和输入时的相同，那么就选用LinkedHashMap。
LinkedHashMap是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
LinkedHashMap实现与HashMap的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序可以是插入顺序或者是访问顺序。
根据链表中元素的顺序可以分为：按插入顺序的链表，和按访问顺序(调用get方法)的链表。默认是按插入顺序排序，如果指定按访问顺序排序，那么调用get方法后，会将这次访问的元素移至链表尾部，不断访问可以形成按访问顺序排序的链表。
注意，此实现不是同步的。如果多个线程同时访问链接的哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须保持外部同步。
由于LinkedHashMap需要维护元素的插入顺序，因此性能略低于HashMap的性能，但在迭代访问Map里的全部元素时将有很好的性能，因为它以链表来维护内部顺序。

3.3 TreeMap

TreeMap 是一个有序的key-value集合，非同步，基于红黑树（Red-Black tree）实现，每一个key-value节点作为红黑树的一个节点。TreeMap存储时会进行排序的，会根据key来对key-value键值对进行排序，其中排序方式也是分为两种，一种是自然排序，一种是定制排序，具体取决于使用的构造方法。
自然排序：TreeMap中所有的key必须实现Comparable接口，并且所有的key都应该是同一个类的对象，否则会报ClassCastException异常。
定制排序：定义TreeMap时，创建一个comparator对象，该对象对所有的treeMap中所有的key值进行排序，采用定制排序的时候不需要TreeMap中所有的key必须实现Comparable接口。
TreeMap判断两个元素相等的标准：两个key通过compareTo()方法返回0，则认为这两个key相等。
如果使用自定义的类来作为TreeMap中的key值，且想让TreeMap能够良好的工作，则必须重写自定义类中的equals()方法，TreeMap中判断相等的标准是：两个key通过equals()方法返回为true，并且通过compareTo()方法比较应该返回为0。
image

4 Iterator 与 ListIterator详解

4.1 Iterator

Iterator的定义如下：

public interface Iterator<E> {}

Java的Iterator（迭代器）是一个设计模式，它使你可以遍历一个容器（如列表，集合，队列等）。它提供了一种方法来顺序访问聚合对象的元素，而不需要暴露该对象的内部表示。
Iterator提供的API接口如下：

  • boolean hasNext()：判断集合里是否存在下一个元素。如果有，hasNext()方法返回 true。
  • Object next()：返回集合里下一个元素。
  • void remove()：删除集合里上一次next方法返回的元素。
    参考如下：
import java.util.*;  
  
public class Main {  
  public static void main(String[] args) {  
     // 创建一个ArrayList对象
        List<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("World");
        list.add("Java");

        // 获取该ArrayList的迭代器
        Iterator<String> it = list.iterator();

        // 使用迭代器遍历列表中的元素
        while(it.hasNext()) {
            String element = it.next();
            System.out.println(element);
            if ("Java".equals(element)) {
                it.remove();
            }
        }
        // 移除之后的ArrayList对象
        System.out.println("after remove element 「java」: " + list);
  }  
}

输出结果如下：

Hello
World
Java
remove java element : [Hello, World]

需要注意的点如下：

  • Iterator只能单向移动。
  • Iterator.remove()是唯一安全在迭代过程中修改集合；如果在迭代过程中以任何其它的方式修改了基本集合将会产生未知的行为。而且每调用一次next()方法，remove()方法只能被调用一次，如果违反这个规则将抛出一个异常，因为可能导致数据异常。

4.2 ListIterator

ListIterator是一个功能更加强大的迭代器, 它继承于Iterator接口,只能用于各种List类型的访问。它提供了在列表中插入和删除元素的方法，以及使用hasPrevious()和previous()方法在迭代过程中向前和向后遍历列表的功能。
以下是ListIterator的主要方法：

  • boolean hasNext(): 返回true如果迭代器有下一个元素。
  • Object next(): 返回迭代器的下一个元素并将指针移到下一个元素。
  • boolean hasPrevious(): 返回true如果迭代器有前一个元素。
  • Object previous(): 返回迭代器的前一个元素并将指针移到前一个元素。
  • int nextIndex(): 返回迭代器下一次要访问的元素的索引。
  • int previousIndex(): 返回迭代器上一次访问的元素的索引。
  • void remove(): 从列表中删除迭代器最后一次返回的元素。
  • void add(Object o): 在迭代器指向的位置插入指定的元素。
  • void set(E e): 从列表中替换迭代器最后一次返回的元素。
public interface ListIterator<E> extends Iterator<E> {
    boolean hasNext(); 
    E next(); 
    boolean hasPrevious(); 
    E previous(); 
    int nextIndex(); 
    int previousIndex(); 
    void remove(); 
    void set(E e); 
    void add(E e);
}

由以上定义我们可以推出ListIterator可以:

  • 双向移动（向前或者向后遍历）
  • 产生相对于迭代器在列表中指向的当前位置的前一个和后一个元素的索引
  • 可以使用set()方法替换它访问过的最后一个元素
  • 可以使用add()方法在next()方法返回的元素之前或previous()方法返回的元素之后插入一个元素

使用示例：

    public static void listIteratorWork() {
        // 创建一个 ArrayList
        List<String> list = new ArrayList<>();
        list.add("Element A");
        list.add("Element B");
        list.add("Element C");

        System.out.println("当前列表 : " + list);

        // 获取 ListIterator 对象
        ListIterator<String> listIterator = list.listIterator();
        // 使用 hasNext() 和 next() 方法迭代列表
        System.out.println("逐一遍历 : ");
        while (listIterator.hasNext()) {
            System.out.println(listIterator.next() + ", " + listIterator.previousIndex() + ", " + listIterator.nextIndex());
        }

        // 在迭代过程中使用 add() 方法添加元素
        listIterator.add("Element D");
        System.out.println("添加一个元素之后:" + list);


        // 在迭代过程中使用 set() 方法进行元素修改
        listIterator = list.listIterator(1);
        System.out.print("修改一个元素之后:");
        while (listIterator.hasNext()) {
            if ("Element D".equals(listIterator.next())) {
                listIterator.set("Element replace");
            }           
        }
        System.out.println(list);        
    }

输出结果如下：

当前列表 : [Element A, Element B, Element C]
逐一遍历 : 
Element A, 0, 1
Element B, 1, 2
Element C, 2, 3
添加一个元素之后:[Element A, Element B, Element C, Element D]
修改一个元素之后:[Element A, Element B, Element C, Element replace]

5 面试考点分析

5.1 ArrayList和LinkedList对比

  • ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
  • 两者都是线程不安全，都实现了Collection接口。
  • 数据结构：ArrayList是基于动态数组的数据结构，LinkedList是基于双向链表的数据结构。
  • 性能：ArrayList支持随机访问，查询快，增删慢，查询的时间复杂度为O(1)，插入和删除的时间复杂度为O(n)，因为对插入和删除位置后面的元素进行移动位置，以保证内存的连续性，所以
    • 对于随机访问get和set，ArrayList绝对优于LinkedList，因为LinkedList要移动指针。
    • 对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。
  • 内存空间占用： ArrayList的空 间浪费主要体现在在list列表的结尾会预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗 比ArrayList更多的空间（因为要存放直接后继和直接前驱以及数据）。

5.2 HashTable与HashMap对比

  • 相同点：
    • 都实现了Map、Cloneable、java.io.Serializable接口。
    • 都是存储"键值对(key-value)"的散列表，而且都是采用拉链法实现的。
  • 不同点：
    • 是否安全：HashMap是非线程安全的，HashTable 是线程安全的；HashTable 内部的方法基本都经过 synchronized 修饰。（如果你要保证线程安全的话就使用 ConcurrentHashMap ）
    • 同步性：HashTable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的 。
    • 对null值的处理：HashMap的key、value都可为null，HashTable的key、value都不可为null 。
    • 基类不同：HashMap继承于AbstractMap，而Hashtable继承于Dictionary。
    • 支持的遍历种类不同：HashMap只支持Iterator(迭代器)遍历。而Hashtable支持Iterator(迭代器)和Enumeration(枚举器)两种方式遍历。
    • 操作效率：因为线程安全的问题，HashMap 要比 HashTable 效率高一点。另外，HashTable 基本被淘汰，不要在代码中使用它；
    • 对Null key 和Null value的支持： HashMap 中，null 可以作为键，这样的键只有一个，可以有一个或多个键所对应的值为 null。但是在 HashTable 中 put 进的键值只要有一个 null，直接抛出 NullPointerException
    • 初始容量大小和每次扩充容量大小的不同 ：
      • 创建时如果不指定容量初始值，Hashtable 默认的初始大小为11，之后每次扩充，容量变为原来的2n+1。HashMap 默认的初始化大小为16。之后每次扩充，容量变为原来的2倍。
      • 创建时如果给定了容量初始值，那么 Hashtable 会直接使用你给定的大小，而 HashMap 会将其扩充为2的幂次方大小。也就是说 HashMap 总是使用2的幂作为哈希表的大小,后面会介绍到为什么是2的幂次方。
    • 底层数据结构： JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。Hashtable 没有这样的机制。

5.3 LinkedHashMap和TreeMap比较

LinkedHashMap保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的，也可以在构造时用带参数，按照应用次数排序。在遍历的时候会比HashMap慢。

TreeMap实现SortMap接口，内部实现是红黑树。能够把它保存的记录根据键排序，默认是按键值的升序排序，也可以指定排序的比较器，当用Iterator 遍历TreeMap时，得到的记录是排过序的。TreeMap不允许key的值为null。非同步的。

5.4 HashSet、LinkedHashSet、TreeSet比较

5.4.1 Set接口

Set不允许包含相同的元素，如果试图把两个相同元素加入同一个集合中，add方法返回false。
Set判断两个对象相同不是使用==运算符，而是根据equals方法。也就是说，只要两个对象用equals方法比较返回true，Set就不会接受这两个对象。

5.4.2 HashSet

HashSet有以下特点：

  • 不能保证元素的排列顺序，顺序有可能发生变化。
  • 不是同步的。
  • 集合元素可以是null，但只能放入一个null。
    HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等，并且两个对象的hashCode()方法返回值也相等。

5.4.3 LinkedHashSet

LinkedHashSet集合同样是根据元素的hashCode值来决定元素的存储位置，但是它同时使用链表维护元素的次序。这样使得元素看起来像是以插入顺序保存的，也就是说，当遍历该集合时候，LinkedHashSet将会以元素的添加顺序访问集合的元素。
LinkedHashSet在迭代访问Set中的全部元素时，性能比HashSet好，但是插入时性能稍微逊色于HashSet。

5.4.4 TreeSet类

TreeSet是SortedSet接口的唯一实现类，TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式，自然排序和定制排序，其中自然排序为默认的排序方式。向TreeSet中加入的应该是同一个类的对象。
TreeSet判断两个对象不相等的方式是两个对象通过equals方法返回false，或者通过CompareTo方法比较没有返回0。

5.5 Iterator和ListIterator区别

  • ListIterator有add()方法，可以向List中添加对象，而Iterator不能
  • ListIterator和Iterator都有hasNext()和next()方法，可以实现顺序向后遍历，但是ListIterator有hasPrevious()和previous()方法，可以实现逆向（顺序向前）遍历。Iterator就不可以。
  • ListIterator可以定位当前的索引位置，nextIndex()和previousIndex()可以实现。Iterator没有此功能。
  • 都可实现删除对象，但是ListIterator可以实现对象的修改，set()方法可以实现。Iierator仅能遍历，不能修改。
    因为ListIterator的这些功能，可以方便的实现对LinkedList等List数据结构的操作。其实，数组对象也可以用迭代器来实现。

5.6 Collection 和 Collections区别

Java中的Collection和Collections都是用于处理集合的类，但它们有一些重要的区别。

继承关系：Collection是所有集合类的根接口，它定义了集合的基本操作，比如添加元素、删除元素等。Collections是一个帮助类，它提供了静态方法来操作和操作集合，比如排序、查找等。Collections类通过实现和实例化集合类的各种基本操作，让集合类的操作更加简单。
用法：Collection通常用于定义集合类的基本操作，而Collections则提供了各种静态方法来操作和操作集合。Collections类中包含了很多有用的静态方法，比如排序、查找、复制等。

posted @ 2023-11-13 14:38  Hello-Brand  阅读(843)  评论(0)  编辑  收藏  举报