Java中集合框架

一，集合框架图

        对于以上的框架图做以下说明：

1，所有集合类都位于java.util包下。Java的集合类主要由两个接口派生而出：Collection和Map是Java集合框架的根接口，者两个接口又包含了一些子接口或实现类。

2，集团接口：6个接口（虚短线表示），表示不同集合类型，是集合框架的基础。

3，抽象类：5个抽象类（长虚线表示），对集合接口的部分实现。可扩展为自定义结合类。

4，实现类：8个实现类（实线表示），对接口的具体实现。

5，Collection 接口是一组允许重复的对象。

6，Set 接口继承 Collection,集团元素不重复。

7，List 接口继承 Collection,允许重复，维护元素插入顺序。

8，Map 接口是键--值对象，与Collection接口没有什么关系。

9，Set,List和Map可以看做集合的三大类：

       List集合是有序集合，集合中的元素可以重复，访问集合中的元素可以根据元素的索引来访问。

       Set集合是无序集合，集合中的元素不可以重复，访问集合中的元素只能根据元素本身来访问（也是集合里元素不允许重复 的原因）。

        Map集合中保存Key-Value对形式的元素，访问时只能根据每项元素的Key来访问其value。

二，总体分析

大致说明：

看上面的框架图，先抓住它的主干，即Collection和Map。

1，Collection是一个接口，是高度抽象出来的集合，它包含了集合的基本操作和属性。Collection包含了List和Set两大分支。

    （1），List是一个有序的队列，每一个元素都有它的索引。第一个元素的索引值是0。List的实现类有LinkedList,ArrayList,Vector,Stack。

        （2），Set是一个不允许有重复元素的集合。Set的实现类有HashSet和TreeSet。HashSet依赖于HashMap，它实际上是通过HashMap实现的；TreeSet依赖于TreeMap,它实际上是通过TreeMap实现的。

2，Map是一个映射接口，即key-value键值对。Map中的每一个元素包括“一个key”和“key对应的“value”。AbstractMap是个抽象类，它实现了Map接口中的大部分API。而HashMap，TreeMap，WeakHashMap都是继承与AbstractMap。Hashtable虽然继承于Dictionary,但它实现了Map接口。

3，接下来，再看Iterator。它是遍历集合的工具，即我们通常通过Iterator迭代器来遍历集合。我们说Collection依赖于Iterator,是因为Collection的实现类都要实现iterator()函数，返回一个Iterator对象。ListIterator是专门为遍历List而存在的。

4，再看Enumeration,它是JDK1.0引入的抽象类。作用和Iterator一样，也是遍历集合；但是Enumeration的功能比Iterator少。在上面的框图中，Enumration只能在Hashtable,Vector,Stack中使用。

5，最后，看Arrays和Collections。它们是操作数组、集合的两个工具类。

三，Collection接口

        Collection接口是处理对象集合的根接口，其中定义了很多对元素进行操作的方法。Collection接口有两个主要的子接口List和Set,注意Map不是Collection的子接口，这个要牢记。

        Collection接口中的方法如下：

  其中，有几个比较常用的方法，比如方法add()添加一个元素到集合中，addAll()将制定集合中的所有元素添加到集合中，contain()方法检测集合中是否包含指定的元素，toArray()方法返回一个表示集合的数组。

        另外，Collection中有一个Iterator()函数，它的作用是返回一个Iterator接口。通常，我们通过Iterator迭代器来遍历集合元素。ListIterator是List接口所特有的，在List接口中，通过ListIterator()返回一个ListIterator对象。

Collection接口有两个常用的子接口，下面详细介绍。

1，List接口

List集合代表一个有序集合，集合中每个元素都有其对应的顺序索引。List集合允许使用重复元素，可以通过索引来访问指定位置的集合元素。

List接口继承于Collection接口，他可以定义一个允许重复的有序集合。因为List中的元素是有序的，所以我们可以通过使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，者类似于Java的数组。

List接口为Collection直接接口。List所代表的是有序的Collection,即他用某种特定的插入顺序来维护元素。用户可以对列表中每个元素的插入位置精准的控制，同时可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。实现List接口的集合主要有：ArrayList，LinkedList、Vector、Stack。

