集合类

    Collection 接口之List总结
 先总的看一下Collection的结构流程
 
 
 
                |—— Set-----HashSet
 Collection-----|
                |
    |
    |         |----ArrayList
    |——List---|----LinkedList
              |----Vector______Stack
  Map----Hashtable_____Properties
关于Collection：它是Collection层次结构中的跟接口。
构造方法：无
普通方法中的常用方法：
1. add(E e) ：确保此 collection 包含指定的元素（可选操作）。
2.addAll(Collection<? extends E> c)：将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
3.clear()：移除此 collection 中的所有元素（可选操作）。
4.contains(Object o)：如果此 collection 包含指定的元素，则返回 true。
5.containsAll(Collection<?> c)：如果此 collection 包含指定 collection 中的所有元素，则返回 true。
6. equals(Object o)：比较此 collection 与指定对象是否相等。
7.hashCode()：返回此 collection 的哈希码值。
8.isEmpty()：如果此 collection 不包含元素，则返回 true。
9.Iterator<E> iterator()：返回在此 collection 的元素上进行迭代的迭代器。
10.remove(Object o)：从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
11.removeAll(Collection<?> c)：移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
12. retainAll(Collection<?> c)：仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
13. size()：返回此 collection 中的元素数。
14.toArray()：返回包含此 collection 中所有元素的数组。
在Collection中的方法将被其子类接口或子类继承，子类接口或子类可以调用Collection中的方法并且它们也可以
扩展父类接口。
List接口：有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。
除了具有Collection接口的方法之外还有其独特的方法：
构造方法：无
普通方法中的常用方法：
1. add(E e)：向列表的尾部添加指定的元素（可选操作）。
2. add(int index, E element)：在列表的指定位置插入指定元素（可选操作）。
3.addAll(int index, Collection<? extends E> c)：将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
4.get(int index)：返回列表中指定位置的元素。
5.indexOf(Object o)：返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
6.lastIndexOf(Object o)：返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
7.listIterator()：返回此列表元素的列表迭代器（按适当顺序）。
8. listIterator(int index)：返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。
9. remove(int index)：移除列表中指定位置的元素（可选操作）。
10.set(int index, E element)： 用指定元素替换列表中指定位置的元素（可选操作）。
11.subList(int fromIndex, int toIndex)：返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
关于ArrayList：List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。
构造方法：
1.ArrayList()：构造一个初始容量为 10 的空列表。
2.ArrayList(Collection<? extends E> c)：构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
3.ArrayList(int initialCapacity)：构造一个具有指定初始容量的空列表。
普通方法中的常用方法：除了继承了Collection和List接口的方法外还有自己特有的方法
1.addAll(Collection<? extends E> c)：按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。
关于LinkedList：List 接口的链接列表实现。除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。
构造方法：
1.LinkedList()：构造一个空列表。
2.LinkedList(Collection<? extends E> c)：构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列。
普通方法中的常用方法：
1.addFirst(E e)：将指定元素插入此列表的开头。
2.addLast(E e)：将指定元素添加到此列表的结尾。
3.element()：获取但不移除此列表的头（第一个元素）。
4.getFirst()：返回此列表的第一个元素。
5.getLast() ：返回此列表的最后一个元素。
6.offer(E e)：将指定元素添加到此列表的末尾（最后一个元素）。
7.offerFirst(E e)：在此列表的开头插入指定的元素。
8.offerLast(E e)：在此列表末尾插入指定的元素。
9. peek()：获取但不移除此列表的头（第一个元素）。
10. peekFirst() ：获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
11.peekLast()：获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
12.poll()：获取并移除此列表的头（第一个元素）
13.pollFirst()：获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
14.pollLast()：获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
15.pop()：从此列表所表示的堆栈处弹出一个元素。
16. push(E e)：将元素推入此列表所表示的堆栈。
17.remove()：获取并移除此列表的头（第一个元素）。
18.removeFirst()：移除并返回此列表的第一个元素。
19.removeLast()：移除并返回此列表的最后一个元素。
关于Vector：Vector 类可以实现可增长的对象数组。并且，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。
构造方法：
1.Vector()：构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。
2.Vector(Collection<? extends E> c) ：构造一个包含指定 collection 中的元素的向量，这些元素按其 collection 的迭代器返回元素的顺序排列。
3.Vector(int initialCapacity)：使用指定的初始容量和等于零的容量增量构造一个空向量。
4.Vector(int initialCapacity, int capacityIncrement)：使用指定的初始容量和容量增量构造一个空的向量。
普通的常用的方法：除实现了Collection和List接口外自己还有其特有的方法
1.addElement(E obj)：将指定的组件添加到此向量的末尾，将其大小增加 1。
2.elementAt(int index)：返回指定索引处的组件。
3.firstElement()：返回此向量的第一个组件（位于索引 0) 处的项）。
4.insertElementAt(E obj, int index)：将指定对象作为此向量中的组件插入到指定的 index 处。
5.lastElement()：返回此向量的最后一个组件。
6.removeAllElements()：从此向量中移除全部组件，并将其大小设置为零。
7.removeElement(Object obj)：从此向量中移除变量的第一个（索引最小的）匹配项。
8. removeElementAt(int index) ：删除指定索引处的组件。
9.setElementAt(E obj, int index)：将此向量指定 index 处的组件设置为指定的对象。
关于Stack：Stack 类表示后进先出（LIFO）的对象堆栈。它提供了通常的 push 和 pop 操作，以及取堆栈顶点的 peek 方法、测试堆栈是否为空的 empty 方法、在堆栈中查找项并确定到堆栈顶距离的 search 方法。
构造方法：Stack()：创建一个空堆栈。
  注意：由于Stack继承了Vector类，所以以下语句从语法上来讲，不会有问题。但却破坏了堆栈“后进先出”的特性，所以，不推荐使用。
