第11部分_集合框架

摘要：如果此对其迭代器返回的元素顺序做出了某些保证，那么此方法必须以相同的顺序返回这些元素。返回如果迭代器仍具有多个元素，则返回。方法功能从迭代器指向的中移除迭代器返回的最后一个元素可选操作。

Java是一门面向对象的语言，就免不了处理对象

为了方便操作多个对象，那么我们就得把这多个对象存储起来

想要存储多个对象(变量),很容易就能想到一个容器

常用的容器我们知道有StringBuffered,数组(虽然有对象数组，但是数组的长度是不可变的)

所以，Java就为我们提供了集合(Collection)

数组的长度是固定的
集合的长度是可变的

数组可以存储基本数据类型，也可以存储引用数据类型
集合只能存储引用数据类型，存储基本数据类型会自动装箱

数组里面只能存储同一数据类型的数据
集合可以存储不同数据类型的数据

public interface Collection extends Iterable

Collection是层次结构的根接口。

Collection是单列集合。

Collection表示一组对象，这些对象也称为collection的元素。

一些collection允许有重复的元素，而另一些则不允许。

一些collection是有序的，而另一些则是无序的。

JDK不提供此接口的任何直接实现，但是它提供更具体的子接口，如Set和List等等。

方法：
    * boolean add(E e)
简述：
    * 添加一个元素。
功能：
    * 确保此collection包含指定的元素（可选操作）。
    * 如果此collection由于调用而发生更改，则返回true。
      如果此collection不允许有重复元素，并且已经包含了指定的元素，则返回false。
    * 支持此操作的collection可以限制哪些元素能添加到此collection中来。
      需要特别指出的是，一些collection拒绝添加null元素，其他一些collection将对可以添加的元素类型强加限制。Collection类在其文档中清楚地指定了其添加元素方面的限制。
    * 如果collection由于某些原因（已经包含该元素的原因除外）拒绝添加特定的元素，那么它必须抛出一个异常而不是返回false。这确保了在此调用返回后，collection总是包含指定的元素。 
参数：
    * e-确定此collection中是否存在的元素。 
返回：
    * 如果此collection由于调用而发生更改，则返回true
抛出： 
    * UnsupportedOperationException-如果此collection不支持add操作 
    * ClassCastException-如果指定元素的类不允许它添加到此collection中 
    * NullPointerException-如果指定的元素为null，并且此collection不允许null元素 
    * IllegalArgumentException-如果元素的某属性不允许它添加到此collection中 
    * IllegalStateException-如果由于插入限制，元素不能在此时间添加

方法:
    * boolean addAll(Collection c)
简述：
    * 添加一个集合的元素
功能：   
    * 将指定collection中的所有元素都添加到此collection中（可选操作）。
    * 如果在进行此操作的同时修改指定的collection，那么此操作行为是不确定的。
      这意味着如果指定的collection是此collection，并且此collection为非空，那么此调用的行为是不确定的
参数：
    * c-包含要添加到此collection的collection 
返回：
    * 如果此collection由于调用而发生更改，则返回true 
抛出： 
    * UnsupportedOperationException-如果此collection不支持addAll方法 
    * ClassCastException-如果指定collection中某个元素的类不允许它添加到此collection中 
    * NullPointerException-如果指定collection包含null元素，
                           并且此collection不支持null元素，或者指定的collection为null 
    * IllegalArgumentException-如果指定collection的元素的某属性不允许它添加到此collection中 
    * IllegalStateException-如果由于插入限制，不是所有的元素都能在此时间添加

方法：
    * void clear()
简述：
    * 移除所有元素
功能：
    * 移除此collection中的所有元素（可选操作）。
    * 此方法无返回，但可抛出一个异常。 
抛出： 
    * UnsupportedOperationException-如果此collection不支持clear操作

方法：
    * boolean contains(Object o)
简述：
    * 判断集合是否包含该元素
功能：
    * 如果此collection包含指定的元素，则返回true。
    * 即当且仅当此collection至少包含一个满足(o==null ? e==null : o.equals(e))的元素e时才返回true
    * 底层使用的是equals方法，需要看情况重写equals方法。
参数：
    * o-测试在此collection中是否存在的元素。 
返回：
    * 如果此collection包含指定的元素，则返回true 
抛出： 
    * ClassCastException-如果指定元素的类型与此collection不兼容（可选）。 
    * NullPointerException-如果指定的元素为null，并且此collection不允许null元素（可选）。

方法：
    * boolean containsAll(Collection c)
简述：
    * 判断集合中是否包含指定的集合元素，只有包含所有的元素，才叫包含
功能：
    * 如果此collection包含指定collection中的所有元素，则返回true。
参数：
    * c-将检查是否包含在此collection中的collection 
返回：
    * 如果此collection包含指定collection中的所有元素，则返回true。
抛出： 
    * ClassCastException-如果指定collection中有一个或多个元素的类型与此collection不兼容（可选） 
    * NullPointerException-如果指定collection包含一个或多个null元素，并且此collection不允许null 元素（可选），或者指定的collection为null。

方法：
    * boolean equals(Object o)
功能：
    * 比较此collection与指定对象是否相等。 
覆盖：
    * 类Object中的equals()
参数：
    * o-要与此collection进行相等性比较的对象。 
返回：
    * 如果指定对象与此collection相等，则返回true。

方法：
    * int hashCode()
功能：
    * 返回此collection的哈希码值。
覆盖：
    * 类Object中的hashCode()
返回：
    * 此collection的哈希码值。

方法：
    * boolean isEmpty()
功能：
    * 如果此collection不包含元素，则返回true。 
返回：
    * 如果此collection不包含元素，则返回true

