1 集合类基本框架

　　Java 集合类主要分为两大类：Collection 与 Map. 它们两是是Java集合框架的根接口。

　　1 Collection 框架

　 Collection 接口是List、Set、Queue接口的父接口，所以该接口定义的所有方法可用于操作这三个集合。Collection 定义了如下基本方法用于操作集合。

boolean add(Object o)：向集合添加一个元素，如果集合对象被添加操作改变了，则返回true。
boolean addAll(Collection c)：将集合c的所有元素添加到指定集合里，如果集合对象被添加操作改变了，则返回true。
void clear()：清除集合所有的元素，将集合的长度变为0。
boolean contains()：判断集合是否包含指定元素，是则返回true，否则返回false。
boolean containsAll()：判断集合是否包含集合c的所有元素。
boolean isEmpty()：判断集合是否为空。
Iterator iterator()：返回一个Iterator对象。
boolean remove(Objcet o)：删除集合中的元素o，删除成功返回true；只删除满足条件的第一个元素。
boolean removeAll(Collection c)：从集合中删除集合c的所有元素。
boolean retainAll(Collection c)：从集合中删除集合c以外的所有元素。
int size()：返回集合个数。
Object[] toArray()：把集合转换为一个数组，所有元素数组变为数组元素。
<T> T[] toArray(T[] a)：返回包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。

　　2 Set 集合类

Set 类，类似一个罐子，程序可以把多个对象扔进Set集合，所以Set集合是无序的，Set集合方法与Collection基本相同，没有提供额外的方法。Set集合不允许重复元素。它有3个常用的实现类，HashSet、TreeSet、EnumSet。

2.1 HashSet

HashSet 是Set 接口的典型实现，大多数时候使用Set时就是使用HashSet。它按照Hash算法存储集合中的元素，具有很好的存取与查找性能。它具有以下特点：

HashSet是无序的，元素的顺序与添加顺序不同。
Hashset 不是同步的，如果多线程同时访问一个HashSet，需要对其进行同步处理。
HashSet 集合元素可以为 null。

使用HashSet 添加与访问元素

        
        //声明一个String型的HashSet变量
        Collection<String> hash = new HashSet<String>();
        String a="曹操";
        String b="刘备";
        String c="孙权";
        hash.add(a);
        hash.add(b);
        hash.add(c);
        
        //使用Iterator 遍历访问HashSet
        Iterator<String> iter = hash.iterator();
        while(iter.hasNext())
        {
            Object obj = iter.next();
            System.out.print(obj+"; ");
        }

　　将HashSet集合转为Object 数组

    Object[] objs = hash.toArray();
    for(Object obj:objs)
    {
         System.out.print(obj+"; ");
    }

　　添加重复元素到HashSet集合的结果：　　

 1         
 2         //声明一个String型的HashSet变量
 3         Collection<String> hash = new HashSet<String>();
 4         String a="曹操";
 5         String b="刘备";
 6         String c="孙权";
 7         hash.add(a);
 8         hash.add(b);
 9         hash.add(c);
10         //第二次添加c元素到hash对戏里
11         boolean result = hash.add(c);
12         //结果为false
13         System.out.println(result);
14         
15         //使用Iterator 遍历访问HashSet
16         Iterator<String> iter = hash.iterator();
17         while(iter.hasNext())
18         {
19             Object obj = iter.next();
20             System.out.print(obj+"; ");
21         }
22         

输出结果：

　false
　曹操; 孙权; 刘备;

　　结果显示添加重复元素到hash对象时，返回结果为false，添加失败。

　　HashSet 是通过equals方法与hashCode方法来判断两个元素是否相等，两个元素调用这两个方法返回的值都为true的时候，HashSet才会认为这两个元素相等。

　　详细讲解：http://www.cnblogs.com/Latiny/p/8359088.html

　　2.2 TreeSet

　　TreeSet 是SortedSet接口的实现类，TreeSet可以确保元素处于有序状态。与HashSet相比TreeSet提供了一些额外的方法：

Comparator comparator()：如果TreeSet采用了定制排序，则该方法返回定制排序所使用的Comparator；如果采用的是自然排序则返回null
Object first()：返回第一个元素
Object last()：返回最后一个元素
Object lower(Object o)：返回指定元素之前的元素
Object higher(Obect o)：返回指定元素之后的元素
SortedSet subSet(fromElement, toElement)：返回子集合

