java 集合

0java 集合

• Collection是单列集合的根接口，主要用于存储一系列符合某种规则的元素，它有两个重要的子接口List和Set。
• List接口的特点是元素有序可重复
• Set接口的特点是元素无序，不可重复
• ArrayList和LinkedList是List接口的实现类
• HashSet和TreeSet是Set接口的实现类

---

• Map是双列集合的根接口，特用蓝色标注，用于存储具有键（Key），值（Value）映射关系的元素，每个元素都包含一个键-值对，在使用该集合时可以通过指定的键找的对应的值。
• Map为独立接口
• HashMap和TreeMap是Map接口的实现类

Iterator

public interface Iterator

概述

位于包 java.util中，Iterator接口是Java集合框架的成员，E表示这个迭代器返回的元素的类型。

对 collection 进行迭代的迭代器。迭代器取代了 Java Collections Framework 中的 Enumeration。迭代器与枚举有两点不同

• 迭代器允许调用者在迭代过程中使用明确定义的语义从底层集合中移除元素；
• 改进了方法名称

• public interface **Enumeration**

实现 Enumeration 接口的对象，它生成一系列元素，一次生成一个。连续调用 nextElement 方法将返回一系列的连续元素。

例如，要输出 Vector v 的所有元素，可使用以下方法：

   for (Enumeration<E> e = v.elements(); e.hasMoreElements();)
       System.out.println(e.nextElement());

这些方法主要通过向量的元素、哈希表的键以及哈希表中的值进行枚举。枚举也用于将输入流指定到 SequenceInputStream 中。

注：此接口的功能与 Iterator 接口的功能是重复的。此外，Iterator 接口添加了一个可选的移除操作，并使用较短的方法名。新的实现应该优先考虑使用 Iterator 接口而不是 Enumeration 接口。

boolean	hasMoreElements]() 测试此枚举是否包含更多的元素。
E	nextElement() 如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个素。

方法

boolean	hasNext() 如果仍有元素可以迭代，则返回 true。
E	next() 返回迭代的下一个元素。
void	remove() 从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。

改变列表的结构，改变列表的大小，打乱列表的顺序等使正在进行迭代产生错误的结果。 java.util.ConcurrentModificationException

原理

Java中的Iterator功能比较简单，并且只能单向移动：

