Java 的数据结构整理（整合版）

一、数据输入输出

https://www.runoob.com/java/java-scanner-class.html

这部分是为了预防 leetcode 刷习惯了，忘记怎么处理输入输出的问题

数据输入

Java的数据输入和 C++ 相比非常繁琐，因此大多数的Java的例题都无需处理输入输出，直接处理封装好的函数体即可

通过 Scanner 类来获取用户的输入。使用步骤如下:

• 导包。Scanner 类在java.util包下，所以需要将该类导入。导包的语句需要定义在类的上面。

import java.util.Scanner;

• 创建Scanner对象。

Scanner sc = new Scanner(System.in);// 创建Scanner对象，sc表示变量名，其他均不可变

• 接收数据

int i = sc.nextInt(); // 表示将键盘录入的值作为int数返回。

import java.util.Scanner;

public class ScannerDemo {
	public static void main(String[] args) { //创建对象
		Scanner sc = new Scanner(System.in); //接收数据
        // 可以使用 next() 与 nextLine() 方法接收数据，如果要输入 int 或 float 类型的数据，使用 nextXxx() 来读取
        // 在读取前一般需要 使用 hasNext 与 hasNextLine 判断是否还有输入的数据
		int x = sc.nextInt();
		//输出数据
        System.out.println("x:" + x);
    }
}

import java.util.Scanner;
 
public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        // 从键盘接收数据
 
        // nextLine方式接收字符串
        System.out.println("nextLine方式接收：");
        // 判断是否还有输入
        if (scan.hasNextLine()) {
            String str2 = scan.nextLine().trim();
            System.out.println("输入的数据为：" + str2);
        }
        scan.close();
    }
}

next() 与 nextLine() 区别

next():

• 1、一定要读取到有效字符后才可以结束输入。
• 2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
• 3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
• next() 不能得到带有空格的字符串。

nextLine()：

• 1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
• 2、可以获得空白。

数据输出

System.out.println("Hello world");

二、集合框架

​ Java 集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。Collection 接口又有 3 种子类型，List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。

集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容：

• **接口：**是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象
• **实现（类）：**是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：ArrayList、LinkedList、HashSet、HashMap。
• **算法：**是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序，这些算法实现了多态，那是因为相同的方法可以在相似的接口上有着不同的实现。

​ 除了集合，该框架也定义了几个 Map 接口和类。Map 里存储的是键/值对。尽管 Map 不是集合，但是它们完全整合在集合中。

三、集合接口

集合框架定义了一些接口。

序号	接口描述
1	Collection 接口 Collection 是最基本的集合接口，一个 Collection 代表一组 Object，即 Collection 的元素, Java不提供直接继承自Collection的类，只提供继承于的子接口(如List和set)。 Collection 接口存储一组不唯一，无序的对象。
2	List 接口 List接口是一个有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引(元素在List中位置，类似于数组的下标)来访问List中的元素，第一个元素的索引为 0，而且允许有相同的元素。 List 接口存储一组不唯一，有序（插入顺序）的对象。
3	Set Set 具有与 Collection 完全一样的接口，只是行为上不同，Set 不保存重复的元素。 Set 接口存储一组唯一，无序的对象。
4	SortedSet 继承于Set保存有序的集合。
5	Map Map 接口存储一组键值对象，提供key（键）到value（值）的映射。
6	Map.Entry 描述在一个Map中的一个元素（键/值对）。是一个 Map 的内部接口。
7	SortedMap 继承于 Map，使 Key 保持在升序排列。
8	Enumeration 这是一个传统的接口和定义的方法，通过它可以枚举（一次获得一个）对象集合中的元素。这个传统接口已被迭代器取代。

Set和List的区别

• Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素
• Set 检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>
• List 和数组类似，可以动态增长，根据实际存储的数据的长度自动增长 List 的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector>

Collection 接口

​ 集合接口是集合框架构建的基础。它声明了所有集合都会具有的核心方法。

序号	方法和描述
1	boolean add(Object obj) 将obj添加到调用的集合中。如果obj被添加到集合中，则返回true。如果obj已经是集合的成员，或者集合不允许重复，则返回false。
2	boolean addAll(Collection c) 将c的所有元素添加到调用的集合中。如果操作成功（即元素被添加），则返回true。否则，返回false。
3	void clear( ) 从调用的集合中删除所有元素。
4	boolean contains(Object obj) 如果obj是调用的集合的元素，则返回true。否则，返回false。
5	boolean containsAll(Collection c) 如果调用的集合包含所有 c 的元素，则返回true。否则，返回false。
6	boolean equals(Object obj) 如果调用的集合和obj相等，则返回true。否则，返回false。
7	int hashCode( ) 返回调用集合的哈希码。
8	boolean isEmpty( ) 如果调用的集合为空，则返回true。否则，返回false。
9	Iterator iterator( ) 返回调用集合的迭代器。
10	boolean remove(Object obj) 从调用的集合中删除一个obj的实例。如果元素被删除，返回true。否则，返回false。
11	boolean removeAll(Collection c) 从调用的集合中删除c的所有元素。如果集合发生了变化（即有元素被删除），返回true。否则，返回false。
12	boolean retainAll(Collection c) 从调用的集合中删除除了c中的元素以外的所有元素。如果集合发生了变化（即有元素被删除），返回true。否则，返回false。
13	int size( ) 返回调用集合中持有的元素数。
14	Object[ ] toArray( ) 返回包含调用集合中所有元素的数组。该数组的元素是集合元素的副本。
15	Object[ ] toArray(Object array[ ]) 返回一个只包含与数组类型匹配的集合元素的数组。

List 接口

列表接口扩展了 Collection 并声明了一个存储元素序列的集合的行为。

• 可以通过在列表中的位置使用零为基的索引来插入或访问元素。
• 列表可以包含重复的元素。
• 除了由 Collection 定义的方法外，列表定义了一些自己的方法，这些方法在下表中总结。
• 如果集合不能被修改，一些列表方法将抛出UnsupportedOperationException异常，并且当一个对象与另一个对象不兼容时，会生成ClassCastException。

序号	方法和描述
1	void add(int index, Object obj) 将obj插入到调用列表中传入的索引处。任何在插入点或超出插入点的预先存在的元素都会向上移动。因此，没有元素被覆盖。
2	boolean addAll(int index, Collection c) 将c的所有元素插入到调用列表中传递给索引的索引处。任何在插入点或超出插入点的预先存在的元素都会向上移动。因此，没有元素被覆盖。如果调用的列表发生变化，返回true，否则返回false。
3	Object get(int index) 返回存储在调用集合中指定索引处的对象。
4	int indexOf(Object obj) 返回调用列表中第一个obj实例的索引。如果obj不是列表中的元素，则返回.1。
5	int lastIndexOf(Object obj) 返回调用列表中最后一个obj实例的索引。如果obj不是列表中的元素，则返回.1。
6	ListIterator listIterator( ) 返回指向调用列表起始处的迭代器。
7	ListIterator listIterator(int index) 返回一个指向调用列表的迭代器，从指定的下标开始。
8	Object remove(int index) 从调用的列表中删除索引位置的元素，并返回被删除的元素。结果列表被合并。也就是说，后续元素的索引减1。
9	Object set(int index, Object obj) 将obj赋值到调用列表中由index指定的位置。
10	List subList(int start, int end) 返回一个从头到尾包含元素的列表。1在调用列表中。返回列表中的元素也会被调用的对象引用。

Set 接口

​ Set是一种不能包含重复元素的集合。它模拟了数学集合的抽象概念。Set接口只包含继承自Collection的方法，并且增加了禁止有重复元素的限制。

​ Set还对equals和hashCode操作的行为增加了更强的约束，使得即使它们的类型实现不同，Set实例也可以有意义地进行比较。

序号	方法和描述
1	add( ) 向集合中添加一个对象。
2	clear( ) 从集合中移除所有对象。
3	contains( ) 如果指定对象是集合中的元素，返回true。
4	isEmpty( ) 如果集合没有元素，返回true。
5	iterator( ) 返回集合的迭代器对象，该对象可用于检索元素。
6	remove( ) 从集合中移除指定对象。
7	size( ) 返回集合中的元素数量。

