Java集合框架的总结整理

源出处：尚硅谷：http://www.gulixueyuan.com/my/course/310

Java集合框架的总结整理

1. Java集合框架概述

Java集合框架概述

• 一方面， 面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象 的操作，就要对对象进行存储。另一方面，使用Array存储对象方面具有一些弊 端，而Java 集合就像一种容器，可以动态地把多个对象的引用放入容器中。
  • 数组在内存存储方面的特点：
    1. 数组初始化以后，长度就确定了。
    2. 数组声明的类型，就决定了进行元素初始化时的类型
  • 数组在存储数据方面的弊端：
    1. 数组初始化以后，长度就不可变了，不便于扩展
    2. 数组中提供的属性和方法少，不便于进行添加、删除、插入等操作，且效率不高。 同时无法直接获取存储元素的个数
    3. 数组存储的数据是有序的、可以重复的。【存储数据的特点单一】
• Java 集合类可以用于存储数量不等的多个对象，还可用于保存具有映射关系的关联数组。

Java 集合可分为 Collection 和 Map 两种体系

• Collection接口：单列数据，定义了存取一组对象的方法的集合

  • List：元素有序、可重复的集合【“动态”数组,替换原有的数组】
    • ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层数据结构是数组，使用Object[ ]存储
    • LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
    • Vector：作为List接口的古老实现类；线程安全的，效率低；底层是数组，使用Object[]存储
  • Set：元素无序、不可重复的集合

    • HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值；底层是HashMap，底层数据结构是哈希表（即数组+链表），使用hash算法计算存储位置。

    • LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历；对于频繁的遍历操作，LinkedHashSet效率高于HashSet，底层数据结构是链表和哈希表。使用hash算法计算存储位置，同时使用链表来维护顺序，顺序与添加顺序一致

    • TreeSet：可以按照添加对象的指定属性，进行排序。底层是二叉树【红黑树】

• Map接口：双列数据，保存具有映射关系“key-value对”的集合
  Map常用实现类：

  • HashMap:：HashMap是 Map 接口使用频率最高的实现类,允许使用 null 值和 null 键;此类不保证映射的顺序;在多线程操作下不安全，底层数据结构是 jdk1.7：哈希表(数组+链表)，jdk1.8：哈希表(数组+链表)+红黑树
  • LinkedHashMap：在HashMap存储结构的基础上，使用了一对双向链表来记录添加
    元素的顺序，双向链表的数据结构保证了该集合具有可预知的迭代顺序（有序性）
  • TreeMap：TreeMap存储 Key-Value 对时，需要根据 key-value 对进行排序。 TreeMap 可以保证所有的 Key-Value 对处于有序状态
  • Hashtable：Hashtable是个古老的 Map 实现类，JDK1.0就提供了。不同于HashMap， Hashtable是线程安全的。Hashtable实现原理和HashMap相同，功能相同。底层都使用哈希表结构，查询 速度快，很多情况下可以互用。
  • Properties：Properties 类是 Hashtable 的子类，该对象用于处理属性文件

Collection接口继承树：Map接口继承树：

---

Collection 接口

• Collection 接口是 List、Set 和 Queue 接口的父接口，该接口里定义的方法 既可用于操作 Set 集合，也可用于操作 List 和 Queue 集合。
• JDK不提供此接口的任何直接实现，而是提供更具体的子接口(如：Set和List)实现。
• 在 Java5 之前，Java 集合会丢失容器中所有对象的数据类型，把所有对象都 当成 Object 类型处理；从 JDK 5.0 增加了泛型以后，Java 集合可以记住容器中对象的数据类型。

Collection 接口方法

https://blog.csdn.net/qq_40164190/article/details/106506910

Collection子接口之一：List接口

List接口概述：

• 鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组
• List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
• List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据 序号存取容器中的元素。
• JDK API中List接口的实现类常用的有：ArrayList、LinkedList和Vector。

List接口常用方法

https://blog.csdn.net/qq_40164190/article/details/106431687

List实现类之一：ArrayList