(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个 元素。注意：iterator()方法是java.lang.Iterable接口,被Collection继承。

(2) 使用next()获得序列中的下一个元素。

(3) 使用hasNext()检查序列中是否还有元素。

(4) 使用remove()将迭代器新返回的元素删除。

ListIterator

系列表迭代器，允许程序员按任一方向遍历列表、迭代期间修改列表，并获得迭代器在列表中的当前位置。ListIterator 没有当前元素；它的光标位置 始终位于调用 previous() 所返回的元素和调用 next() 所返回的元素之间。长度为 n 的列表的迭代器有 n+1 个可能的指针位置

ListIterator是一个功能更加强大的, 它继承于Iterator接口,只能用于各种List类型的访问。可以通过调用listIterator()方法产生一个指向List开始处的ListIterator, 还可以调用listIterator(n)方法创建一个一开始就指向列表索引为n的元素处的ListIterator。

void	add(E e) 将指定的元素插入列表（可选操作）。
boolean	hasNext() 以正向遍历列表时，如果列表迭代器有多个元素，则返回 true（换句话说，如果 next 返回一个元素而不是抛出异常，则返回 true）。
boolean	hasPrevious() 如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
E	next() 返回列表中的下一个元素。
int	nextIndex() 返回对next` 的后续调用所返回元素的索引。
E	previous() 返回列表中的前一个元素。
int	previousIndex() 返回对 previous 的后续调用所返回元素的索引。
void	remove() 从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。
void	set(E e) 用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。

remove() 和 set(Object) 方法不是 根据光标位置定义的；它们是根据对调用 next() 或 previous() 所返回的最后一个元素的操作定义的

Collection

public interface Collection extends Iterable

概述

Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也称为 collection 的。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何 实现：它提供更具体的子接口（如 和 ）实现。此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。

接口常用方法

boolean	add(E e) 确保此 collection 包含指定的元素（可选操作）。
boolean	addAll(Collection c) 将指定 collection 中的所有元素都添加到此 collection 中（可选作）。
void	clear() 移除此 collection 中的所有元素（可选操作）。
boolean	contains(Object o) 如果此 collection 包含指定的元素，则返回 true。
boolean	containsAll(Collection c) 如果此 collection 包含指定 collection 中的所有元素，则返回 true。
boolean	equals(Object o) 比较此 collection 与指定对象是否相等。
int	hashCode() 返回此 collection 的哈希码值。
boolean	isEmpty() 如果此 collection 不包含元素，则返回true`。
Iterator	iterator() 返回在此 collection 的元素上进行迭代的迭代器。
boolean	remove(Object o) 从此 collection 中移除指定元素的单个实例，如果存在的话（可选作）。
boolean	removeAll(Collection c) 移除此 collection 中那些也包含在指定 collection 中的所有元素
boolean	retainAll(Collection c) 仅保留此 collection 中那些也包含在指定 collection 的元素
int	size() 返回此 collection 中的元素数。
Object[]	toArray() 返回包含此 collection 中所有元素的数组。
T[]	toArray(T[] a) 返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

List

public interface List extends Collection`

概述

List集合为列表类型，以线性方式存储对象。List集合中的元素允许重复，各元素的顺序就是对象插入的顺序。用户可以通过使用索引来访问List集合中的元素。

特点

1. 有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

2. 与 set 不同，列表通常允许重复的元素。更确切地讲，列表通常允许满足 e1.equals(e2) 的元素对 e1 和 e2，并且如果列表本身允许 null 元素的话，通常它们允许多个 null 元素。难免有人希望通过在用户尝试插入重复元素时抛出运行时异常的方法来禁止重复的列表，但我们希望这种用法越少越好。

3. List 接口提供了 4 种对列表元素进行定位（索引）访问方法。列表（像 Java 数组一样）是基于 0 的。注意，这些操作可能在和某些实现（例如 LinkedList 类）的索引值成比例的时间内执行。因此，如果调用者不知道实现，那么在列表元素上迭代通常优于用索引遍历列表

List集合的特点就是存取有序，可以存储重复的元素，可以用下标进行元素的操作

接口常用方法

void	add(int index, E element) 在列表的指定位置插入指定元素（可选操作）。
boolean	addAllint index, Collection c) 将指定 collection 中的所有元素都插入到列表中的指定置
E	get(int index) 返回列表中指定位置的元素。
int	hashCode() 返回列表的哈希码值。
int	indexOf(Object o) 返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
int	lastIndexOf() 返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
ListIterator	listIterator() 返回此列表元素的列表迭代器（按适当顺序）。
ListIterator	listIterator(int index) 返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。
E	remove(int index) 移除列表中指定位置的元素（可选操作）。
E	set(int index, E element) 用指定元素替换列表中指定位置的元素（可选操作）。
List	subList(int fromIndex, int toIndex) 返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。

常用子类

ArrayList

public class **ArrayList**extends AbstractListimplements List, RandomAccess, Cloneable, Serializable

概述

每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单。

在添加大量元素前，应用程序可以使用 ensureCapacity 操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。

**注意，此实现不是同步的。**如果多个线程同时访问一个 ArrayList 实例，而其中至少一个线程从结构上修改了列表，那么它必须 保持外部同步。（结构上的修改是指任何添加或删除一个或多个元素的操作，或者显式调整底层数组的大小；仅仅设置元素的值不是结构上的修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方法将该列表“包装”起来。这最好在创建时完成，以防止意外对列表进行不同步的访问：

        List list = Collections.synchronizedList(new ArrayList(...)); 

特点

• 优点: 底层数据结构是数组，查询快，增删慢。
• 缺点: 线程不安全，效率高

常用方法

构造方法摘要
[ArrayList() 构造一个初始容量为 10 的空列表。
ArrayList(Collection c) 构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
[ArrayList(int initialCapacity) 构造一个具有指定初始容量的空列表。

void	ensureCapacity(int minCapacity) 如有必要，增加此ArrayList` 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。
protected void	removeRange(int fromIndex, int toIndex) 移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。
void	trimToSize() 将此 ArrayList 实例的容量调整为列表的当前大小。

LinkedList

public class LinkedListextends AbstractSequentialListimplements List, Deque, Cloneable, Serializable`

概述

List 接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括 null）。除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。

此类实现 Deque 接口，为 add、poll 提供先进先出队列操作，以及其他堆栈和双端队列操作。

**注意，此实现不是同步的。**如果多个线程同时访问一个链接列表，而其中至少一个线程从结构上修改了该列表，则它必须 保持外部同步。（结构修改指添加或删除一个或多个元素的任何操作；仅设置元素的值不是结构修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方法来“包装”该列表。最好在创建时完成这一操作，以防止对列表进行意外的不同步访问，如下所示：

   List list = Collections.synchronizedList(new LinkedList(...));

特点

优点: 底层数据结构是链表，查询慢，增删快。
缺点: 线程不安全，效率高

常用方法

构造方法摘要
LinkedList() 构造一个空列表。
LinkedList(Collection c) 构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列。

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

Vector

public class **Vector**extends AbstractListimplements List, RandomAccess, Cloneable, Serializable

概述

Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。

每个向量会试图通过维护 capacity 和 capacityIncrement 来优化存储管理。capacity 始终至少应与向量的大小相等；这个值通常比后者大些，因为随着将组件添加到向量中，其存储将按 capacityIncrement 的大小增加存储块。应用程序可以在插入大量组件前增加向量的容量；这样就减少了增加的重分配的量。

由 Vector 的 iterator 和 listIterator 方法所返回的迭代器是快速失败的：如果在迭代器创建后的任意时间从结构上修改了向量（通过迭代器自身的 remove 或 add 方法之外的任何其他方式），则迭代器将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就完全失败，而不是冒着在将来不确定的时间任意发生不确定行为的风险。Vector 的 elements 方法返回的 Enumeration 不是 快速失败的。

特点

优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程安全，效率低

常用方法

构造方法摘要
[Vector() 构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。
Vector(Collection c) 构造一个包含指定 collection 中的元素的向量，这些元素按其 collection 的迭代器返回元素的顺序排列。
Vector(int initialCapacity) 使用指定的初始容量和等于零的容量增量构造一个空向量。
Vector(int initialCapacity, int capacityIncrement) 使用指定的初始容量和容量增量构造一个空的向量。

方法摘要
void	addElement(E obj) 将指定的组件添加到此向量的末尾，将其大小增加 1。
int	capacity() 返回此向量的当前容量。
void	copyInto(Object[] anArray) 将此向量的组件复制到指定的数组中。
E	elementAt(int index) 返回指定索引处的组件。
Enumeration	elements() 返回此向量的组件的枚举。
void	ensureCapacity(int minCapacity) 增加此向量的容量（如有必要），以确保其至少能够保存最小容量参数指定的组件数。
E	firstElement()返回此向量的第一个组件（位于索引0`) 处的项）。
void	insertElementAt(E obj, int index) 将指定对象作为此向量中的组件插入到指定的 index 处。
void	removeAllElements() 从此向量中移除全部组件，并将其大小设置为零。
boolean	removeElement(Object obj) 从此向量中移除变量的第一个（索引最小的）匹配项。
void	removeElementAt(int index) 删除指定索引处的组件。
protected void	removeRange(int fromIndex, int toIndex) 从此 List 中移除其索引位于 fromIndex（包括）与 toIndex（不包括）之间的所有元素。
void	setElementAt(E obj, int index) 将此向量指定 index 处的组件设置为指定的对象。
void	setSize(int newSize) 设置此向量的大小。
String	toString() 返回此向量的字符串表示形式，其中包含每个元素的 String 表示形式。
void	trimToSize() 对此向量的容量进行微调，使其等于向量的当前大小。