TreeSet 不是根据插入时的顺序排序的，而是根据元素实际值的大小排序的。

        
        Collection<Integer> tree = new TreeSet<Integer>();
        tree.add(2);
        tree.add(5);
        tree.add(3);
        tree.add(-1);
        tree.add(10);
        
        System.out.println(tree);

　　　　 结果：[-1, 2, 3, 5, 10]

　　String 型的字符串按照字符串的unicode值进行排序

 1     
 2         Collection<String> tree = new TreeSet<String>();
 3         tree.add("Hello");
 4         tree.add("你好吗");
 5         tree.add("曹操");
 6         tree.add("Nice");
 7         tree.add("Best");
 8         
 9         System.out.println(tree);
10         

结果：
[Best, Hello, Nice, 你好吗, 曹操]

　　3 List 集合

List 集合是一种元素有序，可重复的集合，每个元素都有其对应的顺序索引。List 作为Collection接口的子接口，除了拥有Collection的全部方法，还增加了一些根据索引操作结合的方法。

void add(int index, Object element)：将元素插入到List集合的index处

boolean addAll(int index, Collection c)：将集合c包含的所有元素插入到index处

Object get(int index)：返回index处的元素

int indexOf(Object o)：返回对象o在List集合第一次出现的位置

int lastIndexOf(Object o)：返回对象o在List集合最后一次出现的位置

Object remove(int index)：删除并返回index处的对象

void sort(Comparator c)：根据Comparator参数对List集合进行排序

3.1 ArrayList 实现类

ArrayList是List是主要实现类之一，完全支持List接口的所有方法。

 1         
 2         //添加
 3         List list = new ArrayList<String>();
 4         list.add("孙权");
 5         list.add("周瑜");
 6         list.add("诸葛亮");
 7         list.add("司马懿");
 8         list.add("曹丕");
 9         System.out.println(list);
10         
结果：
[孙权, 周瑜, 诸葛亮, 司马懿, 曹丕]

　　在指定的index处添加元素，不能超过List集合长度+1。

 1         
 2         //添加
 3         List list = new ArrayList<String>();
 4         list.add("孙权");
 5         list.add("周瑜");
 6         list.add("诸葛亮");
 7         list.add("司马懿");
 8         list.add("曹丕");
 9         //在指定位置添加字符，位置不能超过集合长度+1
10         list.add(5, "邓艾");
11         list.add(2, "关羽");
12         
13         for(int i=0; i<list.size(); i++)
14         {
15             String str = (String)list.get(i);
16             System.out.print(str+", ");
17         }    
18      
结果：
孙权, 周瑜, 关羽, 诸葛亮, 司马懿, 曹丕, 邓艾,

　　3.2 Vector 类

　　Vector 类也是List接口的实现类，拥有List所有的方法，与ArrayList的主要不同：

线程安全
性能相对较低
历史悠久，从JDK1.0就存在了

　　3.3 LinkedList

　　LinkedList 既是List接口实现类，也是Deque接口实现类，这就意味着它有List与Deque的双重特性，可以根据索引访问集合元素，也可以被当作双端队列使用。

 1         LinkedList list = new LinkedList();
 2         //首先添加一些基本的元素
 3         list.add("Kobe");
 4         list.add("Jordan");
 5         list.add("James");
 6         
 7         //将元素插入到集合开头
 8         list.push("Irving");
 9         //将元素插入到集合末尾
10         list.offer("Curry");
11         
12         //遍历集合中的元素
13         for(int i=0; i<list.size(); i++)
14         {
15             String str =(String)list.get(i);
16             System.out.print(str+", ");
17         }

　　使用策略：　

数组：是以一段连续内存保存数据的；随机访问是最快的，但不支持插入、删除、迭代等操作。

Set类：只关心某元素是否属于 Set （不允许有相同元素），而不关心它的顺序

① HashSet类按照哈希算法来存取集合中的对象，存取速度比较快；

② TreeSet类实现了SortedSet接口，能够对集合中的对象进行排序。

List 类：关心的是顺序，它保证维护元素特定的顺序（允许有相同元素），使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在 List 中的位置，类似于数组下标）来访问 List 中的元素。

① ArrayList 内部以以数组的形式保存集合中的元素，适合大量的随机访问；

② LinkedList 内部以链表的形式保存集合元素，因此随机访问元素集合时性能较差，但是从集合中插入或删除元素时性能较好；

Queue 类：用于模拟"队列"这种数据结构(先进先出 FIFO)。队列的头部保存着队列中存放时间最长的元素，队列的尾部保存着队列中存放时间最短的元素。新元素插入(offer)到队列的尾部。