方法：
    * Iterator iterator()
功能：
    * 返回在此collection的元素上进行迭代的迭代器。
    * 关于元素返回的顺序没有任何保证（除非此collection是某个能提供保证顺序的类实例）。 
来源：
    * 接口Iterable中的iterator方法。
返回：
    * 在此collection的元素上进行迭代的Iterator

方法：
    * boolean remove(Object o)
功能：
    * 从此collection中移除指定元素的单个实例，如果存在的话（可选操作），即移除一个元素。
    * 即如果此collection包含一个或多个满足(o==null ? e==null : o.equals(e))的元素e，
      则移除这样的元素。
    * 如果此collection包含指定的元素（或者此collection由于调用而发生更改），则返回true。 
    * 底层使用的是equals方法，需要看情况重写equals方法。
参数：
    * o-要从此 collection中移除的元素（如果存在）。 
返回：
    * 如果此调用将移除一个元素，则返回true 
抛出： 
    * ClassCastException-如果指定元素的类型与此collection不兼容（可选） 
    * NullPointerException-如果指定的元素为null，并且此collection不允许null元素（可选）。 
    * UnsupportedOperationException-如果此collection不支持remove操作

方法：
    * boolean removeAll(Collection c)
简述：
    * 即移除一个集合的元素，只要有一个元素移除了，就返回true
功能：
    * 移除此collection中那些也包含在指定collection中的所有元素（可选操作）
      此调用返回后，collection中将不包含任何与指定collection相同的元素。 
参数：
    * c-要从此collection移除的元素的collection 
返回：
    * 如果此collection由于调用而发生更改，则返回true 
抛出： 
    * UnsupportedOperationException-如果此collection不支持removeAll方法 
    * ClassCastException-如果此collection中一个或多个元素的类型与指定collection不兼容（可选） 
    * NullPointerException-如果此collection包含一个或多个null元素，并且指定的collection不支持null元素（可选），或者指定的collection为null

方法：
    * boolean retainAll(Collection c)
简述
    * 移除此collection中未包含在指定collection中的所有元素，集合A和集合B做交集，最终的结果保存在集合A，返回值表示的是A是否发生过变化。
功能：
    * 仅保留此collection中那些也包含在指定collection的元素（可选操作）
      即移除此collection中未包含在指定collection中的所有元素。 
参数：
    * c-包含保留在此 collection 中的元素的 collection 
返回：
    * 如果此 collection 由于调用而发生更改，则返回 true 
抛出： 
    * UnsupportedOperationException-如果此collection不支持 retainAll 操作 
    * ClassCastException-如果此collection 中一个或多个元素的类型与指定 collection 不兼容（可选） 
    * NullPointerException-如果此collection包含一个或多个null元素，并且指定的collection不允许null元素（可选），或者指定的collection为null

方法：
    * int size()
功能：
    * 返回此collection中的元素数。
    * 如果此collection包含的元素大于Integer.MAX_VALUE，则返回Integer.MAX_VALUE。 
返回：
    * 此collection中的元素数。

方法：
    * Object[] toArray()
功能：
    * 返回包含此collection中所有元素的数组。
    * 如果collection对其迭代器返回的元素顺序做出了某些保证，那么此方法必须以相同的顺序返回这些元素。 
    * 返回的数组将是“安全的”，因为此collection并不维护对返回数组的任何引用。
      换句话说，即使 collection 受到数组的支持，此方法也必须分配一个新的数组。
      因此，调用者可以随意修改返回的数组。 
    * 此方法充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。 
返回：
    * 包含此 collection 中所有元素的数组

方法：
    *  T[] toArray(T[] a)
功能：
    * 返回包含此collection中所有元素的数组。
    * 返回数组的运行时类型与指定数组的运行时类型相同。
    * 如果指定的数组能容纳该collection，则返回包含此collection元素的数组。否则，将分配一个具有指定数组的运行时类型和此collection大小的新数组。 
    * 如果指定的数组能容纳collection，并有剩余空间（即数组的元素比collection的元素多），那么会将数组中紧接collection尾部的元素设置为null。（调用者只有在知道此collection没有包含任何null元素时才能用此方法确定collection的长度。） 
    * 如果此collection对其迭代器返回的元素顺序做出了某些保证，那么此方法必须以相同的顺序返回这些元素。 
    * 像toArray()方法一样，此方法充当基于数组的API与基于collection的API之间的桥梁。更进一步说，此方法允许对输出数组的运行时类型进行精确控制，并且在某些情况下，可以用来节省分配开销。 
    * 假定x是只包含字符串的一个已知collection。
      以下代码用来将collection转储到一个新分配的String数组： 
      String[] y = x.toArray(new String[0]); 
      注意，toArray(new Object[0])和toArray()在功能上是相同的。 
参数：
    * a-存储此collection元素的数组（如果其足够大）；否则，将为此分配一个具有相同运行时类型的新数组。 
返回：
    * 包含此 collection 中所有元素的数组 
抛出： 
    * ArrayStoreException-如果指定数组的运行时类型不是此collection每个元素运行时类型的超类型 
    * NullPointerException-如果指定的数组为null

public interface Iterator

对collection进行迭代的迭代器

依赖于集合而存在

具体实现是以内部类的方式实现的

方法：
    * boolean hasNext()
功能：
    * 如果仍有元素可以迭代，则返回true。
      换句话说，如果next返回了元素而不是抛出异常，则返回true。 
返回：
    * 如果迭代器仍具有多个元素，则返回true。

方法：
    * E next()
功能：
    * 返回迭代的下一个元素。 
返回：
    * 迭代的下一个元素。 