常用的普通方法：
1.empty()：测试堆栈是否为空。
2. peek()：查看堆栈顶部的对象，但不从堆栈中移除它。
3. pop()：移除堆栈顶部的对象，并作为此函数的值返回该对象。
4. push(E item)：把项压入堆栈顶部。
5.search(Object o)：返回对象在堆栈中的位置，以 1 为基数。
 实现了Set接口的类HashSet
“基于散列表”的检测重复元素的策略：HashSet里的元素值同这个元素在Set里所存放的索引位置有个对应关系（散列函数），在HashSet里插入元素前，可根据这个元素值和对应关系，
计算出这个元素在HashSet里的插入位置，如果在这个位置里（或位置周围）已经存在了待插入元素的值，则不能插入。 
  构造方法
   HashSet()
   HashSet(<E> c)
  其他方法
   boolean contains(Object o) 判断是否存在指定元素
   第一类集合有着共同的特性：它们存储的对象都是一元的（线性的），只不过存储的方式和使用的数据结构不同,以Collection为基类--封装了线性表的插入、删除等基本操作 。
List接口和Set接口都是Collection的子接口                          
      实现List接口：基于线性链表来存放数据的，例如Vector
                              
      实现Set接口：它们不允许有重复的元素，例如HashSet。

  
 在Java中，专门建立以HashTable为代表的“键-值”对类型对象，“键”--索引信息，而“值” –同索引值相对应的信息。
     为什么要使用“键-值”对型的数据结构
    原因：便于信息检索，提高在大数据量里检索信息的速度。
     (1）如果要从其中查询指定数据的话，不得不依次遍历这个数组，这样效率会很低。
    （2）换一种思路：将10存入数组不是插入在第一个空闲空间里！
      存在“索引冲突” 问题：对于散列函数，不同的“值”会得到相同的“键”，即不同的对象可能存放在同一个索引位置上。
     解决方法
     采用技术上的方法，例如设计出尽量降低冲突情况出现的散列函数，或者是指定冲突发生时的应对策略；
      根据待存储的数据量，适当提高Hash表的容量--用加大空间的代价，来取冲突发生的低概率
    “键-值”对的典范——Hashtable类 :在Java的“键-值”对型集合类里，已经封装了用散列函数优化其中数据搜索效率以及处理Hash表里数据冲突的实现细节。其中Hashtable是 “键-值”对型集合类的典范。
   构造方法
   Hashtable()
  Hashtable(int initialCapacity)
   Hashtable(int initialCapacity, float loadFactor)
  Hashtable(<K,V> t) :使用泛型指定Hash表里键和值的类型

  其它方法
   V put(K key, V value)：向Hashtable对象中插入“键-值”对
  V get(Object key)：根据key这个“键”从Hashtable对象中检索到 对应的“值”
   boolean containsKey(Object key):判断“键”是否存在于Hashtable对象中。
      boolean containsValue(Object value):判断“值” 是否存在于Hashtable中。
     public boolean contains(Object?value) 同containsValue()方法。
    public void clear():将此Hashtable清空，使其不包含任何键。
    注意：通过ht.put(new Integer(3), new Integer(27));语句，重新设置了“键”为3的“值”27。如果针对同一个“键”设置了两次“值”，生效的是最后一次的动作。
总结：
      第二类集合的共同特性就是它们存放的数据都是二元的，称其为“键-值”对，通过它们可以快速的根据一个关键字key来得到其所对应的值value，这里之所以称其为关键字就是因为它必须是唯一的，
   这样才能保证每次通过key所得到的value是固定的，即最近一次设置进去的那个值value。
枚举器与数据操作
 枚举器是一个用来访问集合元素的工具，它不仅提供了可以用来访问集合的若干方法，更展示了解决访问对象时“对象类型不确定”难题的思路。
  (1)访问集合类的“不确定性”难题
      Java中有诸多不同类型的Java集合类（比如Vector或List），程序员希望用同一类型的方式来访问其中的数据。
  (2)枚举器接口
      java.util.Iterator（枚举器接口）封装“无差别访问集合对象”的方法。
  相关方法
  在每一个集合类（比如Vector或Hashtable等）里，都有一个iterator()方法，各集合对象可以通过该方法把遍历本类的控制权交给Iterator接口。
  在Iterator的接口里，提供了boolean hasNext()方法，判断出是否可以通过枚举器来得到集合对象中的下一个元素。
  在Iterator的接口里，提供了E next()方法，用来获取集合对象里的下一个元素，它返回的是一个泛型对象。
 (3)枚举器“分离”思想
 “遍历不同种类的集合对象” 采用“分离”的设计思想；
  把遍历这个业务动作同将要实施遍历操作的对象（比如集合）分离，在这个基础上，抽象出遍历不同集合对象的共性代码，并把这些功能代码封装到枚举器这个接口里，就可以用同一套代码，来遍历不同类型的集合；
  正是由于枚举器分离了业务动作（枚举）和业务动作要操作的数据（集合），所以它才能以不变应万变。