（1），ArrayList

        ArrayList是一个动态数组，也是我们最常用的集合。它允许任何符合规则的元素插入包括null。每一个ArrayList都有一个初始容量（10），该容量代表了数组的大小。随着容器的元素不断增加，容器的大小也会随着增加。在每次向容器中增加元素的同时都会进行容器检查，当快溢出时，就会进行扩容操作。所以如果我们明确所插入元素的大小，最好知道一个初始容量值，避免过多的进行扩容操作而浪费时间、效率。

        size，isEmpty,get,set,iterator和listIterator操作都以固定时间运行。add操作以分摊的固定时间运行，也就是说，添加n个元素需要O(n) 时间（由于要考虑到扩容，所以这不只是添加元素会带来分摊固定时间开销那样简单）。

        ArrayList擅长于随机访问。同时ArrayList是非同步的。

（2）LinkedList

        同样实现List接口的LinkedList与ArrayList不同，ArrayList是一个动态数组，而LinkedList是一个双向链表。所以它除了ArrayList的基本操作方法外还额外提供get,remove,insert方法在LinkedList的首部或尾部。

        由于实现方式不同，LinkList不能随机访问，它所有的操作都是要按照双重链表的需要执行。在列表的索引操作将从开头或结尾遍历列表（从靠近指定索引的一端）。这样做的好处就是可以通过较低的代价在List中进行插入和删除操作。

        与ArrayList一样，LinkedList也是非同步的。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List:List list = Collections.synchronizedList(new LinkedList(..));

（3），Vector

        与ArrayList相似，但是Vector是同步的。所以说Vector事线程安全的动态数组。它的操作与ArrayList几乎一样。

（4），Stack

        Stack继承自Vector,实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法，还有peek方法得到栈顶元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后的是空栈。

        

2，Set接口

        Set是一种不包括重复元素的Collection。它维持它自己的内部排序，所以随机访问没有任何意义。与List一样，它同时允许null的存在但是仅有一个。由于Set接口没有排序，但是元素在Set中的位置是由该元素的HashCode决定的，其具体位置其实是固定的。

        此外需要说明一点，在Set接口中不重复是有特殊要求的。

        举一个例子：对象A与对象B，本来是不同的两个对象，正常情况下它们是能够放入Set里面的，但是如果对象A和B的都重写了hashcode和equals方法，并且重写后的hashcode和equals方法是相同的话。那么A和B是不能同时入到Set 集合中的，也就是Set集合中的去重和hasncode和equals方法相关。

public class Test{ 
public static void main(String[] args) { 
     Set<String> set=new HashSet<String>(); 
     set.add("Hello"); 
     set.add("world"); 
     set.add("Hello"); 
     System.out.println("集合的尺寸为:"+set.size());  	   // 2
     System.out.println("集合中的元素为:"+set.toString());  // [world, Hello]
  } 
} 

public class TestSet {
    
    public static void main(String[] args){
        
        Set<String> books = new HashSet<String>();
        //添加一个字符串对象
        books.add(new String("Struts2权威指南"));
        
        //再次添加一个字符串对象，
        //因为两个字符串对象通过equals方法比较相等，所以添加失败，返回false
        boolean result = books.add(new String("Struts2权威指南"));
        
        System.out.println(result);   //false
        
        //下面输出看到集合只有一个元素

System.out.println(books); // [Struct2权威指南]

} }

（1）HashSet

        HashSet是一个没有重复元素的集合。它是由HashMap实现的，不保证元素的顺序（这里所说的没有顺序是指：元素插入 的顺序与输出的顺序不一致），而且HashSet允许使用null元素，HashSet是非同步的，如果多个线程同时访问一个HashSet，而其中至少一个线程修改了该Set,那么它必须保持外部同步。HashSet按Hash算法来存储集合的元素，因此具有很好的存取 和 查找性能。

        HashSet按HashSet的实现方式大致如下，通过一个HashMap存储元素，元素是存放在HashMap的Key中，而Value统一使用一个Object对象。