• ArrayList 是 List 接口的典型实现类、主要实现类（即用得最多、最频繁）
• ArrayList是一个可变长数组，无容量的限制（超出容量后会自动扩容）
• 线程不安全的，会出现 fail-fast，效率高；底层使用Object类型的数组Object[]存储

ArrayList的源码分析：（详细源码分析及扩容机制请点击这里）

jdk 1.7情况下
ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData
list.add(123);//elementData[0] = new Integer(123);
…
list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容。
默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。

jdk 1.8中ArrayList的变化：
ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}.并没有创建长度为10的数组
list.add(123);//第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]
后续扩容操作与jdk1.8一致

小结：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)
在jdk1.8中，第一次调用add()时，底层才创建了长度10的数组。
jdk7中的ArrayList的对象的创建类似于单例模式的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例模式的懒汉式，延迟了数组的创建，节省内存。

List实现类之二：LinkedList

• LinkedList是一个继承于AbstractSequentialList的双向链表。它也可以被当做堆栈、队列或双端队列进行使用。
• 对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高
• LinkedList 中的操作不是线程安全的
• LinkedList：双向链表，内部没有声明数组，而是定义了Node类型的first和last， 用于记录首末元素。同时，定义内部类Node，作为LinkedList中保存数据的基本结构。Node除了保存数据，还定义了两个变量：
  • prev变量记录前一个元素的位置
  • next变量记录下一个元素的位置

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

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

• 新增方法：

void addFirst(Object obj)
void addLast(Object obj)
Object getFirst() 
Object getLast() 
Object removeFirst() 
Object removeLast()

List实现类之三：Vector

• Vector 是一个古老的集合，JDK1.0就有了。Vector 类实现了一个动态数组。和 ArrayList 很相似，区别之处在于：
  • Vector 是同步访问的，所以是Vector是线程安全的
  • Vector 包含了许多传统的方法，这些方法不属于集合框架。
• 在各种list中，最好把ArrayList作为默认选择。当插入、删除频繁时， 使用LinkedList；Vector总是比ArrayList慢，所以尽量避免使用

---

Collection子接口之二：Set接口

Set接口概述

• Set接口是Collection的子接口，Set与Collection基本上完全一样，因为Set接口中没有额外提供新的方法，使用的都是Collection中声明过的方法。实际上Set就是Collection，只是行为略有不同（Set不允许包含重复元素）。
• Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个 Set 集合中，则添加操作失败。
• Set 判断两个对象是否相同不是使用 == 运算符，而是根据 equals() 方法

Set实现类之一：HashSet

• HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时都使用这个实现类。
• HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存取、查找、删除 性能。
• HashSet 具有以下特点：
  • 不能保证元素的排列顺序（无序性）
  • 不可重复性
  • HashSet 不是线程安全的
  • 集合元素可以是 null
• HashSet 集合判断两个元素相等的标准：两个对象通过 hashCode() 方法比较相 等，并且两个对象的 equals() 方法返回值也相等。
• 对于存放在Set容器中的对象，对应的类一定要重写equals()和hashCode(Object obj)方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”

HashSet集合存储数据的结构（哈希表）

什么是哈希表呢？

在JDK1.8之前，哈希表底层采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

简单的来说，哈希表是由数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的。

JDK1.8引入红黑树大程度优化了HashMap的性能，那么对于我们来讲保证HashSet集合元素的唯一，其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象，那么保证其唯一，就必须复写hashCode和equals方法建立属于当前对象的比较方式。

添加元素的过程：以HashSet为例：

当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法 来得到该对象的 hashCode 值，

然后根据 hashCode 值，通过某种散列函数决定该对象 在 HashSet 底层数组中的存储位置。
	- 这个散列函数会与底层数组的长度相计算得到在数组中的下标，
	- 并且这种散列函数计算还尽可能保证能均匀存储元素，越是散列分布， 该散列函数设计的越好

如果两个元素的hashCode()值相等，会再继续调用equals方法，
	如果equals方法结果 为true，添加失败；
	如果为false，那么会保存该元素，但是该数组的位置已经有元素了， 那么会通过链表的方式继续链接。