Set

public interface Set extends Collection`

概述

Set集合中的对象不按特定的方式排序，只是简单的将对象加入到集合中，但是Set集合不能包括重复对象

Set接口继承了Collection接口，因此也包含Collection接口的所有方法

特点

• 无序
• 无重复，可以为null
• 无索引

接口常用方法

在所有构造方法以及 add、equals 和 hashCode 方法的协定上，Set 接口还加入了其他规定，这些规定超出了从 Collection 接口所继承的内容。出于方便考虑，它还包括了其他继承方法的声明（这些声明的规范已经专门针对 Set 接口进行了修改，但是没有包含任何其他的规定）。

常用子类

HashSet

public class **HashSet**extends AbstractSet implements Set, Cloneable, Serializable

概述

此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素。

**注意，此实现不是同步的。**如果多个线程同时访问一个哈希 set，而其中至少一个线程修改了该 set，那么它必须 保持外部同步。这通常是通过对自然封装该 set 的对象执行同步操作来完成的。如果不存在这样的对象，则应该使用 Collections.synchronizedSet 方法来“包装” set。最好在创建时完成这一操作，以防止对该 set 进行意外的不同步访问：

   Set s = Collections.synchronizedSet(new HashSet(...));

特点

底层数据结构是哈希表。(1.8之前：数组+链表，之后：数组+红黑树(链表多于八的时候))

不允许重复，无序。

依赖两个方法：hashCode()和equals()

在HashSet中，基本的操作都是有HashMap底层实现的，因为HashSet底层是用HashMap存储数据的。当向HashSet中添加元素的时候，首先计算元素的hashcode值，然后用这个（元素的hashcode）%（HashMap集合的大小）+1计算出这个元素的存储位置，如果这个位置位空，就将元素添加进去；如果不为空，则用equals方法比较元素是否相等，相等就不添加，否则找一个空位添加。

java.lnag.Object中对hashCode的约定：

1. 在一个应用程序执行期间，如果一个对象的equals方法做比较所用到的信息没有被修改的话，则对该对象调用hashCode方法多次，它必须始终如一地返回同一个整数。
2. 如果两个对象根据equals(Object o)方法是相等的，则调用这两个对象中任一对象的hashCode方法必须产生相同的整数结果。
3. 如果两个对象根据equals(Object o)方法是不相等的，则调用这两个对象中任一个对象的hashCode方法，不要求产生不同的整数结果。但如果能不同，则可能提高散列表的性能。

常用方法

构造方法摘要
HashSet() 构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。
HashSet(Collection c) 构造一个包含指定 collection 中的元素的新 set。
HashSet(int initialCapacity) 构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和默认的加载因子（0.75）。
HashSet(int initialCapacity, float loadFactor) 构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和指定的加载因子。

从接口 java.util.Set 继承的方法
add, addAll, clear, contains, containsAll, equals, hashCode, isEmpty, iterator, remove, removeAll, retainAll, size, toArray, toArray

LinkedHashSet

public class **LinkedHashSet** extends HashSet implements Set, Cloneable, Serializable

概述

具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。此实现与 HashSet 的不同之外在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，即按照将元素插入到 set 中的顺序（插入顺序）进行迭代。注意，插入顺序不 受在 set 中重新插入的 元素的影响。（如果在 s.contains(e) 返回 true 后立即调用 s.add(e)，则元素 e 会被重新插入到 set s 中。）

**注意，此实现不是同步的。**如果多个线程同时访问链接的哈希 set，而其中至少一个线程修改了该 set，则它必须 保持外部同步。这一般通过对自然封装该 set 的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedSet 方法来“包装”该 set。最好在创建时完成这一操作，以防止意外的非同步访问：

     Set s = Collections.synchronizedSet(new LinkedHashSet(...));

常用方法

构造方法摘要
LinkedHashSet() 构造一个带默认初始容量 (16) 和加载因子 (0.75) 的新空链接哈希 set。
LinkedHashSet(Collection c) 构造一个与指定 collection 中的元素相同的新链接哈希 set。
LinkedHashSet(int initialCapacity) 构造一个带指定初始容量和默认加载因子 (0.75) 的新空链接哈希 set。
LinkedHashSet(int initialCapacity, float loadFactor) 构造一个带有指定初始容量和加载因子的新空链接哈希 set。

从类 java.util.HashSet 继承的方法
add, clear, clone, contains, isEmpty, iterator, remove, size

特点

底层数据结构是链表(用于保证顺序)和哈希表。
1.由链表保证元素有序
2.由哈希表保证元素唯一

TreeSet

public class **TreeSet **extends AbstractSet implements NavigableSet, Cloneable, Serializable`

概述

基于 TreeMap 的 NavigableSet 实现。使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法

TreeSet为使用树来进行储存的Set接口提供了一个工具，对象按升序储存，访问和检索是很快的。在存储了大量的需要进行快速检索的排序信息的情况下，TreeSet是一个不错的选择。

**注意，此实现不是同步的。**如果多个线程同时访问一个 TreeSet，而其中至少一个线程修改了该 set，那么它必须 外部同步。这一般是通过对自然封装该 set 的对象执行同步操作来完成的。如果不存在这样的对象，则应该使用 Collections.synchronizedSortedSet 方法来“包装”该 set。此操作最好在创建时进行，以防止对 set 的意外非同步访问：

   SortedSet s = Collections.synchronizedSortedSet(new TreeSet(...));

特点

底层数据结构是红黑树。

• 唯一
• 有序

如何保证元素排序的呢?
自然排序
比较器排序
2.如何保证元素唯一性的呢?
根据比较的返回值是否是0来决定