抛出： 
    * NoSuchElementException-没有元素可以迭代。

方法：
    * void remove()
功能：
    * 从迭代器指向的collection中移除迭代器返回的最后一个元素（可选操作）。
    * 每次调用next只能调用一次此方法。
    * 如果进行迭代时用调用此方法之外的其他方式修改了该迭代器所指向的collection，则迭代器的行为是不确定的
抛出： 
    * UnsupportedOperationException-如果迭代器不支持remove操作。 
    * IllegalStateException-如果尚未调用next方法，或者在上一次调用next方法之后已经调用了remove方法

public interface List extends Collection

有序的collection（也称为序列）。

此接口的用户可以对列表中每个元素的插入位置进行精确地控制。

用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

与set不同，列表通常允许重复的元素

void add(int index,E element)在列表的指定位置插入指定元素（可选操作）。将当前处于该位置的元素（如果有的话）和所有后续元素向右移动（在其索引中加 1）。 

参数：
index - 要在其中插入指定元素处的索引
element - 要插入的元素 
抛出： 
UnsupportedOperationException - 如果列表不支持 add 操作 
ClassCastException - 如果指定元素的类不允许它添加到此列表 
NullPointerException - 如果指定的元素为 null，并且此列表不允许 null 元素 
IllegalArgumentException - 如果指定元素的某些属性不允许它添加到此列表 
IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())

boolean addAll(Collection c)添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序（可选操作）。如果在操作正在进行中修改了指定的 collection，那么此操作的行为是不确定的（注意，如果指定的 collection 是此列表，并且它是非空的，则会发生这种情况。） 

指定者：
接口 Collection 中的 addAll
参数：
c - 包含要添加到此列表的元素的 collection 
返回：
如果此列表由于调用而发生更改，则返回 true 
抛出： 
UnsupportedOperationException - 如果列表不支持 addAll 操作 
ClassCastException - 如果指定 collection 的元素的类不允许它添加到此列表 
NullPointerException - 如果指定的 collection 包含一个或多个 null 元素，并且该列表不允许 null 元素，或者指定的 collection 为 null 
IllegalArgumentException - 如果指定 collection 的元素的某些属性不允许它添加此列表

方法：
    * boolean addAll(int index,Collection c)
功能：
    * 将指定collection中的所有元素都插入到列表中的指定位置（可选操作）。
    * 过程为：将当前处于该位置的元素（如果有的话）和所有后续元素向右移动（增加其索引）。
    * 新元素将按照它们通过指定collection的迭代器所返回的顺序出现在此列表中。
    * 如果在操作正在进行中修改了指定的collection，那么该操作的行为是不确定的
      注意，如果指定的collection是此列表，并且它是非空的，则会发生这种情况。
参数：
    * index-将指定collection的第一个元素所插入位置的索引
    * c-包含要添加到此列表的元素的 collection 
返回：
    * 如果此列表由于调用而发生更改，则返回true 
抛出： 
    * UnsupportedOperationException-如果列表不支持addAll操作 
    * ClassCastException-如果指定collection中某个元素的类不允许它添加到此列表 
    * NullPointerException-如果指定的collection包含一个或多个null元素，并且该列表不允许null元素，或者指定的collection为null 
    * IllegalArgumentException-如果指定 collection 的元素的某些属性不允许它添加到此列表 
    * IndexOutOfBoundsException-如果索引超出范围 (index < 0 || index > size())

E remove(int index)移除列表中指定位置的元素（可选操作）。将所有的后续元素向左移动（将其索引减 1）。返回从列表中移除的元素。 

参数：
index - 要移除的元素的索引 
返回：
以前在指定位置的元素 
抛出： 
UnsupportedOperationException - 如果列表不支持 remove 操作 
IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())

方法：
    * boolean remove(Object o)
功能：
    * 从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。
    * 如果列表不包含元素，则不更改列表。
    * 即移除满足(o==null ? get(i)==null : o.equals(get(i)))的最低索引i的元素
     （如果存在这样的元素）。
    * 如果此列表已包含指定元素（或者此列表由于调用而发生更改），则返回true。 
指定者：
    * Collection接口中的remove方法。
参数：
    * o 要从该列表中移除的元素，如果存在的话 
返回：
    * 如果列表包含指定的元素，则返回true 
抛出： 
    * ClassCastException-如果指定元素的类型和此列表不兼容（可选） 
    * NullPointerException-如果指定的元素是null，并且此列表不允许null元素（可选） 
    * UnsupportedOperationException-如果列表不支持remove 操作

E set(int index,
      E element)用指定元素替换列表中指定位置的元素（可选操作）。 

参数：
index - 要替换的元素的索引
element - 要在指定位置存储的元素 
返回：
以前在指定位置的元素 
抛出： 
UnsupportedOperationException - 如果列表不支持 set 操作 
ClassCastException - 如果指定元素的类不允许它添加到此列表 
NullPointerException - 如果指定的元素为 null，并且此列表不允许 null 元素 
IllegalArgumentException - 如果指定元素的某些属性不允许它添加到此列表 
IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())

E get(int index)返回列表中指定位置的元素。 

参数：
index - 要返回的元素的索引 
返回：
列表中指定位置的元素 
抛出： 
IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())

int indexOf(Object o)返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。更确切地讲，返回满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引 i；如果没有这样的索引，则返回 -1。 

参数：
o - 要搜索的元素 
返回：
此列表中第一次出现的指定元素的索引，如果列表不包含该元素，则返回 -1 
抛出： 
ClassCastException - 如果指定元素的类型和此列表不兼容（可选） 
NullPointerException - 如果指定的元素是 null，并且此列表不允许 null 元素（可选）

