汇合的顶层接口，不能被实例化
a) 根接口Collection
i. 罕用子接口
1. List
实现类：ArrayList、Vector、LinkedList
2. Set
实现类：HashSet、TreeSet
b) 增加性能
i. boolean add(object obj)增加一个元素
ii. boolean addAll(Collection c)将汇合c的全副元素增加到原汇合元素后返回true
iii. 增加性能永远返回true
c) 删除性能
i. void clear();移除所有元素
ii. boolean remove(Object o)移除一个元素
iii. boolean removeAll（Collection c）移除一个汇合的元素，只有有一个被移除就返回true，扭转原汇合，删除原汇合中和c中雷同的元素
iv. 删除性能只有删除胜利后才返回true
d) 判断性能
i. boolean contain(object o)判断汇合中是否蕴含指定的元素。
ii. boolean containsAll(Collection c)判断原汇合中是否蕴含指定汇合c的所有元素，有则true，
iii. boolean isEmpty()判断汇合是否为空
e) 获取性能
i. Iterator iterator()迭代器，汇合的专用形式，实现遍历的性能
ii. Object next()获取以后元素，并挪动到下一个地位
iii. boolean hasNext()判断此地位是否有元素
iv. 迭代器遍历实例在上面
f) 长度性能
i. int size()元素的个数
ii. 数组和字符串中都是length()办法获取元素个数，汇合中是size()办法
因为object包含汇合、字符串、数组，所以其不能间接用length办法。
g) 交加性能boolean retainAll(Collection c)
两个汇合交加的元素给原汇合，并判断原汇合是否扭转，扭转则true，不变则false
h) 把汇合转换为数组
i. Object [] toArray()
1、List汇合
Collection汇合的子类
特点：
a) 有序（存储和取出的元素程序统一），可反复
b) 特有性能
i. 增加性能
void add(int index,Object element)在指定地位增加元素（原索引处的元素后延）
ii. 获取性能
Object get(int index)获取指定地位的元素
iii. 列表迭代器
1. ListIterator listIterator() List汇合特有的迭代器
2. Iterator迭代器的子类，所以其能够用Iterator中的boolean hasNext()、Object next()办法
3. 特有的办法：
a) Object previous ()返回此处地位的前一个的元素，并挪动到前一个地位。
b) boolean hasPrevious()判断此处的前一个地位是否有元素
c) 逆向遍历必须先正向遍历使指针指到前面地位能力应用（应用意义不大）
4. 迭代器遍历元素时不能间接通过汇合批改元素，怎么办？
a) 迭代器批改元素
i. List迭代器有批改办法，Collection中的迭代器没有
ii. 通过迭代器中add(object obj)办法增加，跟在方才迭代元素前面
b) 通过汇合遍历元素，并用汇合批改元素（for循环遍历）
i. 通过汇合中add(object obj)办法增加，跟在汇合最初面
5. 迭代器遍历实例实例在上面给出
iv. 删除性能
Object remove(int index)依据索引删除指定的元素，并返回删除的元素
v. 批改性能、
Object set(int index,Object element)依据索引批改元素，返回被批改的元素
vi. 数组转成汇合
1. public static List asList(T… a)，返回类型为List类型
2. a为汇合，此处的… 代表可变参数，也就是a的数组元素个数可变
3. 此办法是Arrays类中的静态方法
4. 数组转变为汇合，本质还是数组须要保障长度不变，所以不反对增删汇合元素，能够批改元素
c) List子类的特点：
i. ArrayList:
1. 底层数据结构是数组，查问快、增删慢
2. 线程不平安，效率高
ii. Vector：
1. 底层数据结构是数组，查问快，增删慢
2. 线程平安，效率底
iii. LinkedList：
1. 底层数据结构是链表，查问慢，增删快
2. 线程不平安，效率高
1.1、 Vector汇合特有的特点
a) 增加性能
i. public void addElement(Object obj)
b) 获取性能
i. public Object elementAt(int index)
ii. public Enumeration elements ()
1. 也是用来遍历汇合
2. boolean hasMoreElements()
3. Object nextElement()
4. 根本不必这个，都是间接用下面的迭代器实现遍历
1.2、LinkedList汇合的特有性能
a) 增加性能
i. public void addFirst(Object e)
ii. public void addLast(Object e)
b) 获取性能
i. public Object getFirst()
ii. public Object getLast()
c) 删除性能
i. public Object removeFirst()
ii. public Object removeLast()
2、 Set汇合
a) 无序（存储和取出程序不统一，有可能会统一），然而元素惟一，不能反复
b) b) 实现类
i. HashSet
1. 底层数据是哈希表
2. 通过两个办法hashCode()和equals()保障元素的唯一性，XM外汇交易xmchina.net.cn办法主动生成
3. 子类LinkedHashSet底层数据结构是链表和哈希表，由链表保障元素有序，
由哈希表保障元素惟一。
ii. TreeSet
1. 底层数据是红黑二叉树
2. 排序形式：天然排序、比拟器排序
3. 通过比拟返回值是否为0来保障元素的唯一性。
2.1、 HashSet类：
a) 不保障set的迭代程序，
b) 当存储对象时须要重写equals（）和hashCode（）办法（能够用Eclipse主动生成此办法）
2.1.1、 LinkedHashSet类
a) HashSet的子类
b) 可预知的迭代程序，底层数据结构由哈希表和链表组成
i. 哈希表：保障元素的唯一性
ii. 链表：保障元素有序（存储和取出程序统一）
2.2、 TreeSet类
a) 可能保障元素唯一性（依据返回值是否是0来决定的），并且依照某种规定排序
i. 天然排序，无参构造方法（元素具备比拟性）
依照compareTo()办法排序，让须要比拟的元素所属的类实现天然排序接口Comparable，
并重写compareTo()办法
ii. 1. 让汇合的构造方法接管一个比拟器接口的子类对象（compareator）
（此处的Comparator为接口，须要写一个接口实现类，在实现类中重写compare()办法，
并在这里创立接口实现类的对象，能够用匿名外部类来创立实现类对象）
b) 底层是自均衡二叉树构造
i. 二叉树有前序遍历、后序遍历、中序遍历
ii. TreeSet类是依照从根节点开始，依照从左、中、右的准则依此取出元素
c) 当应用无参构造方法，也就是天然排序，须要依据要求重写compareTo()办法，这个不能主动生成
3、 针对Collection汇合咱们应该怎么应用
a) 是否元素惟一
i. 是：Set
1. 是否排序
a) 是：TreeSet
b) 否：HashSet
如果不晓得用哪个Set就用HashSet
ii. 否：List
1. 是否对安全性有要求
a) 是：Vector
b) 否：
查问多：ArrayList
增删多：LinkedList
如果不晓得用哪个List用ArrayList
如果晓得是用汇合但不晓得用哪个用ArrayList
二 、Collection汇合和List汇合迭代器遍历实例
package test10_collecton;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
//Collection汇合中的办法，子集合都能够用
// Iterator<E> iterator()迭代器，汇合的专用形式子集合都能够用
// Object next()获取以后元素，并挪动到下一个地位
// boolean hasNext()判断此地位是否有元素
//List汇合中的办法
// void add(int index,Object element)在指定地位增加元素（原索引处的元素后延）
// Object get(int index)获取指定地位的元素
//list迭代器中的特有办法
// Object previous ()返回此处地位的前一个的元素，并挪动到前一个地位。
// boolean hasPrevious()判断此处的前一个地位是否有元素
public class InteratoeDemo {
public static void main(String[] args) { //Collection汇合的遍历 Collection c=new ArrayList(); c.add("zfliu"); c.add("18"); c.add("java"); Iterator i=c.iterator(); while(i.hasNext()) { //向下转型 String s=(String) i.next(); System.out.println(s); } System.out.println("-----------------"); //List汇合的遍历 List l=new ArrayList(); l.add(0,"zfliu"); l.add(1,"18"); l.add(1,"java"); ListIterator li=l.listIterator(); //后向遍历 while(li.hasNext()) { String s=(String)li.next(); System.out.println(s); } System.out.println("-----------------"); //前向遍历 while(li.hasPrevious()) { String s=(String)li.previous(); System.out.println(s); } System.out.println("-----------------"); //get办法遍历 for(int x=0;x<l.size();x++) { String s=(String)l.get(x); System.out.println(s); } }}