注意，如果要正确实现 Set 接口，则 set 维护的顺序（无论是否提供了显式比较器）必须与 equals 一致。（关于与 equals 一致 的精确定义，请参阅 Comparable 或 Comparator。）这是因为 Set 接口是按照 equals 操作定义的，但 TreeSet 实例使用它的 compareTo（或 compare）方法对所有元素进行比较，因此从 set 的观点来看，此方法认为相等的两个元素就是相等的。即使 set 的顺序与 equals 不一致，其行为也是 定义良好的；它只是违背了 Set 接口的常规协定。

那我们对自定义的TreeSet进行排序时，就需要自己重写比较方法
    自然排序
	  自然排序要进行一下操作：
		1.xxx类中实现 Comparable接口
		2.重写Comparable接口中的Compareto方法	
   	public class xxx implements Comparable{	
    	@Override
		public int compareTo(Object o)
		{
			//return -1; //-1表示放在红黑树的左边,即逆序输出
       	 	//return 1;  //1表示放在红黑树的右边，即顺序输出
        	//return o;  //表示元素相同，仅存放第一个元素
			return 0; 
		}
    }

	比较器排序
	  比较器排序步骤：
		1.单独创建一个比较类，这里以MyComparator为例，并且要让其继承Comparator接口
		2.重写Comparator接口中的Compare方法
        
        public class MyComparator implements Comparator<xxx> {
    		@Override
    		public int compare(Student s1,Student s2) {
        		//return -1; //-1表示放在红黑树的左边,即逆序输出
       	 	//return 1;  //1表示放在红黑树的右边，即顺序输出
        	//return o;  //表示元素相同，仅存放第一个元素
			return 0;
    		}
		}

		TreeSet<xxx> ts=new TreeSet<Student>(new MyComparator());

Comparable

强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compaetTo 方法被称为她的自然比较方法。

只能在类中实现 compareTo() 一次，不能经常修改类的代码实现自己想要的排序，实现此接口的对象列表（和数组）可以通过 Collection.sort （和 Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无序指定比较器。

comparator

强行对某个对象进行整体排序。可以将 Comparator 传递给 sort 方法（如Collection.sort 或 Array.sort），从而允许在排序上实现精确控制。

还可以使用 Comparator 来控制某些数据结构（如有序 set 或有序的映射）的顺序，或者为那些没有自然顺序的对象 collection 提供排序。

对于自定义的类型来说，如果想要调用 Collections.sort() 或 Arrays.sort() 方法时，必须指定一个比较器。

1、在当前类中 实现 Comparable 接口，重写其中的 compareTo() 方法，在方法里面指定比较方式。

2、在调用 sort() 方法的时候，在第二个参数的位置，new Comparor 对象，然后重写 compare 方法。

常用方法

构造方法摘要
TreeSet() 构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。
TreeSet(Collection c) 构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。
TreeSet(Comparator comparator) 构造一个新的空 TreeSet，它根据指定比较器进行排序。
TreeSet(SortedSet s) 构造一个与指定有序 set 具有相同映射关系和相同排序的新 TreeSet。

E	ceiling(E e) 返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。
Comparator	comparator() 返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回 null。
Iterator	descendingIterator()` 返回在此 set 元素上按降序进行迭代的迭代器。
NavigableSet	descendingSet() 返回此 set 中所包含元素的逆序视图。
E	first() 返回此 set 中当前第一个（最低）元素。
E	floor(E e) 返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。
SortedSet	headSet(E toElement) 返回此 set 的部分视图，其元素严格小于 toElement。
NavigableSet	headSet(E toElement, boolean inclusive) 返回此 set 的部分视图，其元素小于（或等于，如果 inclusive 为 true）toElement。
E	higher(E e) 返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null。
Iterator	iterator() 返回在此 set 中的元素上按升序进行迭代的迭代器。
E	last() 返回此 set 中当前最后一个（最高）元素。
E	lower(E e) 返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。
E	pollFirst() 获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。
E	pollLast() 获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。
SortedSet	tailSet(E fromElement) 返回此 set 的部分视图，其元素大于等fromElement`。
NavigableSet	tailSet(E fromElement, boolean inclusive) 返回此 set 的部分视图，其元素大于（或等于，如果 inclusive 为 true）fromElement。

Collections

public class **Collections **extends Object

概述

此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。它包含在 collection 上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容。

作用

Collections 是一个操作 Set、List 和 Map 等集合的工具类。Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法：

常用方法