SortedSet 接口

​ SortedSet接口扩展了Set接口，并声明了按升序排序的集合的行为。SortedSet接口除了Set接口定义的方法之外，还声明了下表中总结的方法。

​ 在调用集合中不包含任何项时，几个方法会抛出NoSuchElementException。当一个对象与集合中的元素不兼容时，会抛出ClassCastException异常。

​ 如果尝试使用一个空对象，并且集合中不允许使用null，那么将抛出NullPointerException异常。

序号	方法和描述
1	Comparator comparator() 返回调用的有序集的比较器。如果对该集使用自然排序，则返回null。
2	Object first() 返回调用的有序集中的第一个元素。
3	SortedSet headSet(Object end) 返回一个包含调用的有序集中小于end的元素的SortedSet。返回的有序集中的元素也被调用的有序集引用。
4	Object last() 返回调用的有序集中的最后一个元素。
5	SortedSet subSet(Object start, Object end) 返回一个包含在start和end之间的元素的SortedSet。返回集合中的元素也被调用的对象引用。
6	SortedSet tailSet(Object start) 返回一个包含大于或等于start的元素的SortedSet，这些元素包含在有序集中。返回集合中的元素也被调用的对象引用。

Map 接口

Map接口将唯一的键映射到值。键是用来在以后检索值的对象。

• 给定一个键和一个值，你可以将该值存储在一个Map对象中。在值被存储后，可以通过使用它的键来检索它。
• 几个方法在调用 Map 中不存在项目时会引发NoSuchElementException。
• 当对象与地图中的元素不兼容时，会引发ClassCastException。
• 如果尝试使用null对象并且在地图中不允许null，将引发NullPointerException。
• 当试图更改一个不可修改的映射时，将引发UnsupportedOperationException。

序号	方法与描述
1	void clear( ) 从调用的映射中删除所有的键/值对。
2	boolean containsKey(Object k) 如果调用的映射包含 k 作为键，则返回true。否则，返回false。
3	boolean containsValue(Object v) 如果映射中包含 v 作为值，则返回true。否则，返回false。
4	Set entrySet( ) 返回一个包含映射条目的Set。该Set包含类型为Map.Entry的对象。此方法提供了对调用的映射的Set视图。
5	boolean equals(Object obj) 如果obj是一个Map且包含相同的条目，则返回true。否则，返回false。
6	Object get(Object k) 返回与键 k 关联的值。
7	int hashCode( ) 返回调用map的哈希码。
8	boolean isEmpty( ) 如果调用的map为空，则返回true。否则，返回false。
9	Set keySet( ) 返回一个包含调用map中键的集合。该方法提供了调用map中键的视图。
10	Object put(Object k, Object v) 向调用的映射中放入一个条目，覆盖与该键关联的任何先前值。键和值分别为k和v。如果键以前不存在，则返回null。否则，返回与该键关联的先前值。
11	void putAll(Map m) 将 m 中的所有条目放入此映射中。
12	Object remove(Object k) 删除键等于 k 的条目。
13	int size( ) 返回映射中键/值对的数量。
14	Collection values( ) 返回包含映射中的值的集合。该方法提供了映射中值的集合视图。

Map.Entry 接口

​ The Map.Entry接口使我们能够使用Map条目进行操作。有点类似 Pair。

​ 由Map接口声明的 entrySet() 方法返回一个包含地图条目的Set。这些集合元素都是Map.Entry对象。

序号	方法与描述
1	boolean equals(Object obj) 如果obj是一个与调用对象的键和值相等的Map.Entry，则返回true。
2	Object getKey( ) 返回此映射项的键。
3	Object getValue( ) 返回此映射项的值。
4	int hashCode( ) 返回此映射项的哈希码。
5	Object setValue(Object v) 将此映射项的值设置为 v 。如果 v 不是映射的正确类型，则抛出ClassCastException。如果映射不允许空键，则如果 v 是null，则抛出NullPointerException。如果映射无法更改，则抛出UnsupportedOperationException。

SortedMap 接口

​ 排序映射接口扩展了映射接口。它确保条目按照升序的键顺序进行维护。

​ 当调用映射中没有条目时，几个方法会抛出 NoSuchElementException 异常。当一个对象与映射中的元素不兼容时，会抛出 ClassCastException 异常。如果在映射中出于不允许使用 null 的原因而试图使用一个 null 对象，则会抛出 NullPointerException 异常。

序号	方法与说明
1	Comparator comparator( ) 返回调用排序映射的比较器。如果使用自然顺序进行调用映射，则返回null。
2	Object firstKey( ) 返回调用映射中的第一个键。
3	SortedMap headMap(Object end) 返回那些键小于end的映射条目的排序映射。
4	Object lastKey( ) 返回调用映射中的最后一个键。
5	SortedMap subMap(Object start, Object end) 返回包含那些键大于或等于start且小于end的条目的映射。
6	SortedMap tailMap(Object start) 返回包含那些键大于或等于start的条目的映射。

集合实现类（集合类）

​ Java提供了一套实现了Collection接口的标准集合类。其中一些是具体类，这些类可以直接拿来使用，而另外一些是抽象类，提供了接口的部分实现

序号	类描述
1	AbstractCollection 实现了大部分的集合接口。
2	AbstractList 继承于AbstractCollection 并且实现了大部分List接口。
3	AbstractSequentialList 继承于 AbstractList ，提供了对数据元素的链式访问而不是随机访问。
4	LinkedList 该类实现了List接口，允许有null（空）元素。主要用于创建链表数据结构，该类没有同步方法，如果多个线程同时访问一个List，则必须自己实现访问同步，解决方法就是在创建List时候构造一个同步的List。例如：List list=Collections.synchronizedList(newLinkedList(...)); LinkedList 查找效率低。
5	ArrayList 该类也是实现了List的接口，实现了可变大小的数组，随机访问和遍历元素时，提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。 ArrayList 增长当前长度的50%，插入删除效率低。
6	AbstractSet 继承于AbstractCollection 并且实现了大部分Set接口。
7	HashSet 该类实现了Set接口，不允许出现重复元素，不保证集合中元素的顺序，允许包含值为null的元素，但最多只能一个。
8	LinkedHashSet 具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。
9	TreeSet 该类实现了Set接口，可以实现排序等功能。
10	AbstractMap 实现了大部分的Map接口。
11	HashMap HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。 该类实现了Map接口，根据键的HashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为null，不支持线程同步。
12	TreeMap 继承了AbstractMap，并且使用一颗树。
13	WeakHashMap 继承AbstractMap类，使用弱密钥的哈希表。
14	LinkedHashMap 继承于HashMap，使用元素的自然顺序对元素进行排序.
15	IdentityHashMap 继承AbstractMap类，比较文档时使用引用相等。

四、集合实现类

​ Java 提供了一套实现了 Collection 接口的标准集合类。其中一些是具体类，这些类可以直接拿来使用，而另外一些是抽象类，提供了接口的部分实现

序号	类描述
1	AbstractCollection 实现了大部分的集合接口。
2	AbstractList 继承于AbstractCollection 并且实现了大部分List接口。
3	AbstractSequentialList 继承于 AbstractList ，提供了对数据元素的链式访问而不是随机访问。
4	LinkedList 该类实现了List接口，允许有null（空）元素。主要用于创建链表数据结构，该类没有同步方法，如果多个线程同时访问一个List，则必须自己实现访问同步，解决方法就是在创建List时候构造一个同步的List。例如：List list=Collections.synchronizedList(newLinkedList(...)); LinkedList 查找效率低。
5	ArrayList 该类也是实现了List的接口，实现了可变大小的数组，随机访问和遍历元素时，提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。 ArrayList 增长当前长度的50%，插入删除效率低。
6	AbstractSet 继承于AbstractCollection 并且实现了大部分Set接口。
7	HashSet 该类实现了Set接口，不允许出现重复元素，不保证集合中元素的顺序，允许包含值为null的元素，但最多只能一个。
8	LinkedHashSet 具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。
9	TreeSet 该类实现了Set接口，可以实现排序等功能。
10	AbstractMap 实现了大部分的Map接口。
11	HashMap HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。 该类实现了Map接口，根据键的HashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为null，不支持线程同步。
12	TreeMap 继承了AbstractMap，并且使用一颗树。
13	WeakHashMap 继承AbstractMap类，使用弱密钥的哈希表。
14	LinkedHashMap 继承于HashMap，使用元素的自然顺序对元素进行排序.
15	IdentityHashMap 继承AbstractMap类，比较文档时使用引用相等。