如果两个元素的 equals() 方法返回 true，但它们的 hashCode() 返回值不相等：
	hashSet 将会把它们存储在不同的位置，但依然可以添加成功

Set实现类之二：LinkedHashSet

• LinkedHashSet 是 HashSet 的子类
• LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置， 但它同时使用双向链表维护元素的次序，这使得元素看起来是以插入顺序保存的。
• LinkedHashSet插入性能略低于 HashSet，但在迭代访问 Set 里的全部元素时有很好的性能。【即对于频繁的遍历操作， LinkedHashSet效率高于HashSet】
• LinkedHashSet 不允许集合元素重复

Set实现类之三：TreeSet

• TreeSet 是 SortedSet 接口的实现类，TreeSet 可以确保集合元素处于排序状态。
• TreeSet底层使用红黑树结构存储数
• 新增的方法如下： (了解)

  Comparator comparator()
  Object first() Object last() 
  Object lower(Object e) 
  Object higher(Object e) 
  SortedSet subSet(fromElement, toElement)
  SortedSet headSet(toElement)
  SortedSet tailSet(fromElement)
  

• TreeSet 两种排序方法：自然排序和定制排序。默认情况下，TreeSet 采用自然排序。
  

排 序—自然排序

• 自然排序：TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系，然后将集合元素按升序(默认情况)排列
• 如果试图把一个对象添加到 TreeSet 时，则该对象的类必须实现 Comparable 接口。
  • 实现 Comparable 的类必须实现 compareTo(Object obj) 方法，两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。
• Comparable 的典型实现：
  • BigDecimal、BigInteger 以及所有的数值型对应的包装类：按它们对应的数值大小 进行比较
  • Character：按字符的 unicode值来进行比较
  • Boolean：true 对应的包装类实例大于 false 对应的包装类实例
  • String：按字符串中字符的 unicode 值进行比较
  • Date、Time：后边的时间、日期比前面的时间、日期
• 向 TreeSet 中添加元素时，只有第一个元素无须比较compareTo()方法，后面添 加的所有元素都会调用compareTo()方法进行比较。
• 因为只有相同类的两个实例才会比较大小，所以向 TreeSet 中添加的应该是同 一个类的对象。
• 对于 TreeSet 集合而言，它判断两个对象是否相等的唯一标准是：两个对象通 过 compareTo(Object obj) 方法比较返回值。
• 当需要把一个对象放入 TreeSet 中，重写该对象对应的 equals() 方法时，应保证该方法与 compareTo(Object obj) 方法有一致的结果：如果两个对象通过 equals() 方法比较返回 true，则通过 compareTo(Object obj) 方法比较应返回 0。

排 序—定制排序

• TreeSet的自然排序要求元素所属的类实现Comparable接口，如果元素所属的类没 有实现Comparable接口，或不希望按照升序(默认情况)的方式排列元素或希望按照 其它属性大小进行排序，则考虑使用定制排序。定制排序，通过Comparator接口来 实现。需要重写compare(T o1,T o2)方法。
• 利用int compare(T o1,T o2)方法，比较o1和o2的大小：如果方法返回正整数，则表 示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2。
• 要实现定制排序，需要将实现Comparator接口的实例作为形参传递给TreeSet的构 造器。
• 此时，仍然只能向TreeSet中添加类型相同的对象。否则发生ClassCastException异 常。
• 使用定制排序判断两个元素相等的标准是：通过Comparator比较两个元素返回了0

---

Map接口

• Map与Collection并列存在。用于保存具有映射关系的数据:key-value
• Map 中的 key 和 value 都可以是任何引用类型的数据
• Map 中的 key 用Set来存放，不允许重复，即同一个 Map 对象所对应 的类，须重写hashCode()和equals()方法  常用String类作为Map的“键”
• key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到 唯一的、确定的 value
• Map接口的常用实现类：HashMap、TreeMap、LinkedHashMap和 Properties。其中，HashMap是 Map 接口使用频率最高的实现类

Map接口：常用方法：（点击这里）

Map实现类之一：HashMap