1. publicstatic boolean` `addAll(Collection`super` `T> c,T... elements)

   将所有指定元素添加到指定 collection 中。

2. publicstatic intbinarySearch(List`extends` `Comparable`superT>> list,T key)

   在List集合中查找某个元素的下标，但是List的元素必须是T或T的子类对象，而且必须是可比较大小的，即支持自然排序的。而且集合也事先必须是有序的，否则结果不确定。

3. publicstatic``extendsObject & ComparablesuperT>> T max(CollectionextendsT> coll)

   `在coll集合中找出最大的元素，集合中的对象必须是T或T的子类对象，而且支持自然排序

4. publicstaticvoid reverse(List list) 反转指定列表List中元素的顺序。

5. publicstaticvoid shuffle(List list) List 集合元素进行随机排序，类似洗牌

6. publicstatic``extends ComparablesuperT>> void sort(List list)

   根据元素的自然顺序对指定 List 集合元素按升序排序

7. publicstaticvoid sort(List list,Comparatorsuper T> c)

```根据指定的 Comparator 产生的顺序对 List 集合元素进行排序`

8. publicstaticintfre quency(Collection c,Object o)返回指定集合中指定元素的出现次数

9. publicstatic ``void copy(ListsuperT> dest,List`extendsT> src)将src中的内容复制到dest中

注意：

Collections 类中提供了多个 synchronizedXXX() 方法，该方法可使指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题。

Collections 类中提供了多个 unmodifiableXXX() 方法，该方法返回指定 XXX 的不可修改的视图。

Map

public interface **Map**

概述

将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

此接口取代 Dictionary 类，后者完全是一个抽象类，而不是一个接口。

Map 接口提供三种collection 视图，允许以键集、值集或键-值映射关系集的形式查看某个映射的内容。映射顺序 定义为迭代器在映射的 collection 视图上返回其元素的顺序。某些映射实现可明确保证其顺序，如 TreeMap 类；另一些映射实现则不保证顺序，如 HashMap 类。

注：将可变对象用作映射键时必须格外小心。当对象是映射中某个键时，如果以影响 equals 比较的方式更改了对象的值，则映射的行为将是不确定的。此项禁止的一种特殊情况是不允许某个映射将自身作为一个键包含。虽然允许某个映射将自身作为值包含，但请格外小心：在这样的映射上 equals 和 hashCode 方法的定义将不再是明确的。

特点

• Map集合没有继承Collection接口，其提供的是键到值的映射。

• Map不能包含相同的键，每个键只能映射一个值。键还决定了储存对象在映射中的储存位置。如果相同后者会覆盖前者(这里与Set不同)

• 无序

• 可以为null

• 允许以键集、值集或键-值映射关系集的形式查看某个映射的内容

• 只支持Iterator(迭代器)遍历

一定要重写hashcode（）和equals（）防止重复。

由Map接口定义的集合又被叫做是查找表，将key值作为value的索引，以key-value键值对的方式进行数据存储，其中key值不可重复；而Map有多种实现类，以哈希表（hashtable）作为底层数据结构实现的，我们叫做HashMap；因此HashMap的实现原理即哈希表数据结构的实现原理。

hash表就是通过传入的键值对，通过hash算法指向一个连续的存储空间（数组存储），将键值对存入数组；对于指向相同的存储空间的hash值，再以链表方式存储；这样hashmap不仅具有了数据查询快速的特性，同时有了链表方便插入、删除的特性；因此hashMap对于数据的存储查询具有非常好的特性；

常用方法

嵌套类摘要
static interface	Map.Entry[K,V] 映射项（键-值对）。

映射项（键-值对）。Map.entrySet 方法返回映射的 collection 视图，其中的元素属于此类。获得映射项引用的唯一 方法是通过此 collection 视图的迭代器来实现。这些 Map.Entry 对象仅 在迭代期间有效；更确切地讲，如果在迭代器返回项之后修改了底层映射，则某些映射项的行为是不确定的，除了通过 setValue 在映射项上执行操作之外。

Map.Entry是Map声明的一个内部接口，此接口为泛型，定义为Entry。它表示Map中的一个实体（一个key-value对）。接口中有getKey(),getValue方法。

方法摘要
void	clear() 从此映射中移除所有映射关系（可选操作）。
boolean	containsKey(Object key) 如果此映射包含指定键的映射关系，则返回true`。
boolean	containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回true`。
Set<Map.entry<k,v>>	entrySet() 返回此映射中包含的映射关系的 Set 视图。
boolean	equals(Object o) 比较指定的对象与此映射是否相等。
V	get(Object key) 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
int	hashCode() 返回此映射的哈希码值。
boolean	isEmpty() 如果此映射未包含键-值映射关系，则返回 true。
Set	keySet() 返回此映射中包含的键的 Set 视图。
V	put(K key, V value) 将指定的值与此映射中的指定键关联（可选操作）。
void	putAll(Map m) 从指定映射中将所有映射关系复制到此映射中（可选操作）。
V	remove(Object key) 如果存在一个键的映射关系，则将其从此映射中移除
int	size() 返回此映射中的键-值映射关系数。
Collection	values() 返回此映射中包含的值的 Collection 视图。

常用子类

HashMap

public class **HashMap**extends AbstractMap implements Map, Cloneable, Serializable

概述

基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

此实现假定哈希函数将元素适当地分布在各桶之间，可为基本操作（get 和 put）提供稳定的性能。迭代 collection 视图所需的时间与 HashMap 实例的“容量”（桶的数量）及其大小（键-值映射关系数）成比例。所以，如果迭代性能很重要，则不要将初始容量设置得太高（或将加载因子设置得太低）。

HashMap 的实例有两个参数影响其性能：初始容量 和加载因子。容量 是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。

**注意，此实现不是同步的。**如果多个线程同时访问一个哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须 保持外部同步。（结构上的修改是指添加或删除一个或多个映射关系的任何操作；仅改变与实例已经包含的键关联的值不是结构上的修改。）这一般通过对自然封装该映射的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedMap 方法来“包装”该映射。最好在创建时完成这一操作，以防止对映射进行意外的非同步访问，如下所示：

   Map m = Collections.synchronizedMap(new HashMap(...));

特点

• (1.8之前：数组+链表，之后：数组+红黑树(链表多于八的时候))

• 初始长度16，加载因子0.75，扩展长度2倍。

• 非线程安全

• 添加元素时使用自定义的哈希算法

常用方法

构造方法摘要
HashMap() 构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。
HashMap(int initialCapacity) 构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。
HashMapint initialCapacity, float loadFactor)构造一个带指定初始容量和加载因子的空HashMap`。
HashMap(Map m) 构造一个映射关系与指定 Map 相同的新 HashMap。

LinkedHashMap

public class **LinkedHashMap **extends HashMap implements Map

概述

Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。此实现与 的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序通常就是将键插入到映射中的顺序（）。注意，如果在映射中 键，则插入顺序不受影响。（如果在调用 前 返回了 ，则调用时会将键 重新插入到映射 中。）

此类提供所有可选的 Map 操作，并且允许 null 元素。与 HashMap 一样，它可以为基本操作（add、contains 和 remove）提供稳定的性能，假定哈希函数将元素正确分布到桶中。由于增加了维护链接列表的开支，其性能很可能比 HashMap 稍逊一筹，不过这一点例外：LinkedHashMap 的 collection 视图迭代所需时间与映射的大小 成比例。HashMap 迭代时间很可能开支较大，因为它所需要的时间与其容量 成比例。

**注意，此实现不是同步的。**如果多个线程同时访问链接的哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须 保持外部同步。这一般通过对自然封装该映射的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedMap 方法来“包装”该映射。最好在创建时完成这一操作，以防止对映射的意外的非同步访问：

    Map m = Collections.synchronizedMap(new LinkedHashMap(...));

特点

• 基于双向链表
• 非线程安全
• 有顺序(按照插入顺序)

常用方法

构造方法摘要
LinkedHashMap() 构造一个带默认初始容量 (16) 和加载因子 (0.75) 的空插入顺序 LinkedHashMap 实例。
LinkedHashMap(int initialCapacity) 构造一个带指定初始容量和默认加载因子 (0.75) 的空插入顺序 LinkedHashMap 实例。
LinkedHashMap(int initialCapacity, float loadFactor) 构造一个带指定初始容量和加载因子的空插入顺序 LinkedHashMap 实例。
LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) 构造一个带指定初始容量、加载因子和排序模式的空 LinkedHashMap 实例。
LinkedHashMap(Map m) 构造一个映射关系与指定映射相同的插入顺序 LinkedHashMap 实例。

方法摘要
protected boolean	removeEldestEntry(Map.Entry eldest) 如果此映射移除其最旧的条目，则返回 true。

从类 java.util.HashMap 继承的方法
clone, containsKey, entrySet, isEmpty, keySet, put, putAll, remove, size, values

TreeMap

public class **TreeMap **extends AbstractMap implements NavigableMap, Cloneable, Serializable

概述

基于红黑树（Red-Black tree）的 NavigableMap 实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。

注意，如果要正确实现 Map 接口，则有序映射所保持的顺序（无论是否明确提供了比较器）都必须与 equals 一致。（关于与 equals 一致 的精确定义，请参阅 Comparable 或 Comparator）。这是因为 Map 接口是按照 equals 操作定义的，但有序映射使用它的 compareTo（或 compare）方法对所有键进行比较，因此从有序映射的观点来看，此方法认为相等的两个键就是相等的。即使排序与 equals 不一致，有序映射的行为仍然是 定义良好的，只不过没有遵守 Map 接口的常规协定。

**注意，此实现不是同步的。**如果多个线程同时访问一个映射，并且其中至少一个线程从结构上修改了该映射，则其必须 外部同步。（结构上的修改是指添加或删除一个或多个映射关系的操作；仅改变与现有键关联的值不是结构上的修改。）这一般是通过对自然封装该映射的对象执行同步操作来完成的。如果不存在这样的对象，则应该使用 Collections.synchronizedSortedMap 方法来“包装”该映射。最好在创建时完成这一操作，以防止对映射进行意外的不同步访问，如下所示：

   SortedMap m = Collections.synchronizedSortedMap(new TreeMap(...));

特点

• TreeMap与TreeSet类似，都需要重写比较器（外部比较器+内部比较器）
• 单一
• 有序
• 非同步
• 基于红黑树

常用方法

构造方法摘要
TreeMap() 使用键的自然顺序构造一个新的、空的树映射。
TreeMap(Comparator comparator) 构造一个新的、空的树映射，该映射根据给定比较器进行排序。
TreeMap(Map m) 构造一个与给定映射具有相同映射关系的新的树映射，该映射根据其键的自然顺序 进行排序。
TreeMap(SortedMap m) 构造一个与指定有序映射具有相同映射关系和相同排序顺序的新的树映射。

方法摘要
Map.Entry	ceilingEntry(K key) 返回一个键-值映射关系，它与大于等于给定键的最小键关联；如果不存在这样的键，则返回 null。
K	ceilingKey(K key) 返回大于等于给定键的最小键；如果不存在这样的键，则返回 null。
Comparator	comparator() 返回对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返回 null。
NavigableSet	descendingKeySet() 返回此映射中所包含键的逆序 NavigableSet 视图。
NavigableMap	descendingMap() 返回此映射中所包含映射关系的逆序视图。
Map.Entry	firstEntry() 返回一个与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 null。
K	firstKey() 返回此映射中当前第一个（最低）键。
Map.Entry	floorEntry(K key) 返回一个键-值映射关系，它与小于等于给定键的最大键关联；如果不存在这样的键，则返回 null。
K	floorKey(K key) 返回小于等于给定键的最大键；如果不存在这样的键，则返回 null。
SortedMap	headMap(K toKey) 返回此映射的部分视图，其键值严格小于 toKey。
NavigableMap	headMap(K toKey, boolean inclusive) 返回此映射的部分视图，其键小于（或等于，如果 inclusive 为 true）toKey。
Map.Entry	higherEntry(K key) 返回一个键-值映射关系，它与严格大于给定键的最小键关联；如果不存在这样的键，则返回 null。
K	higherKey(K key) 返回严格大于给定键的最小键；如果不存在这样的键，则返回 null。
Map.Entry	lastEntry() 返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 null。
K	lastKey() 返回映射中当前最后一个（最高）键。
Map.Entry	lowerEntryK (key) 返回一个键-值映射关系，它与严格小于给定键的最大键关联；如果不存在这样的键，则返回 null。
K	lowerKeyK (key) 返回严格小于给定键的最大键；如果不存在这样的键，则返回 null。
NavigableSet	navigableKeySe() 返回此映射中所包含键的 NavigableSet 视图。
Map.Entry	pollFirstEntry() 移除并返回与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 null。
Map.Entry	pollLastEntry() 移除并返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 null。
NavigableMap	subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) 返回此映射的部分视图，其键的范围从 fromKey 到 toKey。
SortedMap	subMap(K fromKey, K toKey) 返回此映射的部分视图，其键值的范围从 fromKey（包括）到 toKey（不包括）。
SortedMap	tailMap(K fromKey) 返回此映射的部分视图，其键大于等于 fromKey。
NavigableMap	tailMap(K fromKey, boolean inclusive) 返回此映射的部分视图，其键大于（或等于，如果 inclusive 为 true）fromKey。