LinkedList 类

​ LinkedList类扩展了AbstractSequentialList类并实现了List接口。它提供了一个链表数据结构

​ 与 ArrayList 相比，LinkedList 的增加和删除的操作效率更高，而查找和修改的操作效率较低。

以下情况使用 ArrayList :

• 频繁访问列表中的某一个元素。
• 只需要在列表末尾进行添加和删除元素操作。

以下情况使用 LinkedList :

• 你需要通过循环迭代来访问列表中的某些元素。
• 需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。

LinkedList 继承了 AbstractSequentialList 类。

LinkedList 实现了 Queue 接口，可作为队列使用。

LinkedList 实现了 List 接口，可进行列表的相关操作。

LinkedList 实现了 Deque 接口，可作为队列使用。

LinkedList 实现了 Cloneable 接口，可实现克隆。

LinkedList 实现了 java.io.Serializable 接口，即可支持序列化，能通过序列化去传输。

构造函数

序号	构造函数 & 描述
1	LinkedList( ) 这个构造函数构建一个空的链表。
2	LinkedList(Collection c) 这个构造函数构建一个链表，该链表使用集合 c 中的元素初始化。

其他方法

序号	方法与描述
1	void add(int index, Object element) 在列表中指定的位置index处插入指定的元素。如果指定的索引超出范围 (index < 0 || index > size())，则抛出IndexOutOfBoundsException异常。
2	boolean add(Object o) 将指定的元素追加到列表的末尾。
3	boolean addAll(Collection c) 将指定集合中的所有元素按照指定集合迭代器返回的顺序追加到列表的末尾。如果指定的集合为null，则抛出NullPointerException异常。
4	boolean addAll(int index, Collection c) 将指定集合中的所有元素从指定位置开始插入到此列表中。如果指定的集合为空，则抛出NullPointerException。
5	void addFirst(Object o) 在此列表的开头插入指定的元素。
6	void addLast(Object o) 将指定的元素追加到此列表的末尾。
7	void clear() 从此列表中移除所有元素。
8	Object clone() 返回此LinkedList的浅拷贝。
9	boolean contains(Object o) 如果此列表包含指定的元素，则返回true。更正式地说，如果且仅如果此列表包含至少一个元素e，使得(onull ? enull : o.equals(e))，则返回true。
10	Object get(int index) 返回列表中指定位置的元素。如果指定的索引超出范围 (index < 0 || index >= size())，则抛出IndexOutOfBoundsException。
11	Object getFirst() 返回此列表中的第一个元素。如果此列表为空，则抛出NoSuchElementException。
12	Object getLast() 返回此列表中的最后一个元素。如果此列表为空，则抛出NoSuchElementException。
13	int indexOf(Object o) 返回指定元素在列表中第一次出现的索引，如果列表不包含该元素则返回-1。
14	int lastIndexOf(Object o) 返回指定元素在列表中最后一次出现的索引，如果列表不包含该元素则返回-1。
15	ListIterator listIterator(int index) 返回一个列表迭代器，它按列表中的正确顺序（从指定位置开始）遍历列表中的元素。如果指定的索引超出范围（index < 0 || index >= size()），则抛出IndexOutOfBoundsException。
16	Iterator descendingIterator() 返回倒序迭代器。
17	Object remove(int index) 在此列表中删除指定位置的元素。如果此列表为空，则抛出NoSuchElementException异常。
18	boolean remove(Object o) 在列表中删除指定元素的第一个匹配项。如果此列表为空，则抛出NoSuchElementException异常。如果指定的索引超出范围（索引 < 0 || 索引 >= size()），则抛出IndexOutOfBoundsException异常。
19	Object removeFirst() 从列表中删除并返回第一个元素。如果此列表为空，则抛出NoSuchElementException异常。
20	Object removeLast() 从列表中删除并返回最后一个元素。如果此列表为空，则抛出NoSuchElementException异常。
21	Object set(int index, Object element) 用指定的元素替换列表中指定位置的元素。如果指定的索引超出范围（索引 < 0 || 索引 >= size()），则抛出IndexOutOfBoundsException异常。
22	int size() 返回列表中的元素数。
23	Object[] toArray() 返回包含列表中所有元素的数组，按正确的顺序。如果指定的数组为null，则抛出NullPointerException异常。
24	Object[] toArray(Object[] a) 返回包含列表中所有元素的数组，按正确的顺序；返回数组的运行时类型是指定数组的类型。
25	E poll() 删除并返回第一个元素。
26	**E peek() **返回第一个元素，如果队列是空的就返回null
27	**E element() **返回第一个元素，如果队列是空的就抛出异常NoSuchElementException
28	E peekFirst() 返回头部元素。
29	E peekLast() 返回尾部元素。

ArrayList 类

​ ArrayList类继承了 AbstractList 类并实现了 List 接口。ArrayList 支持动态数组，可以根据需要增长。

​ 标准的Java数组是固定长度的。一旦数组被创建，它们不能增长或缩小，这意味着您必须提前知道数组将容纳多少个元素。

​ 数组列表是带有初始大小的。当超过这个大小时，集合会自动扩大。当对象被移除时，数组可能会缩小。

构造函数

序号	构造方法 & 描述
1	ArrayList( ) 此构造方法构建一个空的数组列表。
2	ArrayList(Collection c) 此构造方法构建一个包含集合元素的数组列表 c 。
3	ArrayList(int capacity) 此构造方法构建一个具有指定初始容量的数组列表。容量是用于存储元素的底层数组的大小。随着元素加入数组列表，容量会自动增长。

其他方法

序号	方法及描述
1	void add(int index, Object element) 在此列表中的指定位置index插入指定的元素。如果指定的索引超出范围（index < 0 || index > size()），则抛出IndexOutOfBoundsException异常。
2	boolean add(Object o) 将指定的元素追加到此列表的末尾。
3	boolean addAll(Collection c) 将指定集合中的所有元素按照指定集合的迭代器返回顺序追加到此列表的末尾。如果指定的集合为空（null），则抛出NullPointerException异常。
4	boolean addAll(int index, Collection c) 将指定集合中的所有元素插入到列表的指定位置。如果指定集合为null，将抛出NullPointerException异常。
5	void clear() 从列表中移除所有元素。
6	Object clone() 返回此ArrayList的浅表副本。
7	boolean contains(Object o) 如果列表包含指定的元素，则返回true。更正式地说，如果列表至少包含一个元素 e 满足(onull ? enull : o.equals(e))，则返回true。
8	void ensureCapacity(int minCapacity) 如果需要，增加此ArrayList实例的容量，以确保至少可以容纳由最小容量参数指定的元素数量。
9	Object get(int index) 返回列表中指定位置的元素。如果指定的索引超出范围（index < 0 || index >= size()），则抛出IndexOutOfBoundsException。
10	int indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果列表不包含此元素，则返回-1。
11	int lastIndexOf(Object o) 返回列表中指定元素的最后一次出现的索引，如果列表不包含此元素，则返回-1。
12	Object remove(int index) 删除列表中指定位置的元素。如果索引超出范围（index < 0 || index >= size()），则抛出IndexOutOfBoundsException异常。
13	protected void removeRange(int fromIndex, int toIndex) 从此列表中删除所有索引位于fromIndex（包含）和toIndex（不包含）之间的元素。
14	Object set(int index, Object element) 用指定的元素替换列表中指定位置的元素。如果指定的索引超出范围（index < 0 || index >= size()），则抛出IndexOutOfBoundsException异常。
15	int size() 返回列表中元素的数量。
16	Object[] toArray() 返回一个按正确顺序包含列表中所有元素的数组。如果指定的数组为null，则抛出NullPointerException。
17	Object[] toArray(Object[] a) 返回一个按正确顺序包含列表中所有元素的数组;返回的数组的运行时类型是指定数组的类型。
18	void trimToSize() 将此ArrayList实例的容量调整为列表的当前大小。
19	Object[] subList(int fromIndex, int toIndex) 用于截取并返回动态数组中的一部分， fromIndex - 截取元素的起始位置，包含该索引位置元素 toIndex - 截取元素的结束位置，不包含该索引位置元素。 返回给定的动态数组截取的部分，如果fromIndex 小于 0 或大于数组的长度，则抛出 IndexOutOfBoundsException 的异常，如果 fromIndex 大于 toIndex 的值则抛出 IllegalArgumentException 异常；该动态数组包含的元素起始于 fromIndex 位置，直到元素索引位置为 toIndex-1，而索引位置 toIndex 的元素并不包括
20	void sort(Comparator c) 根据指定的顺序对动态数组中的元素进行排序，不返回任何值，它只是更改动态数组列表中元素的顺序