int lastIndexOf(Object o)返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。更确切地讲，返回满足 (o==null ? get(i)==null : o.equals(get(i))) 的最高索引 i；如果没有这样的索引，则返回 -1。 

参数：
o - 要搜索的元素 
返回：
列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1 
抛出： 
ClassCastException - 如果指定元素的类型和此列表不兼容（可选） 
NullPointerException - 如果指定的元素是 null，并且此列表不允许 null 元素（可选）

List subList(int fromIndex,
                int toIndex)返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。（如果 fromIndex 和 toIndex 相等，则返回的列表为空）。返回的列表由此列表支持，因此返回列表中的非结构性更改将反映在此列表中，反之亦然。返回的列表支持此列表支持的所有可选列表操作。
此方法省去了显式范围操作（此操作通常针对数组存在）。通过传递 subList 视图而非整个列表，期望列表的任何操作可用作范围操作。例如，下面的语句从列表中移除了元素的范围： 

            list.subList(from, to).clear();
 可以对 indexOf 和 lastIndexOf 构造类似的语句，而且 Collections 类中的所有算法都可以应用于 subList。
如果支持列表（即此列表）通过任何其他方式（而不是通过返回的列表）从结构上修改，则此方法返回的列表语义将变为未定义（从结构上修改是指更改列表的大小，或者以其他方式打乱列表，使正在进行的迭代产生错误的结果）。 


参数：
fromIndex - subList 的低端（包括）
toIndex - subList 的高端（不包括） 
返回：
列表中指定范围的视图 
抛出： 
IndexOutOfBoundsException - 非法的端点值 (fromIndex < 0 || toIndex > size || fromIndex > toIndex)

ListIterator listIterator()返回此列表元素的列表迭代器（按适当顺序）。 

返回：
此列表元素的列表迭代器（按适当顺序）

ListIterator listIterator(int index)返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。指定的索引表示 next 的初始调用所返回的第一个元素。previous 方法的初始调用将返回索引比指定索引少 1 的元素。 

参数：
index - 从列表迭代器返回的第一个元素的索引（通过调用 next 方法） 
返回：
此列表中元素的列表迭代器（按适当顺序），从列表中的指定位置开始 
抛出： 
IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())

public interface ListIterator extends Iterator

继承了Iterator接口，是List特有的Iterator接口，拥有独特的成员方法。

List专有的迭代器，允许程序员按任一方向遍历列表、迭代期间修改列表，并获得迭代器在列表中的当前位置——避免ConcurrentModificationException-并发修改异常。

void add(E e)将指定的元素插入列表（可选操作）。该元素直接插入到 next 返回的下一个元素的前面（如果有），或者 previous 返回的下一个元素之后（如果有）；如果列表没有元素，那么新元素就成为列表中的唯一元素。新元素被插入到隐式光标前：不影响对 next 的后续调用，并且对 previous 的后续调用会返回此新元素（此调用把调用 nextIndex 或 previousIndex 所返回的值增加 1）。 

参数：
e - 要插入的元素。 
抛出： 
UnsupportedOperationException - 如果列表迭代器不支持 add 操作。 
ClassCastException - 如果指定元素的类不允许该元素添加到此列表。 
IllegalArgumentException - 如果此元素的某个方面不允许该元素添加到此列表。

boolean hasNext()以正向遍历列表时，如果列表迭代器有多个元素，则返回 true（换句话说，如果 next 返回一个元素而不是抛出异常，则返回 true）。 

指定者：
接口 Iterator 中的 hasNext
返回：
如果以正向遍历列表，列表迭代器有多个元素，则返回 true。

boolean hasPrevious()如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。（换句话说，如果 previous 返回一个元素而不是抛出异常，则返回 true）。 

返回：
如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。

E next()返回列表中的下一个元素。可以重复调用此方法来迭代此列表，或混合调用 previous 来前后移动（注意交替调用 next 和 previous 将重复返回相同的元素）。 

指定者：
接口 Iterator 中的 next
返回：
列表中的下一个元素。 
抛出： 
NoSuchElementException - 如果没有可迭代的下一个元素。

int nextIndex()返回对 next 的后续调用所返回元素的索引。（如果列表迭代器在列表的结尾，则返回列表的大小）。 

返回：
对 next 的后续调用所返回元素的索引，如果列表迭代器在列表的结尾，则返回列表大小。

E previous()返回列表中的前一个元素。可以重复调用此方法来迭代列表，或混合调用 next 来前后移动（注意交替调用 next 和 previous 将重复返回相同的元素）。 

返回：
列表中的上一个元素。 
抛出： 
NoSuchElementException - 如果没有可迭代的上一个元素。

int previousIndex()返回对 previous 的后续调用所返回元素的索引。（如果列表迭代器在列表的开始，则返回 -1）。 

返回：
对 previous 的后续调用所返回元素的索引，如果列表迭代器在列表的开始，则返回 -1。

void remove()从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。对于每个 next 或 previous 调用，只能执行一次此调用。只有在最后一次调用 next 或 previous 之后，尚未调用 ListIterator.add 时才可以执行该调用。 

指定者：
接口 Iterator 中的 remove
抛出： 
UnsupportedOperationException - 如果列表迭代器不支持 remove 操作。 
IllegalStateException - 既没有调用 next 也没有调用 previous，或者在最后一次调用 next 或 previous 后调用了 remove 或 add。

void set(E e)用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。只有在最后一次调用 next 或 previous 后既没有调用 ListIterator.remove 也没有调用 ListIterator.add 时才可以进行该调用。 