HashTable

public class **Hashtable **extends Dictionary implements Map, Cloneable, Serializable

概述

此类实现一个哈希表，该哈希表将键映射到相应的值。

为了成功地在哈希表中存储和获取对象，用作键的对象必须实现 hashCode 方法和 equals 方法。

Hashtable 的实例有两个参数影响其性能：初始容量 和加载因子。容量 是哈希表中桶 的数量，初始容量 就是哈希表创建时的容量。注意，哈希表的状态为 open：在发生“哈希冲突”的情况下，单个桶会存储多个条目，这些条目必须按顺序搜索。加载因子 是对哈希表在其容量自动增加之前可以达到多满的一个尺度。初始容量和加载因子这两个参数只是对该实现的提示。关于何时以及是否调用 rehash 方法的具体细节则依赖于该实现。

特点

• 底层数据结构：数组+链表
• null值：key、value不能为null
• key重复性:key不能重复
• 不能保证插入有序
• Hashtable支持Iterator和Enumeration两种遍历方式

常用方法

Hashtable() 用默认的初始容量 (11) 和加载因子 (0.75) 构造一个新的空哈希表。
Hashtable(int initialCapacity) 用指定初始容量和默认的加载因子 (0.75) 构造一个新的空哈希表。
Hashtable(int initialCapacity, float loadFactor) 用指定初始容量和指定加载因子构造一个新的空哈希表。
Hashtable(Map t) 构造一个与给定的 Map 具有相同映射关系的新哈希表。