HashSet 类

​ HashSet 扩展了 AbstractSet 类并实现了 Set 接口。HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。HashSet 允许有 null 值。HashSet 是无序的，即不会记录插入的顺序。HashSet 不是线程安全的， 如果多个线程尝试同时修改 HashSet，则最终结果是不确定的。 必须在多线程访问时显式同步对 HashSet 的并发访问。

构造方法

No.	构造函数与描述
1	HashSet() 这个构造函数构造一个默认的HashSet。
2	HashSet(Collection c) 这个构造函数使用集合 c 的元素初始化哈希集。
3	HashSet(int capacity) 这个构造函数将哈希集的容量初始化为给定的整数值 capacity 。当向HashSet添加元素时，容量会自动增长。
4	HashSet(int capacity, float fillRatio) 这个构造函数根据参数初始化哈希集的容量和填充比率（也称为装载因子）。填充比率必须在0.0和1.0之间，它决定了哈希集在调整大小之前可以有多满。具体来说，当元素的数量大于哈希集的容量乘以其填充比率时，哈希集将进行扩展。

其他方法

序号	方法和描述
1	boolean add(Object o) 如果该集合中尚未包含指定元素，则将其添加到该集合中。
2	void clear() 从该集合中移除所有元素。
3	Object clone() 返回此HashSet实例的浅拷贝：元素本身不会被克隆。
4	boolean contains(Object o) 如果该集合包含指定的元素，则返回true。
5	boolean isEmpty() 如果该集合不包含任何元素，则返回true。
6	Iterator iterator() 返回该集合中元素的迭代器。
7	boolean remove(Object o) 如果该集合中存在指定的元素，则将其从集合中移除。
8	int size() 返回该集合中元素的数量（基数）。

LinkedHashSet 类

​ 该类继承自HashSet，但没有添加自己的成员。LinkedHashSet 维护了一个以插入顺序为排序的条目链表。这允许按照插入顺序进行迭代。也就是说，使用迭代器循环访问 LinkedHashSet 时，元素将按照插入顺序返回。

构造函数

序号	构造函数及其描述
1	HashSet( ) 该构造函数构造一个默认的HashSet。
2	HashSet(Collection c) 该构造函数通过使用集合 c 中的元素来初始化hash set。
3	LinkedHashSet(int capacity) 该构造函数将linkedhashset的容量初始化为给定的整数值capacity。随着元素的添加，容量会自动增长。
4	LinkedHashSet(int capacity, float fillRatio) 该构造函数通过参数初始化hash set的容量和填充比率（也称为加载容量）。

TreeSet 类

​ TreeSet 提供了一种使用树进行存储的 Set 接口的实现。对象按照排序和升序的方式存储。访问和检索时间非常快，这使得 TreeSet 成为在存储大量需要快速找到的已排序信息时的绝佳选择。

构造函数

序号	构造函数 & 描述
1	TreeSet( ) 此构造函数构建一个空的树集，根据其元素的自然顺序进行升序排序。
2	TreeSet(Collection c) 此构造函数构建一个包含集合中元素的树集 c 。
3	TreeSet(Comparator comp) 此构造函数构建一个空的树集，根据给定的比较器进行排序。
4	TreeSet(SortedSet ss) 此构造函数构建一个包含给定 SortedSet 元素的TreeSet。

其他方法

序号	方法和描述
1	void add(Object o) 如果此集合中尚未存在指定的元素，则将其添加到集合中。
2	boolean addAll(Collection c) 将指定集合中的所有元素添加到此集合。
3	void clear() 从集合中移除所有元素。
4	Object clone() 返回此TreeSet实例的浅拷贝。
5	Comparator comparator() 返回用于排序此排序集的比较器，如果此树集使用其元素的自然顺序，则返回null。
6	boolean contains(Object o) 如果此集合包含指定的元素，则返回true。
7	Object first() 返回此排序集中当前第一个（最低）元素。
8	SortedSet headSet(Object toElement) 返回此集合中严格小于toElement的部分的视图。
9	boolean isEmpty() 如果此集合不包含任何元素，则返回true。
10	Iterator iterator() 返回此集合中的元素的迭代器。
11	Object last() 返回此排序集中当前最后一个（最高）元素。
12	boolean remove(Object o) 如果存在，则从此集合中移除指定的元素。
13	int size() 返回此集合中的元素数量（基数）。
14	SortedSet subSet(Object fromElement, Object toElement) 返回该集合中元素范围从fromElement（包括）到toElement（不包括）的部分的视图。
15	SortedSet tailSet(Object fromElement) 返回此集合中大于或等于fromElement的部分的视图。

HashMap 类

​ HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。HashMap 是无序的，即不会记录插入的顺序。HashMap 继承于AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口。

构造函数

序号	构造函数和描述
1	HashMap( ) 这个构造函数构造一个默认的HashMap。
2	HashMap(Map m) 这个构造函数使用给定的Map对象的元素来初始化哈希映射中的元素 m
3	HashMap(int capacity) 这个构造函数通过使用给定的整数值capacity来初始化哈希映射的容量。
4	HashMap(int capacity, float fillRatio) 这个构造函数使用其参数来初始化哈希映射的容量和填充比例。

其他方法

Java HashMap 新增方法（merge,compute）

序号	方法与描述
1	void clear() 从映射中移除所有的键值对。
2	Object clone() 返回此HashMap实例的浅拷贝：键和值本身不会被克隆。
3	boolean containsKey(Object key) 如果此映射中包含指定键的映射关系，则返回true。
4	boolean containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回true。
5	Set entrySet() 返回包含此映射中的映射关系的集合视图。
6	Object get(Object key) 返回此标识哈希映射中与指定键映射关系对应的值，如果映射不包含该键的映射关系，则返回 null。
7	Object getOrDefault(Object key, V defaultValue) 获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值
8	boolean isEmpty() 如果此映射不包含键值映射，则返回true。
9	Set keySet() 返回此映射中包含的键的Set视图。
10	Object put(Object key, Object value) 在此映射中关联指定值与指定键。
11	putAll(Map m) 将指定映射中的所有映射复制到此映射。 这些映射将替换此映射当前在指定映射中的任何键的映射。
12	Object putIfAbsent(K key, V value) 如果 hashMap 中不存在指定的键，则将指定的键/值对插入到 hashMap 中；和 put 方法功能等价，效率并不等价
13	Object remove(Object key) 如果存在，从此映射中删除指定键的映射关系。
14	int size() 返回此映射中的键值映射的数量。
15	Collection values() 返回此映射中包含的值的集合视图。
16	Object replace(K key, V newValue) 或 replace(K key, V oldValue, V newValue) 替换 hashMap 中是指定的 key 对应的 value；如果 oldValue 不存，则替换 key 对应的值，返回 key 对应的旧值，如果存在 oldValue，替换成功返回 true，如果 key 不存在，则返回 null
17	Object merge(key, value, remappingFunction) 方法会先判断指定的 key 是否存在，如果不存在，则添加键值对到 hashMap 中； merge(key, value, (oldVal, newVal) -> oldVal + newVal) 如果key存在，则执行lambda表达式，表达式入参为oldVal和newVal(neVal即merge()的第二个参数)。表达式返回最终put的val。如果key不存在，则直接putnewVal。
18	compute(K key, BiFunction remappingFunction) 方法对 hashMap 中指定 key 的值进行重新计算； **根据已知的 k v 算出新的v并put。 注意：**如果无此key，那么oldVal为null，lambda中涉及到oldVal的计算会报空指针
19	computeIfAbsent(K key, Function remappingFunction) 对 hashMap 中指定 key 的值进行重新计算，如果不存在这个 key，则添加到 hashMap 中
20	computeIfPresent(K key, BiFunction remappingFunction) 对 hashMap 中指定 key 的值进行重新计算，前提是该 key 存在于 hashMap 中，key存在时才compute()避免潜在的空指针情况