HashSet使用和理解中容易出现的误区：

a,HashSet中存放null值

   HashSet中是允许存入null值的，但是在HashSet中仅仅能够存入一个null值。

b,HashSet中存储元素的位置是固定的

   HashSet中存储的元素是无序的，这个没什么好说的，但是由于HashSet底层是基于Hash算法实现的，使用了hashcode，所以HashSet中相应的元素的位置是固定的。

c，必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。

（2）LinkedHashSet

        LinkedHashSet继承HashSet，其底层是基于LinkedHashMap来实现的，有序，非同步。LinkedHashSet集合同样是根据元素的hashCode值来决定元素的存储位置，但是它同时是使用链表维护元素的次序。这样使得元素看起来像是以插入顺序保存的，也就是说，当遍历该集合时候，LinkedHashSet将会以元素的添加顺序访问集合的元素。

（3）TreeSet

        TreeSet是一个有序集合，其底层是基于TreeMap实现的，非线程安全。TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式，自然排序和定制排序，其中自然排序为默认的排序方式。当我们构造TreeSet时，若使用不带参数的构造函数，则TreeSet的使用自然比较器；若用户需要使用自定义的比较器；若用户使用自定义的比较器，则需要使用带比较器的参数。

注意：TreeSet集合不是通过hashcode和equals函数来比较元素的，它是通过compare或者compareTo函数来判断元素是否相等。compare函数通过判断两个对象的id，相同的id判断为重复元素，不会被加入到集合中。

四，Map接口

        Map与List、Set接口不同，它是由一系列键值对组成的集合，提供了key到value的映射。同时它也没有继承Collection。在Map中它保证了key与value之间的一一对应关系。也就是说一个key对应一个value，所以它不能存在相同的key值，当然value值可以相同。

1，HashMap

        以哈希表数据结构实现，查找对象是通过哈希函数计算其位置，它是为快速查询而设计的，其内部定义了一个hash表数组（Entry[] table），元素会通过哈希转换函数将元素的哈希地址转换为数组中存放的索引，如果有冲突，则使用散列链表的形式将所有相同哈希地址的元素串起来，可以通过查看HashMap.Entry的源码知道它是 一个单链表结构。

2，LinkedHashMap

        LinkedHashMap是HashMap的一个子类，它保留插入的顺序，如果需要输出的顺序和输入时的相同，那么就选用LinkedHashMap.

        LinkedHashMap是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是他不保证该顺序恒久不变。

        LinkedHashMap实现与HashMap不同之处在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序可以是插入顺序或者是 访问顺序。

        根据链表中元素的顺序可以分为：按插入顺序的链表，和按访问顺序（调用get方法）的链表。默认是按插入顺序排序，如果指定按访问顺序，那么调用get方法后，会将这次访问的元素移至链表尾部，不断访问可以形成按访问顺序排序的链表。

        注意，此实现不是同步的。如果多个线程同时访问链接的哈希映射，而其中一个线程从结构上修改了该映射，则它必须保持外部同步。

        由于LinkedHashMap需要维护元素的插入顺序，因此性能略低于HashMap的性能，但在迭代访问Map里的全部元素时将有很好的性能，因为它以链表来维护内部顺序。

3，TreeMap

        Treemap是一个有序的key-value集合，非同步，基于红黑树（Red-Black tree）实现，每一个key-value节点作为红黑树的一个节点。TreeMap存储时会进行排序的，会根据key来对key-value键值对进行排序，其中排序方式也是分为两种，一种是自然排序，一种是定制排序，具体取决于使用的构造方法。

自然排序：TreeMap中所以的key必须实现Comparable接口，并且所有的key都应该是同一类的对象，否则会报ClassCastException异常。

定制排序：定义TreeMap时，创建一个comparator对象，该对象对所有的TreeMap中所有的Key值进行排序，采用定制排序的时候不需要TreeMap中所有key实现Comparable接口。

        TreeMap判断两个元素相等的标准：两个key通过compareTo()方法返回0，则认为这两个key相等。

        如果使用自定义的类 来作为TreeMap中的key值，且想让TreeMap能够良好的工作，则必须重写自定义类中的equals()方法，TreeMap中 判断相等的标准是：两个key通过equals()方法 返回true，并且通过compareTo()方法比较应该返回为0。