• HashMap是 Map 接口使用频率最高的实现类。
• 允许使用null键和null值，与HashSet一样，不保证映射的顺序。
• 所有的key构成的集合是Set:无序的、不可重复的。所以，key所在的类要重写： equals()和hashCode()
• 所有的value构成的集合是Collection:无序的、可以重复的。所以，value所在的类 要重写：equals()
• 一个key-value构成一个entry
• 所有的entry构成的集合是Set:无序的、不可重复的
• HashMap 判断两个 key 相等的标准是：两个 key 通过 equals() 方法返回 true， hashCode 值也相等。
• HashMap 判断两个 value相等的标准是：两个 value 通过 equals() 方法返回 true
• HashMap是非同步的（线程不安全），想要线程同步的HashMap可以用HashTable或ConcurrentHashMap。
  
• HashMap的内部存储结构其实是数组和链表的结合。当实例化一个HashMap时， 系统会创建一个长度为Capacity的Entry数组，这个长度在哈希表中被称为容量 (Capacity)，在这个数组中可以存放元素的位置我们称之为“桶”(bucket)，每个 bucket都有自己的索引，系统可以根据索引快速的查找bucket中的元素。
• 每个bucket中存储一个元素，即一个Entry对象，但每一个Entry对象可以带一个引 用变量，用于指向下一个元素，因此，在一个桶中，就有可能生成一个Entry链。 而且新添加的元素作为链表的head。
• 添加元素的过程： 向HashMap中添加entry1(key，value)，需要首先计算entry1中key的哈希值(根据 key所在类的hashCode()计算得到)，此哈希值经过处理以后，得到在底层Entry[]数 组中要存储的位置i。如果位置i上没有元素，则entry1直接添加成功。如果位置i上 已经存在entry2(或还有链表存在的entry3，entry4)，则需要通过循环的方法，依次 比较entry1中key和其他的entry。如果彼此hash值不同，则直接添加成功。如果 hash值不同，继续比较二者是否equals。如果返回值为true，则使用entry1的value 去替换equals为true的entry的value。如果遍历一遍以后，发现所有的equals返回都 为false,则entry1仍可添加成功。entry1指向原有的entry元素。

Map实现类之二：LinkedHashMap

• LinkedHashMap 是 HashMap 的子类
• 在HashMap存储结构的基础上，使用了一对双向链表来记录添加
  元素的顺序
  与LinkedHashSet类似，LinkedHashMap 可以维护 Map 的迭代 顺序：迭代顺序与 Key-Value 对的插入顺序一

Map实现类之三：TreeMap

• TreeMap存储 Key-Value 对时，需要根据 key-value 对进行排序。 TreeMap 可以保证所有的 Key-Value 对处于有序状态。
• TreeSet底层使用红黑树结构存储数据
• TreeMap 的 Key 的排序：
  • 自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有 的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException
  • 定制排序：创建 TreeMap 时，传入一个 Comparator 对象，该对象负责对 TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现 Comparable 接口
• TreeMap判断两个key相等的标准：两个key通过compareTo()方法或 者compare()方法返回0。

Map实现类之四：Hashtable

• Hashtable是个古老的 Map 实现类，JDK1.0就提供了。不同于HashMap， Hashtable是线程安全的。
• Hashtable实现原理和HashMap相同，功能相同。底层都使用哈希表结构，查询 速度快，很多情况下可以互用。
• 与HashMap不同，Hashtable 不允许使用 null 作为 key 和 value
• 与HashMap一样，Hashtable 也不能保证其中 Key-Value 对的顺序
• Hashtable判断两个key相等、两个value相等的标准，与HashMap一致

Map实现类之五：Properties

• Properties 类是 Hashtable 的子类，该对象用于处理属性文件
• 由于属性文件里的 key、value 都是字符串类型，所以 Properties 里的 key 和 value 都是字符串类型
• 存取数据时，建议使用setProperty(String key,String value)方法和 getProperty(String key)方法

Properties pros = new Properties();
pros.load(new FileInputStream("jdbc.properties"));
String user = pros.getProperty("user");
System.out.println(user)