TreeMap类

​ TreeMap类通过使用一棵树来实现Map接口。TreeMap提供了一种有效的方式来存储按照排序顺序排列的键/值对，并允许快速检索。需要注意的是，与哈希映射不同，树映射保证其元素按照键的升序排序。

构造函数

序号	构造方法 & 描述
1	TreeMap( ) 此构造方法构建一个空的树映射，将使用其键的自然顺序进行排序。
2	TreeMap(Comparator comp) 此构造方法构建一个空的树映射，将使用比较器 comp 进行排序。
3	TreeMap(Map m) 此构造方法使用键的自然顺序初始化一个树映射，其中的条目来自于 m 。
4	TreeMap(SortedMap sm) 此构造方法使用 SortedMap sm 中的条目来初始化一个树映射，条目的排序顺序与 sm 相同。

其他方法

序号	方法和描述
1	void clear() 从此TreeMap中删除所有映射。
2	Object clone() 返回此TreeMap实例的浅拷贝。
3	Comparator comparator() 返回用于对此映射进行排序的比较器，如果此映射使用其键的自然顺序，则返回null。
4	boolean containsKey(Object key) 如果此映射包含指定键的映射关系，则返回true。
5	boolean containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回true。
6	Set entrySet() 返回此映射中包含的映射的集合视图。
7	Object firstKey() 返回当前此排序映射中的第一个（最低）键。
8	Object get(Object key) 返回此映射将指定键映射到的值。
9	SortedMap headMap(Object toKey) 返回此映射中键严格小于toKey的部分的视图。
10	Set keySet() 返回此映射中包含的键的Set视图。
11	Object lastKey() 返回当前此排序映射中的最后一个（最高）键。
12	Object put(Object key, Object value) 将指定的值与指定的键关联到此映射中。
13	void putAll(Map map) 将指定映射中的所有映射都复制到此映射中。
14	Object remove(Object key) 如果存在，从此TreeMap中删除与此键关联的映射。
15	int size() 返回此映射中的键值映射数。
16	SortedMap subMap(Object fromKey, Object toKey) 返回此映射中键范围从fromKey（包括）到toKey（排除）的部分的视图。
17	SortedMap tailMap(Object fromKey) 返回此映射中键大于或等于 fromKey 的部分视图。
18	Collection values() 返回此映射中包含的值的集合视图。

WeakHashMap 类

​ WeakHashMap 是 Map 接口的实现，它只存储对其键的弱引用。只存储弱引用允许在其键在 WeakHashMap 之外不再被引用时，可以进行垃圾回收。这个类提供了利用弱引用的最简单方法。它非常适用于实现类似“注册表”的数据结构，当键不再被任何线程引用时，一个条目的实用性就消失了。WeakHashMap 的功能与 HashMap 完全相同，只有一个非常重要的例外：如果 Java 内存管理器不再对指定为键的对象有强引用，那么映射中的条目将被删除。

​ 弱引用 − 如果对象的所有引用都是弱引用，垃圾收集器可以随时回收对象的内存，而不需要等到系统内存耗尽。通常，在下一次垃圾收集器运行时，它将被释放

关于引用可以看这个Java中的引用类型： 弱引用、软引用与强引用详解

构造函数

序号	构造函数 & 描述
1	WeakHashMap() 该构造函数创建一个新的、空的WeakHashMap对象，其默认初始容量为16，加载因子为0.75。
2	WeakHashMap(int initialCapacity) 该构造函数创建一个新的、空的WeakHashMap对象，具有指定的初始容量和默认加载因子(0.75)。
3	WeakHashMap(int initialCapacity, float loadFactor) 该构造函数创建一个新的、空的WeakHashMap对象，具有指定的初始容量和加载因子。
4	WeakHashMap(Map t) 该构造函数创建一个新的WeakHashMap对象，其映射与指定的Map相同。

其他方法

序号	方法与描述
1	void clear() 从该映射中删除所有的键值映射。
2	boolean containsKey(Object key) 如果该映射包含指定键的映射关系，则返回 true。
3	boolean containsValue(Object value) 如果该映射将一个或多个键映射到指定值，则返回 true。
4	Set entrySet() 返回此映射中包含的映射的集合视图。
5	Object get(Object key) 返回指定键所映射到的在此弱哈希映射中的值，如果此映射不包含该键的映射关系，则返回 null。
6	boolean isEmpty() 如果该映射不包含键-值映射关系，则返回 true。
7	Set keySet() 返回此映射中包含的键的集合视图。
8	Object put(Object key, Object value) 将指定的值与该映射中的指定键关联起来。
9	void putAll(Map m) 将指定映射中的所有映射关系复制到此映射中。这些映射关系将替换开始此映射中具有任何当前在指定映射中的键的映射关系。
10	Object remove(Object key) 如果存在，则从该映射中移除键的映射关系。
11	int size() 返回此映射中的键-值映射关系的数目。
12	Collection values() 返回此映射中包含的值的集合视图。

LinkedHashMap 类

​ 该类扩展了 HashMap 类，并按照插入顺序维护了一个链表存储在 map 中的条目。这允许在迭代 LinkedHashMap 时按照插入顺序返回元素

构造函数

序号	构造函数和说明
1	LinkedHashMap( ) 该构造函数构建了一个默认的LinkedHashMap。
2	LinkedHashMap(Map m) 该构造函数使用给定的Map类中的元素初始化LinkedHashMap。 m 代表给定的Map类。
3	LinkedHashMap(int capacity) 该构造函数使用给定的容量初始化LinkedHashMap。
4	LinkedHashMap(int capacity, float fillRatio) 该构造函数同时初始化容量和填充比例。容量和填充比例的含义与HashMap相同。
5	LinkedHashMap(int capacity, float fillRatio, boolean Order) 该构造函数允许您指定元素是按插入顺序还是按最后访问顺序存储在链表中。如果Order为true，则使用访问顺序。如果Order为false，则使用插入顺序。

其他方法

序号	方法和描述
1	void clear() 从此映射中移除所有映射。
2	boolean containsKey(Object key) 如果此映射将一个或多个键映射到指定值，则返回true。
3	Object get(Object key) 返回此映射到指定键的值。
4	protected boolean removeEldestEntry(Map.Entry eldest) 如果此映射应该移除其最旧的条目，则返回true。

IdentityHashMap 类

​ IdentityHashMap 是Java集合框架中的一部分，此类实现 AbstractMap，它是HashMap的一种特殊实现。与标准的HashMap相比，IdentityHashMap在比较键（Key）时使用的是引用相等性（identity）而不是对象的等价性（equality）。这意味着，对于 IdentityHashMap 来说，当且仅当两个键（k1 和 k2）是且仅是同一个对象（k1 == k2）时，它们才被认为是相等的，换句话说，是允许key重复的。