参数：
e - 用于替换 next 或 previous 返回的最后一个元素的元素。 
抛出： 
UnsupportedOperationException - 如果列表迭代器不支持 set 操作。 
ClassCastException - 如果指定元素的类不允许该元素添加到此列表。 
IllegalArgumentException - 如果指定元素的某个方面不允许该元素添加到此列表。 
IllegalStateException - 如果既没有调用 next 也没有调用 previous，或者在最后一次调用 next 或 previous 后调用了 remove 或 add。

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

底层数据结构是数组，查询快，增删慢

线程不安全，效率高

使用ArrayList类的contains方法判断是否包含，底层调用的是equals方法，需要考虑是否重写equals方法。

使用ArrayList类的remove方法删除元素，底层调用的是equals方法，需要考虑是否重写equals方法。

方法：
    * public ArrayList()
功能：
    * 构造一个初始容量为10的空列表。 

方法：
    * public ArrayList(Collection c)
功能：
    * 构造一个包含指定collection的元素的列表，这些元素是按照该collection的迭代器返回它们的顺序排列的。 
参数：
    * c-其元素将放置在此列表中的collection 
抛出： 
    * NullPointerException-如果指定的collection为null

方法：
    * public ArrayList(int initialCapacity)
功能：
    * 构造一个具有指定初始容量的空列表。 
参数：
    * initialCapacity-列表的初始容量 
抛出： 
    * IllegalArgumentException-如果指定的初始容量为负

方法：
    * public Object clone()
功能：
    * 返回此ArrayList实例的浅表副本。（不复制这些元素本身。） 
覆盖：
    * Object类中的clone方法
返回：
    * 此ArrayList实例的一个副本

方法：
    * public void ensureCapacity(int minCapacity)
功能：
    * 如有必要，增加此ArrayList实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。 
参数：
    * minCapacity-所需的最小容量

方法：
    * protected void removeRange(int fromIndex,int toIndex)
方法：
    * 移除列表中索引在fromIndex（包括）和toIndex（不包括）之间的所有元素。
    * 过程：向左移动所有后续元素（减小其索引）。
    * 此调用将列表缩短了 (toIndex - fromIndex) 个元素。（如果 toIndex==fromIndex，则此操作无效。） 
覆盖：
    * AbstractList类中的removeRange方法
参数：
    * fromIndex-要移除的首个元素的索引。
    * toIndex-最后一个要移除的元素后面那个元素的索引。
抛出： 
    * IndexOutOfBoundsException-如果fromIndex或toIndex超出范围 
      (fromIndex < 0 || fromIndex >= size() || toIndex > size() || toIndex < fromIndex)

方法：
    * public void trimToSize()
功能：
    * 将此ArrayList实例的容量调整为列表的当前大小。
    * 应用程序可以使用此操作来最小化ArrayList实例的存储量。 

public class LinkedList extends AbstractSequentialList
implements List, Deque, Cloneable, Serializable

在JDK中是以双向链表实现的。

底层数据结构是链表，查询慢，增删快

线程不安全，效率高

LinkedList实现了Deque接口，因此，可以操作LinkedList像操作队列和栈一样

方法：
    * public LinkedList()
功能：
    * 构造一个空列表。 

方法：
    * public LinkedList(Collection c)
功能：
    * 构造一个包含指定collection中的元素的列表，这些元素按其collection的迭代器返回的顺序排列。 
参数：
    * c-要将其元素放入此列表的collection 
抛出： 
    * NullPointerException-如果指定的collection为null

方法：
    * public E getFirst()
功能：
    * 返回此列表的第一个元素。 
指定者：
    * 接口 Deque 中的 getFirst
返回：
    * 此列表的第一个元素 
抛出： 
    * NoSuchElementException - 如果此列表为空

方法：
    * public E getLast()
功能：
    * 返回此列表的最后一个元素。 
指定者：
    * 接口 Deque 中的 getLast
返回：
    * 此列表的最后一个元素 
抛出： 
    * NoSuchElementException - 如果此列表为空

方法：
    * public Object clone()
功能：
    * 返回此LinkedList的浅表副本。（这些元素本身没有复制。） 
覆盖：
    * 类Object中的clone。
返回：
    * 此LinkedList实例的浅表副本。

方法：
    * public E getFirst()
功能：
    * 返回此列表的第一个元素。 
指定者：
    * Deque接口中的getFirst方法
返回：
    * 此列表的第一个元素 
抛出： 
    * NoSuchElementException - 如果此列表为空

方法：
    * public E getLast()
功能：
    * 返回此列表的最后一个元素。 
指定者：
    * 接口 Deque 中的 getLast
返回：
    * 此列表的最后一个元素 
抛出： 
    * NoSuchElementException - 如果此列表为空

public E remove()获取并移除此列表的头（第一个元素）。 

指定者：
接口 Deque 中的 remove
指定者：
接口 Queue 中的 remove
返回：
列表的头 
抛出： 
NoSuchElementException - 如果此列表为空

方法：
    * public E removeFirst()
功能：
    * 移除并返回此列表的第一个元素。 
指定者：
    * 接口 Deque 中的 removeFirst
返回：
    * 此列表的第一个元素 
抛出： 
    * NoSuchElementException - 如果此列表为空

方法：
    * public E removeLast()
功能：
    * 移除并返回此列表的最后一个元素。 
指定者：
    * Deque接口中的removeLast方法
返回：
    * 此列表的最后一个元素 
抛出： 
    * NoSuchElementException - 如果此列表为空

public boolean removeFirstOccurrence(Object o)从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。如果列表不包含该元素，则不作更改。 

指定者：
接口 Deque 中的 removeFirstOccurrence
参数：
o - 要从此列表中移除的元素（如果存在） 
返回：
如果该列表已包含指定元素，则返回 true