五，Iterstor与ListIterator详解

1，Iterator

public interface Iterator<E> {}        // 定义

Iterator是一个接口，它是集合的迭代器。集合可以通过Iterator去遍历 集合中的元素。Iterator提供API接口如下：

boolean hashNext():判断集合里是否存在下一个元素。如果有hashNext()方法返回true.

Object next(): 返回集合里的下一个元素。

void remove(): 删除集合里上一次next方法返回的元素。

使用示例：

public class IteratorExample 
{
    public static void main(String[] args) 
    {
        ArrayList<String> a = new ArrayList<String>();
        a.add("aaa");
        a.add("bbb");
        a.add("ccc");
        System.out.println("Before iterate : " + a);
        Iterator<String> it = a.iterator();
        while (it.hasNext()) 
        {
            String t = it.next();
            if ("bbb".equals(t)) 
            {
                it.remove();
            }
        }
        System.out.println("After iterate : " + a);
    }
}
结果：
Before iterate : [aaa, bbb, ccc]
After iterate : [aaa, ccc] 

注意：

（1），Iterator只能单向移动。

（2），Iterator。remove()是唯一安全的方式来在迭代过程中修改集合；如果在迭代过程中以任何其它的方式修改了基本集合将会产生未知的行为。而且每调用一次next()方法，remove()方法只能被调用一次，如果违反这个规则将抛出异常。

2，ListIterator

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

ListIterator接口定义如下：

public interface ListIterator<E> extends Iterator<E> {
    boolean hasNext();
 
    E next();
 
    boolean hasPrevious();
 
    E previous();
 
    int nextIndex();
 
    int previousIndex();
 
    void remove();
 
    void set(E e);
 
    void add(E e);
     
}  

由以上定义我们可以推出ListIterator可以：

（1），双向移动（向前/向后遍历）。

（2），产生相对于迭代器在列表中指向的当前位置的前一个和后一个元素的索引。

（3），可以使用set()方法替换它访问过的最后一个元素。

（4），可以使用add()方法在next()返回的元素之前或previous()方法返回的元素之后擦好人一个元素。

public class ListIteratorExample {
	 
    public static void main(String[] args) {
        ArrayList<String> a = new ArrayList<String>();
        a.add("aaa");
        a.add("bbb");
        a.add("ccc");
        System.out.println("Before iterate : " + a);
        ListIterator<String> it = a.listIterator();
        while (it.hasNext()) {
            System.out.println(it.next() + ", " + it.previousIndex() + ", " + it.nextIndex());
        }
        while (it.hasPrevious()) {
            System.out.print(it.previous() + " ");
        }
        System.out.println();
        it = a.listIterator(1);
        while (it.hasNext()) {
            String t = it.next();
            System.out.println(t);
            if ("ccc".equals(t)) {
                it.set("nnn");
            } else {
                it.add("kkk");
            }
        }
        System.out.println("After iterate : " + a);
    }
} 
结果：
Before iterate : [aaa, bbb, ccc]
aaa, 0, 1
bbb, 1, 2
ccc, 2, 3
ccc bbb aaa 
bbb
ccc
After iterate : [aaa, bbb, kkk, nnn] 

六，异同点

1,ArrayList和LinkedList

（1），ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。

（2），对于随机访问get和set，ArrayList绝对优于LinkedList，因为LinkedList要移动指针。

（3），对于新增和删除操作add和remove，LinkedList比较占优势，因为ArrayList要移动数据。

这一点要看实际情况的。若只对单条数据插入或删除，ArrayList的速度反而优于LinkedList。但若是批量随机的插入删除数据，LinkedList的速度大大优于ArrayList，因为ArrayList每插入一条数据，要移动插入点及以后的所有数据。

2，HashTable与HashMap

相同点：

（1），都实现Map、Cloneablale、java.io.Serizable接口。

（2），都是存储“键值对（key-value）”的散列表，而且都是采用拉链法实现的。

不同点：

（1），