​ IdentityHashMap通常用于需要维护对象的身份而不是对象的逻辑相等性的特殊情况。例如，它可以用于保存对象的元数据或维护对象引用的唯一列表。由于IdentityHashMap 不使用 hashCode() 和 equals() 方法，因此它的性能在某些情况下可能比标准HashMap更优。

​ 此类有一个调整参数（影响性能但不影响语义）：预期的最大大小。该参数是地图预计将保存的键值映射的最大数量。

构造函数

序号	构造函数及描述
1	IdentityHashMap() 该构造函数创建一个新的空的身份哈希映射，具有默认的预期最大大小（21）。
2	IdentityHashMap(int expectedMaxSize) 该构造函数使用指定的预期最大大小创建一个新的空的身份哈希映射。
3	IdentityHashMap(Map m) 该构造函数创建一个新的身份哈希映射，其中包含指定映射中的键值对。

其他方法

编号	方法及描述
1	void clear() 从该映射中移除所有映射关系。
2	Object clone() 返回此标识哈希映射的浅层副本：键和值本身未被克隆。
3	boolean containsKey(Object key) 测试指定的对象引用是否为此标识哈希映射的键。
4	boolean containsValue(Object value) 测试指定的对象引用是否为此标识哈希映射的值。
5	Set entrySet() 返回此映射中包含的映射的集合视图。
6	boolean equals(Object o) 将指定的对象与此映射进行比较，以确保相等性。
7	Object get(Object key) 返回此标识哈希映射中映射到指定键的值，如果该映射不包含此键的映射，则返回null。
8	int hashCode() 返回此映射的哈希码值。
9	boolean isEmpty() 如果此标识哈希映射不包含键值映射关系，则返回true。
10	Set keySet() 返回此映射中包含的键的基于标识的集合视图。
11	Object put(Object key, Object value) 在此标识哈希映射中将指定的值与指定的键关联。
12	void putAll(Map t) 将指定映射中的所有映射复制到此映射中。这些映射将替换掉此映射当前拥有的任何键的映射。
13	Object remove(Object key) 如果存在，则从此映射中移除指定键的映射。
14	int size() 返回此标识哈希映射中的键值映射数。
15	Collection values() 返回此映射中包含的值的集合视图。

Java.util 包中定义的类（非框架结构下）：

序号	类描述
1	Vector 该类和ArrayList非常相似，但是该类是同步的，可以用在多线程的情况，该类允许设置默认的增长长度，默认扩容方式为原来的2倍。
2	Stack 栈是Vector的一个子类，它实现了一个标准的后进先出的栈。
3	Dictionary Dictionary 类是一个抽象类，用来存储键/值对，作用和Map类相似。
4	Hashtable Hashtable 是 Dictionary(字典) 类的子类，位于 java.util 包中。
5	Properties Properties 继承于 Hashtable，表示一个持久的属性集，属性列表中每个键及其对应值都是一个字符串。
6	BitSet 一个Bitset 类创建一种特殊类型的数组来保存位值。BitSet中数组大小会随需要增加。

Java Vector类

​ Vector 类实现了一个动态数组。和 ArrayList 很相似，但两者是不同的：

• Vector 是同步访问的。
• Vector 包含了许多传统的方法，这些方法不属于集合框架。

​ Vector 主要用在事先不知道数组的大小，或者只是需要一个可以改变大小的数组的情况。

Vector 类支持 4 种构造方法。

序号	构造函数 & 描述
1	Vector( ) 此构造函数创建一个默认的向量，初始大小为10。
2	Vector(int size) 此构造函数接受一个与所需大小相等的参数，并创建一个初始容量由size指定的向量。
3	Vector(int size, int incr) 此构造函数创建一个初始容量由size指定，并且增量由incr指定的向量。增量指定每次调整向量大小时要分配的元素数量。
4	Vector(Collection c) 此构造函数创建一个包含集合c的元素的向量。

Vector 类中的其他方法

序号	方法与描述
1	void add(int index, Object element) 在Vector的指定位置插入指定的元素。
2	boolean add(Object o) 将指定的元素添加到Vector的末尾。
3	boolean addAll(Collection c) 将指定Collection中的所有元素以指定Collection的迭代器返回的顺序追加到Vector的末尾。
4	boolean addAll(int index, Collection c) 将指定Collection中的所有元素插入到Vector的指定位置。
5	void addElement(Object obj) 将指定组件添加到此向量的末尾，增加其大小一个。
6	int capacity() 返回此向量的当前容量。
7	void clear() 从此向量中删除所有元素。
8	Object clone() 返回此向量的克隆。
9	boolean contains(Object elem) 测试指定的对象是否是此向量的组件。
10	boolean containsAll(Collection c) 如果此向量包含指定集合中的所有元素，则返回true。
11	void copyInto(Object[] anArray) 将此向量的组件复制到指定的数组中。
12	Object elementAt(int index) 返回指定索引处的组件。
13	Enumeration elements() 返回此向量的组件的枚举。
14	void ensureCapacity(int minCapacity) 如有必要，增加此向量的容量，以确保能够容纳至少由最小容量参数指定的组件数量。
15	boolean equals(Object o) 将指定对象与此向量进行比较是否相等。
16	Object firstElement() 返回此向量的第一个组件(索引为0的项)。
17	**Object get(int index)**返回此向量中指定位置的元素。
18	**int hashCode()**返回此向量的哈希码值。
19	**int indexOf(Object elem)**搜索给定参数的第一次出现，使用equals方法进行相等性测试。
20	**int indexOf(Object elem, int index)**搜索给定参数的第一次出现，从索引开始搜索，并使用equals方法进行相等性测试。
21	void insertElementAt(Object obj, int index) 在此向量中的指定索引位置插入指定的对象作为组件。
22	boolean isEmpty() 测试此向量是否没有组件。
23	Object lastElement() 返回向量的最后一个组件。
24	int lastIndexOf(Object elem) 返回指定对象在此向量中最后一次出现的索引。
25	int lastIndexOf(Object elem, int index) 从指定索引开始反向搜索指定对象，并返回其索引。
26	Object remove(int index) 从向量中指定的位置删除元素。
27	boolean remove(Object o) 从向量中删除指定元素的第一个出现，如果向量不包含该元素，则不改变。
28	boolean removeAll(Collection c) 从向量中删除包含在指定集合中的所有元素。
29	void removeAllElements() 从向量中删除所有组件，并将其大小设置为零。
30	boolean removeElement(Object obj) 从向量中删除参数的第一个（最低索引）出现。
31	void removeElementAt(int index) 删除指定索引位置的元素。
32	protected void removeRange(int fromIndex, int toIndex) 删除此列表中从fromIndex（含）到toIndex（不含）之间的所有元素。
33	boolean retainAll(Collection c) 仅保留在此向量中包含在指定集合中的元素。
34	Object set(int index, Object element) 用指定的元素替换此向量中指定位置的元素。
35	void setElementAt(Object obj, int index) 将此向量中指定索引的组件设置为指定的对象。
36	void setSize（int newSize） 设置此向量的大小。
37	int size（） 返回此向量中的组件数。
38	List subList（int fromIndex，int toIndex） 以fromIndex（含）和toIndex（不含）之间的部分返回此列表的视图。
39	Object[] toArray（） 按正确的顺序返回包含此向量中所有元素的数组。
40	Object[] toArray（Object[] a） 按正确的顺序返回包含此向量中所有元素的数组；返回的数组的运行时类型是指定数组的类型。
41	String toString() 返回此向量的字符串表示形式，包含每个元素的字符串表示形式。
42	void trimToSize() 将此向量的容量调整为向量的当前大小。

Java Stack类

Stack是Vector的子类，实现了标准的后进先出的堆栈。

Stack只定义了默认构造函数，用于创建一个空的堆栈。Stack包含了所有Vector定义的方法，并添加了一些自己的方法。

Stack()

除了从其父类Vector继承的方法外，Stack还定义了以下方法