public boolean removeLastOccurrence(Object o)从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。如果列表不包含该元素，则不作更改。 

指定者：
接口 Deque 中的 removeLastOccurrence
参数：
o - 要从此列表中移除的元素（如果存在） 
返回：
如果该列表已包含指定元素，则返回 true

public Iterator descendingIterator()从接口 Deque 复制的描述 
返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。元素将按从最后一个（尾部）到第一个（头部）的顺序返回。 

指定者：
接口 Deque 中的 descendingIterator
返回：
以逆向顺序在此双端队列中的元素上进行迭代的迭代器

public E element()获取但不移除此列表的头（第一个元素）。 

指定者：
接口 Deque 中的 element
指定者：
接口 Queue 中的 element
返回：
列表的头 
抛出： 
NoSuchElementException - 如果此列表为空

public boolean offer(E e)将指定元素添加到此列表的末尾（最后一个元素）。 

指定者：
接口 Deque 中的 offer
指定者：
接口 Queue 中的 offer
参数：
e - 要添加的元素 
返回：
true（根据 Queue.offer(E) 的规定）

public boolean offerFirst(E e)在此列表的开头插入指定的元素。 

指定者：
接口 Deque 中的 offerFirst
参数：
e - 要插入的元素 
返回：
true（根据 Deque.offerFirst(E) 的规定）

public boolean offerLast(E e)在此列表末尾插入指定的元素。 

指定者：
接口 Deque 中的 offerLast
参数：
e - 要插入的元素 
返回：
true（根据 Deque.offerLast(E) 的规定）

public E peek()获取但不移除此列表的头（第一个元素）。 

指定者：
接口 Deque 中的 peek
指定者：
接口 Queue 中的 peek
返回：
此列表的头，如果此列表为空，则返回 null

public E peekFirst()获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。 

指定者：
接口 Deque 中的 peekFirst
返回：
此列表的第一个元素；如果此列表为空，则返回 null

public E peekLast()获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。 

指定者：
接口 Deque 中的 peekLast
返回：
此列表的最后一个元素；如果此列表为空，则返回 null

public E poll()获取并移除此列表的头（第一个元素） 

指定者：
接口 Deque 中的 poll
指定者：
接口 Queue 中的 poll
返回：
此列表的头，如果此列表为空，则返回 null

public E pollFirst()获取并移除此列表的第一个元素；如果此列表为空，则返回 null。 

指定者：
接口 Deque 中的 pollFirst
返回：
此列表的第一个元素；如果此列表为空，则返回 null

方法：
    * public E pollLast()
功能：    
    * 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。 
指定者：
    * 接口Deque中的pollLast
返回：
    * 此列表的最后一个元素；如果此列表为空，则返回null

方法：
    * public E pop()
功能：
    * 从此列表所表示的堆栈处弹出一个元素。
    * 换句话说，移除并返回此列表的第一个元素。 
    * 此方法等效于removeFirst()。 
指定者：
    * 接口Deque中的pop方法
返回：
    * 此列表开头的元素（它是此列表所表示的堆栈的顶部） 
抛出： 
    * NoSuchElementException-如果此列表为空

方法：
    * public void push(E e)
功能：
    * 将元素推入此列表所表示的堆栈。
    * 换句话说，将该元素插入此列表的开头。 
    * 此方法等效于addFirst(E)。 
指定者：
    * 接口Deque中的push方法。
参数：
    * e-要推入的元素

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

底层数据结构是数组，查询快，增删慢

线程安全，效率低（我们也不用Vector）

字段：
    * protected int capacityIncrement
描述：
    * 向量的大小大于其容量时，容量自动增加的量。
    * 如果容量的增量小于等于零，则每次需要增大容量时，向量的容量将增大一倍。 

字段：
    * protected int elementCountVector 
描述：
    * 对象中的有效组件数。
    * 从 elementData[0] 到 elementData[elementCount-1] 的组件均为实际项。 

字段：
    * protected Object[] elementData
描述：
    * 存储向量组件的数组缓冲区。vector 的容量就是此数据缓冲区的长度，该长度至少要足以包含向量的所有元素。 
    * Vector 中的最后一个元素后的任何数组元素都为 null。 

方法：
    * public Vector()
功能：
    * 构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。 

方法：
    * public Vector(Collection c)
功能：
    * 构造一个包含指定collection中的元素的向量，这些元素按其collection的迭代器返回元素的顺序排列。     
参数：
    * c-其元素要放入此向量中的collection 
抛出： 
    * NullPointerException-如果指定的collection为null

方法：
    * public Vector(int initialCapacity)
功能：
    * 使用指定的初始容量和等于零的容量增量构造一个空向量。 
参数：
    * initialCapacity-向量的初始容量 
抛出： 
    * IllegalArgumentException-如果指定的初始容量为负数

方法：
    * public Vector(int initialCapacity,int capacityIncrement)
功能：
    * 使用指定的初始容量和容量增量构造一个空的向量。 
参数：
    * initialCapacity-向量的初始容量
    * capacityIncrement-当向量溢出时容量增加的量 
抛出： 
    * IllegalArgumentException-如果指定的初始容量为负数

public interface Set extends Collection

一个不包含重复元素的collection

public class HashSet extends AbstractSet
implements Set, Cloneable, Serializable

不保证set的迭代顺序，特别是它不保证该顺序恒久不变

无索引

底层数据结构是哈希表(元素为链表的数组)

哈希表依赖于哈希值存储

int hashCode()

boolean equals(Object obj)

先使用hashCode方法，再使用equals方法。即若hashCode方法返回的结果相同再使用equals方法。