Properties

public class **Properties** extends Hashtable

概述

Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。

一个属性列表可包含另一个属性列表作为它的“默认值”；如果未能在原有的属性列表中搜索到属性键，则搜索第二个属性列表。

因为 Properties 继承于 Hashtable，所以可对 Properties 对象应用 put 和 putAll 方法。但不建议使用这两个方法，因为它们允许调用者插入其键或值不是 String 的项。相反，应该使用 setProperty 方法。如果在“不安全”的 Properties 对象（即包含非 String 的键或值）上调用 store 或 save 方法，则该调用将失败。类似地，如果在“不安全”的 Properties 对象（即包含非 String 的键）上调用 propertyNames 或 list 方法，则该调用将失败。

load(Reader) / [store(Writer, String)](…/…/java/util/Properties.html#store(java.io.Writer, java.lang.String)) 方法按下面所指定的、简单的面向行的格式在基于字符的流中加载和存储属性。除了输入/输出流使用 ISO 8859-1 字符编码外，load(InputStream) / [store(OutputStream, String)](…/…/java/util/Properties.html#store(java.io.OutputStream, java.lang.String)) 方法与 load(Reader)/store(Writer, String) 对的工作方式完全相同。可以使用 Unicode 转义来编写此编码中无法直接表示的字符；转义序列中只允许单个 ‘u’ 字符。可使用 native2ascii 工具对属性文件和其他字符编码进行相互转换。

loadFromXML(InputStream) 和 [storeToXML(OutputStream, String, String)](…/…/java/util/Properties.html#storeToXML(java.io.OutputStream, java.lang.String, java.lang.String)) 方法按简单的 XML 格式加载和存储属性。默认使用 UTF-8 字符编码，

特点

Java中有个比较重要的类Properties（Java.util.Properties），主要用于读取Java的配置文件，各种语言都有自己所支持的配置文件，配置文件中很多变量是经常改变的，这样做也是为了方便用户，让用户能够脱离程序本身去修改相关的变量设置。

在Java中，其配置文件常为.properties文件，格式为文本文件，文件的内容的格式是“键=值”的格式，文本注释信息可以用"#"来注释。

示例： InputStream in = JProperties.class.getResourceAsStream(name);
Properties p = new Properties();
p.load(in);

使用class.getClassLoader()所得到的java.lang.ClassLoader的getResourceAsStream()方法
示例： InputStream in = JProperties.class.getClassLoader().getResourceAsStream(name);
Properties p = new Properties();
p.load(in);

常用方法

Properties() 创建一个无默认值的空属性列表。
Properties(Properties defaults) 创建一个带有指定默认值的空属性列表。

方法摘要
String	getProperty(String key) 用指定的键在此属性列表中搜索属性。
String	getProperty(String key, String defaultValue) 用指定的键在属性列表中搜索属性。
void	list(PrintStream out) 将属性列表输出到指定的输出流。
void	list(PrintWriter out) 将属性列表输出到指定的输出流。
void	load(InputStream inStream) 从输入流中读取属性列表（键和元素对）。
void	load(Reader reader) 按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。
void	loadFromXML(InputStream in) 将指定输入流中由 XML 文档所表示的所有属性加载到此属性表中。
Enumeration	propertyNames() 返回属性列表中所有键的枚举，如果在主属性列表中未找到同名的键，则包括默认属性列表中不同的键。
Object	setProperty(String key, String value) 调用 Hashtable 的方法 put。
void	store(OutputStream out, String comments) 以适合使用 load(InputStream) 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。
void	store(Writer writer, String comments) 以适合使用 load(Reader) 方法的格式，将此 Properties 表中的属性列表（键和元素对）写入输出字符。
void	storeToXML(OutputStream os, String comment) 发出一个表示此表中包含的所有属性的 XML 文档。
void	storeToXML(OutputStream os, String comment, String encoding) 使用指定的编码发出一个表示此表中包含的所有属性的 XML 文档。
Set	stringPropertyName() 返回此属性列表中的键集，其中该键及其对应值是字符串，如果在主属性列表中未找到同名的键，则还包括默认属性列表中不同的键。

数据结构

栈

栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。它体现了后进先出（LIFO）的特点。

Java中，Stack实现了这种特性，但是Stack也继承了Vector，所以具有线程安全线和效率低下两个特性

堆

堆是一颗完全二叉树，在这棵树中，所有父节点都满足大于等于其子节点的堆叫大根堆，所有父节点都满足小于等于其子节点的堆叫小根堆。堆虽然是一颗树，但是通常存放在一个数组中，父节点和孩子节点的父子关系通过数组下标来确定。

队列

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端进行删除操作，而在表的后端进行插入操作，亦即所谓的先进先出（FIFO）。

数组

数组是相同数据类型的元素按一定顺序排列的集合，是一块连续的内存空间。数组的优点是：get和set操作时间上都是O(1)的；缺点是：add和remove操作时间上都是O(N)的。

链表

链表是一种非连续、非顺序的结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的，链表由一系列结点组成。链表的优点是：add和remove操作时间上都是O(1)的；缺点是：get和set操作时间上都是O(N)的，而且需要额外的空间存储指向其他数据地址的项。

哈希表

散列表也叫哈希表，是根据关键键值(Keyvalue)进行访问的数据结构，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度，这个映射函数叫做散列函数。 有数组与链表组成

树

树

树（tree）是包含n（n>0）个节点的有穷集合，其中：

每个元素称为节点（node）

有一个特定的节点被称为根节点或树根（root）

除根节点之外的其余数据元素被分为m（m≥0）个互不相交的结合T1，T2，……Tm-1，其中每一个集合Ti（1<=i<=m）本身也是一棵树，被称作原树的子树（subtree）

二叉树

二叉树是一种基础而且重要的数据结构，其每个结点至多只有二棵子树，二叉树有左右子树之分，第i层至多有2^{(i-1)个结点（i从1开始）；深度为k的二叉树至多有2}(k)-1)个结点，对任何一棵二叉树，如果其终端结点数为n0，度为2的结点数为n2，则n0=n2+1。

排序树

二叉查找树，又称为是二叉排序树（Binary Sort Tree）或二叉搜索树。二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：

若左子树不空，则左子树上所有结点的值均小于它的根结点的值；

若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值；

左、右子树也分别为二叉排序树；

平衡树

平衡二叉树又被称为AVL树，具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。它的出现就是解决二叉查找树不平衡导致查找效率退化为线性的问题，因为在删除和插入之时会维护树的平衡，使得查找时间保持在O(logn)，比二叉查找树更稳定。

红黑树

①、节点都有颜色；

②、在插入和删除的过程中，要遵循保持这些颜色的不同排列规则。

第一个很好理解，在红-黑树中，每个节点的颜色或者是黑色或者是红色的。当然也可以是任意别的两种颜色，这里的颜色用于标记，我们可以在节点类Node中增加一个boolean型变量isRed，以此来表示颜色的信息。

第二点，在插入或者删除一个节点时，必须要遵守的规则称为红-黑规则：

1.每个节点不是红色就是黑色的；

2.根节点总是黑色的；

3.如果节点是红色的，则它的子节点必须是黑色的（反之不一定）,(也就是从每个叶子到根的所有路径上不能有两个连续的红色节点)；

4.从根节点到叶节点或空子节点的每条路径，必须包含相同数目的黑色节点（即相同的黑色高度）。

从根节点到叶节点的路径上的黑色节点的数目称为黑色高度，规则 4 另一种表示就是从根到叶节点路径上的黑色高度必须相同。

称为根节点或树根（root）

除根节点之外的其余数据元素被分为m（m≥0）个互不相交的结合T1，T2，……Tm-1，其中每一个集合Ti（1<=i<=m）本身也是一棵树，被称作原树的子树（subtree）

二叉树

二叉树是一种基础而且重要的数据结构，其每个结点至多只有二棵子树，二叉树有左右子树之分，第i层至多有2^{(i-1)个结点（i从1开始）；深度为k的二叉树至多有2}(k)-1)个结点，对任何一棵二叉树，如果其终端结点数为n0，度为2的结点数为n2，则n0=n2+1。