编号	方法和描述
1	boolean empty() 测试此堆栈是否为空。如果堆栈为空则返回true，否则返回false。
2	Object peek( ) 返回堆栈顶部的元素，但不将其移除。
3	Object pop( ) 返回堆栈顶部的元素，并将其移除。
4	Object push(Object element) 将元素推入堆栈。元素也将被返回。
5	int search(Object element) 在堆栈中搜索元素。如果找到，则返回元素与堆栈顶部的偏移量。否则，返回-1。

Dictionary 类

Dictionary 类是一个抽象类，用来存储键/值对，作用和Map类相似。

​ 给出键和值，你就可以将值存储在Dictionary对象中。一旦该值被存储，就可以通过它的键来获取它。所以和Map一样， Dictionary 也可以作为一个键/值对列表。

​ 但 Dictionary 类已经过时。可以实现Map接口来获得键/值存储功能

Dictionary定义的抽象方法如下表所示：

No	方法与描述
1	enumeration elements() 返回字典中包含的值的枚举。
2	Object get(Object key) 返回包含与键相关联的值的对象。如果键不在字典中，则返回一个空对象。
3	boolean isEmpty() 如果字典为空，返回true；如果字典包含至少一个键，则返回false。
4	enumeration keys() 返回字典中包含的键的枚举。
5	Object put(Object key, Object value) 将键及其值插入字典中。如果键尚未在字典中，则返回null；如果键已经在字典中，则返回与键相关联的先前值。
6	Object remove(Object key) 移除键及其值。返回与键相关联的值。如果键不在字典中，则返回null。
7	int size() 返回字典中的条目数。

Hashtable 类

​ Hashtable是原始的 java.util 的一部分， 是一个 Dictionary 具体的实现。然而，Java 2 重构的Hashtable实现了Map接口，因此，Hashtable现在集成到了集合框架中。它和 HashMap 类很相似，但是它支持同步。

​ 像HashMap一样，Hashtable在哈希表中存储键/值对。当使用一个哈希表，要指定用作键的对象，以及要链接到该键的值。

​ 然后，该键经过哈希处理，所得到的散列码被用作存储在该表中值的索引。

构造函数列表

序号	构造函数和描述
1	Hashtable( ) 这是哈希表的默认构造函数，它实例化Hashtable类。
2	Hashtable(int size) 这个构造函数接受一个整数参数，并创建一个具有由整数值size指定的初始大小的哈希表。
3	Hashtable(int size, float fillRatio) 这创建了一个具有由大小指定的初始大小和由fillRatio指定的填充比率的哈希表。此比率必须介于0.0和1.0之间，并确定哈希表在重新调整大小之前可以有多满。
4	**Hashtable(Map t) ** 这使用给定的映射构造一个Hashtable。哈希表的容量被设置为 t 的两倍

除了从 Map 接口中定义的方法外，其他方法

序号	方法及描述
1	void clear( ) 重置并清空哈希表。
2	Object clone( ) 返回调用对象的副本。
3	boolean contains(Object value) 如果哈希表中存在与value相等的值，则返回true。如果找不到该值，则返回false。
4	boolean containsKey(Object key) 如果哈希表中存在与key相等的键，则返回true。如果找不到该键，则返回false。
5	boolean containsValue(Object value) 如果哈希表中存在与value相等的值，则返回true。如果找不到该值，则返回false。
6	Enumeration elements( ) 返回哈希表中包含的值的枚举。
7	Object get(Object key) 返回与key关联的值。如果哈希表中不存在该键，则返回空对象。
8	boolean isEmpty( ) 如果哈希表为空，则返回true；如果至少包含一个键，则返回false。
9	Enumeration keys( ) 返回哈希表中包含的键的枚举。
10	Object put(Object key, Object value) 将键和值插入哈希表。如果键尚未存在于哈希表中，则返回空；如果键已经存在于哈希表中，则返回与键关联的先前值。
11	void rehash( ) 增加哈希表的大小并重新哈希化所有键。
12	Object remove(Object key) 删除键及其值。返回与键关联的值。如果哈希表中不存在该键，则返回空对象。
13	int size( ) 返回哈希表中的条目数。
14	String toString( ) 返回哈希表的字符串表示形式。

五、集合算法

​ 集合框架定义了几种算法，可用于集合和映射。这些算法被定义为集合类的静态方法。

​ 在尝试比较不兼容的类型时，一些方法能够抛出 ClassCastException异常。当试图修改一个不可修改的集合时，抛出UnsupportedOperationException异常。

​ 集合定义三个静态的变量：EMPTY_SET，EMPTY_LIST，EMPTY_MAP的。这些变量都不可改变。

序号	方法与描述
1	static int binarySearch(List list, Object value, Comparator c) 根据 c 按顺序在列表中搜索值。如果找到该值，则返回其位置；如果未找到该值，则返回-1。
2	static int binarySearch(List list, Object value) 在列表中搜索值。列表必须是有序的。如果找到该值，则返回其位置；如果未找到该值，则返回-1。
3	static void copy(List list1, List list2) 将list2的元素复制到list1中。
4	static Enumeration enumeration(Collection c) 返回一个枚举 c 的枚举。
5	static void fill（List list，Object obj） 将 obj 分配给列表的每个元素。
6	static int indexOfSubList（List list，List subList） 在列表中搜索subList的第一次出现。返回第一个匹配项的索引，如果没有找到匹配项，则返回1。
7	static int lastIndexOfSubList（List list，List subList） 在列表中搜索subList的最后一次出现。返回最后一个匹配项的索引，如果没有找到匹配项，则返回1。
8	static ArrayList list（Enumeration enum） 返回一个包含enum元素的ArrayList。
9	static Object max(Collection c, Comparator comp) 根据 comp 决定，返回集合 c 中的最大元素。
10	static Object max(Collection c) 根据自然排序，返回集合 c 中的最大元素。集合不需要排序。
11	static Object min(Collection c, Comparator comp) 根据 comp 决定，返回集合 c 中的最小元素。集合不需要排序。
12	static Object min(Collection c) 根据自然排序，返回集合 c 中的最小元素。
13	static List nCopies(int num, Object obj) 返回一个包含 num 个 obj 副本的不可变列表。num 必须大于或等于零。
14	static boolean replaceAll(List list, Object old, Object new) 将列表中所有的 old 替换为 new。如果至少有一个替换发生，则返回 true。否则返回 false。
15	static void reverse(List list) 反转列表中的顺序。
16	static Comparator reverseOrder( ) 返回一个逆向比较器。
17	static void rotate(List list, int n) 将列表按照 n 进行旋转右边的地方。要向左旋转，请给n设置一个负值.
18	static void shuffle(List list, Random r) 使用 r 作为随机数源，对列表中的元素进行洗牌（即随机排序）。
19	static void shuffle(List list) 对列表中的元素进行洗牌（即随机排序）。
20	static Set singleton(Object obj) 将obj作为不可变的set返回。这是将单个对象转换为set的简便方法。
21	static List singletonList(Object obj) 将obj作为不可变的列表返回。这是将单个对象转换为列表的简便方法。
22	static Map singletonMap(Object k, Object v) 将键/值对k/v作为不可变映射返回。这是将单个键/值对转换为映射的简单方法。
23	static void sort(List list, Comparator comp) 根据comp确定的顺序对list的元素进行排序。
24	static void sort(List list) 根据元素的自然顺序对list的元素进行排序。
25	static void swap(List list, int idx1, int idx2) 交换列表中由idx1和idx2指定的索引处的元素。
26	static Collection synchronizedCollection(Collection c) 返回一个同步的集合，该集合是由c支持的。返回一个由 c 支持的线程安全集合。
27	static List synchronizedList(List list) 返回一个由list支持的线程安全列表。
28	static Map synchronizedMap(Map m) 返回一个由 m 支持的线程安全映射。
29	static Set synchronizedSet(Set s) 返回一个由 s 支持的线程安全集合。
30	static SortedMap synchronizedSortedMap(SortedMap sm) 返回一个由 sm 支持的线程安全的排序映射。
31	static SortedSet synchronizedSortedSet(SortedSet ss) 返回一个由 ss 支持的线程安全的集合。
32	static Collection unmodifiableCollection(Collection c) 返回由 c 支持的不可修改的集合。
33	static List unmodifiableList(List list) 返回由列表支持的不可修改的列表。
34	static Map unmodifiableMap(Map m) 返回由 m 支持的不可修改的映射。
35	static Set unmodifiableSet(Set s) 返回由 s 支持的不可修改的集合。
36	static SortedMap unmodifiableSortedMap(SortedMap sm) 返回由 sm 支持的不可修改的排序映射。
37	static SortedSet unmodifiableSortedSet(SortedSet ss) 返回由 ss 支持的不可修改的排序集合。