public class LinkedHashSet extends HashSet
implements Set, Cloneable, Serializable

元素有序唯一

由链表保证元素有序

由哈希表保证元素唯一

底层数据结构由哈希表和链表组成。

public class TreeSetextends AbstractSet
implements NavigableSet, Cloneable, Serializable

使用元素的自然顺序对元素进行排序

或者根据创建set时提供的Comparator进行排序

具体取决于使用的构造方法。

底层数据结构是红黑树(红黑树是一种自平衡的二叉树)

保证元素的排序方式

方法：
    * public TreeSet()
功能：
    * 构造一个新的空set，该set根据其元素的自然顺序进行排序。
    * 插入该set的所有元素都必须实现Comparable接口。
    * 所有这些元素都必须是可互相比较的：对于set中的任意两个元素e1和e2，执行e1.compareTo(e2)都不得抛出 ClassCastException。
    * 如果用户试图将违反此约束的元素添加到set（例如，用户试图将字符串元素添加到其元素为整数的 set 中），则add调用将抛出ClassCastException。 

方法：
    * public TreeSet(Collection c)
功能：
    * 构造一个包含指定collection元素的新TreeSet，它按照其元素的自然顺序进行排序。
    * 插入该set的所有元素都必须实现Comparable接口。
    * 另外，所有这些元素都必须是可互相比较的：对于set中的任意两个元素 e1和e2，执行e1.compareTo(e2)都不得抛出ClassCastException。 
参数：
    * c-一个collection，其元素将组成新的set 
抛出： 
    * ClassCastException-如果c中的元素不是Comparable，或者是不可相互比较的 
    * NullPointerException-如果指定collection为null

方法：
    * public TreeSet(Comparator comparator)
功能：
    * 构造一个新的空 TreeSet，它根据指定比较器进行排序。
    * 插入到该set的所有元素都必须能够由指定比较器进行相互比较：对于set中的任意两个元素e1和e2，执行comparator.compare(e1, e2)都不得抛出ClassCastException。
    * 如果用户试图将违反此约束的元素添加到set中，则add调用将抛出ClassCastException。 
参数：
    * comparator-将用来对此set进行排序的比较器。如果该参数为null，则使用元素的自然顺序。

方法：
    * public TreeSet(SortedSet s)
功能：
    * 构造一个与指定有序set具有相同映射关系和相同排序的新TreeSet。 
参数：
    * s-一个有序set，其元素将组成新set 
抛出： 
    * NullPointerException-如果指定有序set为null

public interface Map

Map是双列集合。

方法：
    * void clear()
功能：
    * 从此映射中移除所有映射关系（可选操作）。
    * 此调用返回后，该映射将为空。 
抛出： 
    * UnsupportedOperationException-如果此映射不支持clear操作。

方法：
    * boolean containsKey(Object key)
功能：
    * 如果此映射包含指定键的映射关系，则返回true。
    * 即当且仅当此映射包含针对满足 (key==null ? k==null : key.equals(k)) 的键k的映射关系时，返回 true，且最多只能有一个这样的映射关系。 
参数：
    * key-测试是否存在于此映射中的键 
返回：
    * 如果此映射包含指定键的映射关系，则返回true 
抛出： 
    * ClassCastException-如果该键对于此映射是不合适的类型（可选） 
    * NullPointerException-如果指定键为null并且此映射不允许null键（可选）

方法：
    * boolean containsValue(Object value)
功能：
    * 如果此映射将一个或多个键映射到指定值，则返回true。
    * 即当且仅当此映射至少包含一个对满足 (value==null ? v==null : value.equals(v)) 的值v的映射关系时，返回true。
    * 对于大多数Map接口的实现而言，此操作需要的时间可能与映射大小呈线性关系。 
参数：
    * value-测试是否存在于此映射中的值 
返回：
    * 如果此映射将一个或多个键映射到指定值，则返回 true 
抛出： 
    * ClassCastException-如果该值对于此映射是不合适的类型（可选） 
    * NullPointerException-如果指定值为null并且此映射不允许null值（可选）

方法：
    * Set> entrySet()
    * 返回此映射中包含的映射关系的 Set 视图。该 set 受映射支持，所以对映射的更改可在此 set 中反映出来，反之亦然。如果对该 set 进行迭代的同时修改了映射（通过迭代器自己的 remove 操作，或者通过对迭代器返回的映射项执行 setValue 操作除外），则迭代结果是不确定的。set 支持元素移除，通过 Iterator.remove、Set.remove、removeAll、retainAll 和 clear 操作可从映射中移除相应的映射关系。它不支持 add 或 addAll 操作。 

返回：
    * 此映射中包含的映射关系的 set 视图

方法：
    * boolean equals(Object o)比较指定的对象与此映射是否相等。如果给定的对象也是一个映射，并且这两个映射表示相同的映射关系，则返回 true。更确切地讲，如果 m1.entrySet().equals(m2.entrySet())，则两个映射 m1 和 m2 表示相同的映射关系。这可以确保 equals 方法在不同的 Map 接口实现间运行正常。 

覆盖：
    * 类 Object 中的 equals
参数：
    * o - 要与此映射进行相等性比较的对象 
返回：
    * 如果指定的对象等于此映射，则返回 true

V get(Object key)返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。 
更确切地讲，如果此映射包含满足 (key==null ? k==null : key.equals(k)) 的键 k 到值 v 的映射关系，则此方法返回 v；否则返回 null。（最多只能有一个这样的映射关系）。 

如果此映射允许 null 值，则返回 null 值并不一定 表示该映射不包含该键的映射关系；也可能该映射将该键显示地映射到 null。使用 containsKey 操作可区分这两种情况。 