排序树

二叉查找树，又称为是二叉排序树（Binary Sort Tree）或二叉搜索树。二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：

若左子树不空，则左子树上所有结点的值均小于它的根结点的值；

若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值；

左、右子树也分别为二叉排序树；

平衡树

平衡二叉树又被称为AVL树，具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。它的出现就是解决二叉查找树不平衡导致查找效率退化为线性的问题，因为在删除和插入之时会维护树的平衡，使得查找时间保持在O(logn)，比二叉查找树更稳定。

红黑树

①、节点都有颜色；

②、在插入和删除的过程中，要遵循保持这些颜色的不同排列规则。

第一个很好理解，在红-黑树中，每个节点的颜色或者是黑色或者是红色的。当然也可以是任意别的两种颜色，这里的颜色用于标记，我们可以在节点类Node中增加一个boolean型变量isRed，以此来表示颜色的信息。

第二点，在插入或者删除一个节点时，必须要遵守的规则称为红-黑规则：

1.每个节点不是红色就是黑色的；

2.根节点总是黑色的；

3.如果节点是红色的，则它的子节点必须是黑色的（反之不一定）,(也就是从每个叶子到根的所有路径上不能有两个连续的红色节点)；

4.从根节点到叶节点或空子节点的每条路径，必须包含相同数目的黑色节点（即相同的黑色高度）。

从根节点到叶节点的路径上的黑色节点的数目称为黑色高度，规则 4 另一种表示就是从根到叶节点路径上的黑色高度必须相同。

注意：新插入的节点颜色总是红色的，这是因为插入一个红色节点比插入一个黑色节点违背红-黑规则的可能性更小，原因是插入黑色节点总会改变黑色高度（违背规则4），但是插入红色节点只有一半的机会会违背规则3（因为父节点是黑色的没事，父节点是红色的就违背规则3）。