迭代器

​ Java迭代器（Iterator）是 Java 集合框架中的一种机制，是一种用于遍历集合（如列表、集合和映射等）的接口。

​ 它提供了一种统一的方式来访问集合中的元素，而不需要了解底层集合的具体实现细节。

​ Java Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法，可用于迭代 ArrayList 和 HashSet 等集合。

​ Iterator 是 Java 迭代器最简单的实现，ListIterator 是 Collection API 中的接口， 它扩展了 Iterator 接口，允许列表的双向遍历和元素的修改。

迭代器声明的方法

序号	方法与描述
1	boolean hasNext( ) 如果还有更多元素，则返回true。否则，返回false。
2	Object next( ) 返回下一个元素。如果没有下一个元素，则抛出NoSuchElementException异常。
3	void remove( ) 移除当前元素。如果在调用remove( )之前没有调用next( )，则抛出IllegalStateException异常。

ListIterator 声明的方法

序号	方法与描述
1	void add(Object obj) 在列表中obj对象之前插入元素，该元素将在下一次调用next()时返回。
2	boolean hasNext( ) 如果存在下一个元素，则返回true。否则，返回false。
3	boolean hasPrevious( ) 如果存在上一个元素，则返回true。否则，返回false。
4	Object next( ) 返回下一个元素。如果没有下一个元素，则会抛出NoSuchElementException异常。
5	int nextIndex( ) 返回下一个元素的索引。如果没有下一个元素，则返回列表的大小。
6	Object previous( ) 返回上一个元素。如果没有上一个元素，则会抛出NoSuchElementException异常。
7	int previousIndex( ) 返回上一个元素的索引。如果没有上一个元素，则返回-1。
8	void remove( ) 从列表中删除当前元素。如果在调用next()或previous()之前调用remove()，则会抛出IllegalStateException异常。
9	void set(Object obj) 将obj赋值给当前元素。这是最后一次调用next()或previous()返回的元素。

通常，要使用迭代器循环遍历集合的内容

• 通过调用集合的iterator()方法获取一个迭代器到集合的起始位置。
• 设置循环，调用hasNext()方法并使循环迭代，只要hasNext()返回true。
• 在循环内，通过调用next()方法获取每个元素。

while(it.hasNext()) {
    System.out.println(it.next());
}

遍历ArrayList

import java.util.*;
 
public class Test{
 public static void main(String[] args) {
     List<String> list=new ArrayList<String>();
     list.add("Hello");
     list.add("World");
     list.add("HAHAHAHA");
     //第一种遍历方法使用 For-Each 遍历 List
     for (String str : list) {            //也可以改写 for(int i=0;i<list.size();i++) 这种形式
        System.out.println(str);
     }
 
     //第二种遍历，把链表变为数组相关的内容进行遍历
     String[] strArray=new String[list.size()];
     list.toArray(strArray);
     for(int i=0;i<strArray.length;i++) //这里也可以改写为  for(String str:strArray) 这种形式
     {
        System.out.println(strArray[i]);
     }
     
    //第三种遍历 使用迭代器进行相关遍历
     
     Iterator<String> ite=list.iterator();
     while(ite.hasNext())//判断下一个元素之后有值
     {
         System.out.println(ite.next());
     }
 }
}

遍历Map

import java.util.*;
 
public class Test{
     public static void main(String[] args) {
      Map<String, String> map = new HashMap<String, String>();
      map.put("1", "value1");
      map.put("2", "value2");
      map.put("3", "value3");
      
      //第一种：普遍使用，二次取值
      System.out.println("通过Map.keySet遍历key和value：");
      for (String key : map.keySet()) {
       System.out.println("key= "+ key + " and value= " + map.get(key));
      }
      
      //第二种
      System.out.println("通过Map.entrySet使用iterator遍历key和value：");
      Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
      while (it.hasNext()) {
       Map.Entry<String, String> entry = it.next();
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
      }
      
      //第三种：推荐，尤其是容量大时
      System.out.println("通过Map.entrySet遍历key和value");
      for (Map.Entry<String, String> entry : map.entrySet()) {
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
      }
    
      //第四种
      System.out.println("通过Map.values()遍历所有的value，但不能遍历key");
      for (String v : map.values()) {
       System.out.println("value= " + v);
      }
     }
}

比较器

​ TreeSet和TreeMap都以排序顺序存储元素。然而，正是比较器定义了确切的排序顺序的含义。

​ Comparator接口定义了两个方法：compare（）和equals（）。compare（）方法如下所示，用于比较两个元素的顺序

compare方法

int compare(Object obj1, Object obj2)

​ obj1和obj2是要进行比较的对象。该方法如果对象相等返回零。如果obj1大于obj2则返回正数。否则返回负值。

​ 通过重写compare()方法，您可以改变对象的排序方式。例如，可以创建一个反向比较结果的比较器以实现按照反向顺序排序。

equals方法

用于测试一个对象是否与调用比较器相等。

boolean equals(Object obj)

​ obj是要测试是否相等的对象。如果obj和调用对象都是Comparator对象并且使用相同的排序顺序，则该方法返回true。否则，返回false。

​ 覆盖equals（）是不必要的，大多数简单的比较器都不会这样做。

比较器使用

Arrays.sort(a, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
        // return o2.compareTo(o1);
    }
});
public int compareTo(T other)
// compareTo() 方法比较当前对象与 other 对象的顺序关系，并返回以下结果：
// 如果当前对象小于 other 则返回一个负整数
// 如果当前对象等于 other 返回 0
// 如果当前对象大于 other 则返回一个正整数

// 降序 Collections.reverseOrder()
Arrays.sort(a, Collections.reverseOrder());

// lambda 写法
Arrays.sort(a, (o1, o2) -> o2 - o1); 

// 实现 Comparator 接口，重写 compare() 方法
Arrays.sort(str, new CompLen());
class CompLen implements Comparator<String>{
    @Override
    public int compare(String o1, String o2) {
        return o1.length() - o2.length(); // 也可以实现降序排列 o2.length() - o1.length();
    }
}

写compare()方法，您可以改变对象的排序方式。例如，可以创建一个反向比较结果的比较器以实现按照反向顺序排序。

equals方法

用于测试一个对象是否与调用比较器相等。

boolean equals(Object obj)

​ obj是要测试是否相等的对象。如果obj和调用对象都是Comparator对象并且使用相同的排序顺序，则该方法返回true。否则，返回false。

​ 覆盖equals（）是不必要的，大多数简单的比较器都不会这样做。

比较器使用

Arrays.sort(a, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
        // return o2.compareTo(o1);
    }
});
public int compareTo(T other)
// compareTo() 方法比较当前对象与 other 对象的顺序关系，并返回以下结果：
// 如果当前对象小于 other 则返回一个负整数
// 如果当前对象等于 other 返回 0
// 如果当前对象大于 other 则返回一个正整数

// 降序 Collections.reverseOrder()
Arrays.sort(a, Collections.reverseOrder());

// lambda 写法
Arrays.sort(a, (o1, o2) -> o2 - o1); 

// 实现 Comparator 接口，重写 compare() 方法
Arrays.sort(str, new CompLen());
class CompLen implements Comparator<String>{
    @Override
    public int compare(String o1, String o2) {
        return o1.length() - o2.length(); // 也可以实现降序排列 o2.length() - o1.length();
    }
}