参数：
key - 要返回其关联值的键 
返回：
指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null 
抛出： 
ClassCastException - 如果该键对于此映射是不合适的类型（可选） 
NullPointerException - 如果指定键为 null 并且此映射不允许 null 键（可选）

方法：
    * int hashCode()
功能：
    * 返回此映射的哈希码值。
    * 映射的哈希码定义为此映射entrySet()视图中每个项的哈希码之和。这确保 m1.equals(m2) 对于任意两个映射 m1 和 m2 而言，都意味着 m1.hashCode()==m2.hashCode()，正如 Object.hashCode() 常规协定的要求。 

覆盖：
    * Object类中的hashCode方法。
返回：
    * 此映射的哈希码值。

方法：
    * boolean isEmpty()
功能：
    * 如果此映射未包含键-值映射关系，则返回true。 
返回：
    * 如果此映射未包含键-值映射关系，则返回true。

Set keySet()返回此映射中包含的键的 Set 视图。该 set 受映射支持，所以对映射的更改可在此 set 中反映出来，反之亦然。如果对该 set 进行迭代的同时修改了映射（通过迭代器自己的 remove 操作除外），则迭代结果是不确定的。set 支持元素移除，通过 Iterator.remove、Set.remove、removeAll、retainAll 和 clear 操作可从映射中移除相应的映射关系。它不支持 add 或 addAll 操作。 

返回：
此映射中包含的键的 set 视图

V put(K key,V value)将指定的值与此映射中的指定键关联（可选操作）。如果此映射以前包含一个该键的映射关系，则用指定值替换旧值（当且仅当 m.containsKey(k) 返回 true 时，才能说映射 m 包含键 k 的映射关系）。 

参数：
key - 与指定值关联的键
value - 与指定键关联的值 
返回：
以前与 key 关联的值，如果没有针对 key 的映射关系，则返回 null。（如果该实现支持 null 值，则返回 null 也可能表示此映射以前将 null 与 key 关联）。 
抛出： 
UnsupportedOperationException - 如果此映射不支持 put 操作 
ClassCastException - 如果指定键或值的类不允许将其存储在此映射中 
NullPointerException - 如果指定键或值为 null，并且此映射不允许 null 键或值 
IllegalArgumentException - 如果指定键或值的某些属性不允许将其存储在此映射中

void putAll(Map m)从指定映射中将所有映射关系复制到此映射中（可选操作）。对于指定映射中的每个键 k 到值 v 的映射关系，此调用等效于对此映射调用一次 put(k, v)。如果正在进行此操作的同时修改了指定的映射，则此操作的行为是不确定的。 

参数：
m - 要存储在此映射中的映射关系 
抛出： 
UnsupportedOperationException - 如果此映射不支持 putAll 操作 
ClassCastException - 如果指定映射中的键或值的类不允许将其存储在此映射中 
NullPointerException - 如果指定映射为 null，或者此映射不允许 null 键或值，并且指定的映射包含 null 键或值 
IllegalArgumentException - 如果指定映射中的键或值的某些属性不允许将其存储在此映射中

方法：
    * V remove(Object key)
功能：
    * 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。更确切地讲，如果此映射包含从满足 (key==null ? k==null :key.equals(k)) 的键 k 到值 v 的映射关系，则移除该映射关系。（该映射最多只能包含一个这样的映射关系。） 
返回此映射中以前关联该键的值，如果此映射不包含该键的映射关系，则返回 null。 

如果此映射允许 null 值，则返回 null 值并不一定 表示该映射不包含该键的映射关系；也可能该映射将该键显示地映射到 null。 

调用返回后，此映射将不再包含指定键的映射关系。 


参数：
key - 从映射中移除其映射关系的键 
返回：
以前与 key 关联的值；如果没有 key 的映射关系，则返回 null。 
抛出： 
UnsupportedOperationException - 如果此映射不支持 remove 操作 
ClassCastException - 如果该键对于此映射是不合适的类型（可选） 
NullPointerException - 如果指定键为 null 并且此映射不允许 null 键（可选）

方法：
    * int size()
功能：
    * 返回此映射中的键-值映射关系数。
    * 如果该映射包含的元素大于Integer.MAX_VALUE，则返回Integer.MAX_VALUE。 
返回：
    * 此映射中的键-值映射关系数。

方法：
    * Collection values()
功能：
    * 返回此映射中包含的值的 Collection 视图。该 collection 受映射支持，所以对映射的更改可在此 collection 中反映出来，反之亦然。如果对该 collection 进行迭代的同时修改了映射（通过迭代器自己的 remove 操作除外），则迭代结果是不确定的。collection 支持元素移除，通过 Iterator.remove、Collection.remove、removeAll、retainAll 和 clear 操作可从映射中移除相应的映射关系。它不支持 add 或 addAll 操作。 

返回：
    * 此映射中包含的值的 collection 视图

public class HashMap extends AbstractMap
implements Map, Cloneable, Serializable

public class LinkedHashMap extends HashMap
implements Map

public class TreeMap extends AbstractMap
implements NavigableMap, Cloneable, Serializable

键是红黑树结构，可以保证键的排序和唯一性

3. 集合转数组的方法 4. 集合转数组的特点

十八、增强for循环 1. 概述

简化数组和Collection集合的遍历

for(元素数据类型 变量 : 数组或者Collection集合) {
    /*使用变量即可，该变量就是元素*/
}

简化遍历

增强for的目标需要判断是否为null

普通for循环可以，但是索引要--。

迭代器可以删除，但是必须要使用迭代器自身的remove方法，不能使用集合的remove方法，否则会出现并发修改异常。

增强for循环不能删除。