java集合（1）- 类底层数据结构分析

Java 集合类图

参考：http://www.cnblogs.com/xwdreamer/archive/2012/05/30/2526822.html

上述类图中，实线边框的是实现类，比如ArrayList，LinkedList，HashMap等，折线边框的是抽象类，比如AbstractCollection，AbstractList，AbstractMap等，而点线边框的是接口，比如Collection，Iterator，List等。

　　发现一个特点，上述所有的集合类，都实现了Iterator接口，这是一个用于遍历集合中元素的接口，主要包含 hashNext(),next(),remove()三种方法。它的一个子接口LinkedIterator在它的基础上又添加了三种方法，分别是 add(),previous(),hasPrevious()。也就是说如果是先Iterator接口，那么在遍历集合中元素的时候，只能往后遍历，被遍历后的元素不会在遍历到，通常无序集合实现的都是这个接口，比如HashSet，HashMap；而那些元素有序的集合，实现的一般都是 LinkedIterator接口，实现这个接口的集合可以双向遍历，既可以通过next()访问下一个元素，又可以通过previous()访问前一个元素，比如ArrayList。

　　还有一个特点就是抽象类的使用。如果要自己实现一个集合类，去实现那些抽象的接口会非常麻烦，工作量很大。这个时候就可以使用抽象类，这些抽象类中给我们提供了许多现成的实现，我们只需要根据自己的需求重写一些方法或者添加一些方法就可以实现自己需要的集合类，工作流昂大大降低。

2.详解

一． List
1).ArrayList

 ArrayList维护着一个对象数组。如果调用new ArrayList()后，它会默认初始一个size=10的数组。
 每次add操作都要检查数组容量，如果不够，重新设置一个初始容量1.5倍大小的新数组，然后再把每个元素copy过去。
 在数组中间插入或删除，都要移动后面的所有元素。（使用System.arraycopy()）

2).LindedList
LinkedList的实现是一个双向链表。每个节点除含有元素外，还包含向前，向后的指针。
新建一个LinkedList，生成一个头节点（header，就是一个头指针），它的元素为null。

它自包含，next和previous指针都指向自己。
执行add(Object obj)方法后，会生成一个新节点

Header节点的next指向链表的第一个节点，previous指向链表的最后一个节点，在这里都是first。
再增加一个对象，它的形状像下面这样。

现在是一个标准的双向链表形状。每个节点都有自己的next和previous指针。
 增加节点，只会对链表的指针进行操作，速度快
 LinkedList实现了Deque，所以它有双向队列的特征，在链表两端可增删数据
 使用index查找对象时，会以index和size/2比较，从前或从后向中间搜索
 ListIterator可向前或向后迭代

比较ArrayList和LinkedList的结构，就可以得出：
1． ArrayList的remove和add(index, Object)操作代价高，需要移动后面的每个元素。
2． LinkedList的get(index)操作代价高，它要先循环遍历list，找到Object

以下是http://blog.csdn.net/bobge/article/details/3110000观点：

首先看一下LinkedList和ArrayList的继承关系。

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Queue<E>, Cloneable, Serializable

两者都实现List接口，前者实现RandomAccess接口，后者实现Queue接口。

ArrayList

ArrayList其实是包装了一个数组Object[]，当实例化一个ArrayList时，一个数组也被实例化，当向ArrayList中添加对象是，数组的大小也相应的改变。这样就带来以下有缺点：

快速随即访问 你可以随即访问每个元素而不用考虑性能问题，通过调用get(i)方法来访问下标为i的数组元素。

向其中添加对象速度慢 当你创建数组是并不能确定其容量，所以当改变这个数组时就必须在内存中做很多事情。

操作其中对象的速度慢 当你要想数组中任意两个元素中间添加对象时，数组需要移动所有后面的对象。

LinkedList

LinkedList是通过节点直接彼此连接来实现的。每一个节点都包含前一个节点的引用，后一个节点的引用和节点存储的值。当一个新节点插入时，只需要修改其中保持先后关系的节点的引用即可，当删除记录时也一样。这样就带来以下有缺点：

操作其中对象的速度快 只需要改变连接，新的节点可以在内存中的任何地方

不能随即访问 虽然存在get()方法，但是这个方法是通过遍历接点来定位的所以速度慢。

一些结论：

当一些被定义好的数据需要放到与数组对应的List中，ArrayList是很好的选择，因为它可以动态变化，但是不要在整个应用程序用频繁的使用。当你要很方便的操作其中的数据而不用随即访问时LinkList是很好的选择。如果你要频繁随即访问建议使用数组。

另外一个我没有提到的是关于Queue。LinkedList的实现使其具有很好的可扩展性，可以方便的在开始和结尾添加删除节点。所以LinkedList很适合用来实现Queue和Stack，尽管在Java5种已经有了一个Stack的实现。

二． Map
1).HashMap
HashMap的结构是一个散列桶，初始化时生成如下结构

每个bucket包含一个Entry(map自定义的一种结构，包含一个往后的指针)的链表。
在put(key, value)后，它的结构如下

将key的hashcode再次散列，然后用这个hash和length-1进行按位与操作，得到bucket的index，然后检查当前bucket的链表，有没有这个key,如果有替换value，没有则跟在链表的最后。
 允许key和value都可以是null
 Index=0的bucket存key=null的value，也可以是其它hashcode为0的项
 初始容量必须为2的幂次（我的理解是，在生成index的时候有这样的代码:hase ^ (length - 1)），length – 1的二进制代码为全1,则容易进行hash的设计）
 如果两个key散列后的index一样的话，第一个key生成的Entry先存在桶中，第二个key生成的Entry会将第一个Entry设为自己的 next，串起来。（如图中，先put(yy, “first”)，会将这个Entry设为bucket的第一项，后put(xx,”second”)，则生成新Entry，它的next为key为yy 的Entry，生成一个链表）
 在put操作中，会比较threshold（capacity * load_factor，一个临界值），如果size > threshold的话，生成一个当前bucket两倍数量的buckets，然后把现有的数据重新散列到新bucket中
 对HashMap迭代时，返回数据的顺序是:index从0到length-1，循环遍历每个bucket，把不为null的数据取出，每个bucket内的顺序由链表的顺序决定。而不是由插入数据决定。

2).LinkedHashMap
上面说过，Map的迭代不由插入顺序决定。如果要保持这种顺序呢？就要新增加一种结构来保持。

LinkedHashMap是HashMap的子类，增加一个双向链表，用来存储每个新加入的节点。在遍历时，按链表的顺序进行。其实差不多就是上面HashMap和LinkedList的和吧。

测试列子

import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map.Entry;


public class mapTest {

    /**
     * @param args
     */
    public static void main(String[] args) {

        
        HashMap<String , Double> hashmap = new HashMap<String , Double>();   
        hashmap.put("语文" , 80.0);   
        hashmap.put("数学" , 89.0);   
        hashmap.put("英语" , 78.2); 
        hashmap.put("国学" , 3432423.00);                 
        Iterator i = hashmap.entrySet().iterator();  
        while(i.hasNext()){  
            Entry  entry=(Entry)i.next();  
            Object key=entry.getKey();  
            Object value=entry.getValue();  
            System.out.println(key+":"+value);
        } 
        System.out.println("-------------------");

        LinkedHashMap<String , Double> linkmap = new LinkedHashMap<String , Double>();   
        linkmap.put("语文" , 80.0);   
        linkmap.put("数学" , 89.0);   
        linkmap.put("英语" , 78.2); 
        linkmap.put("国学" , 3432423.00);                 
        Iterator ik = linkmap.entrySet().iterator();  
        while(ik.hasNext()){  
            Entry  entry=(Entry)ik.next();  
            Object key=entry.getKey();  
            Object value=entry.getValue();  
            System.out.println(key+":"+value);
        } 
        
    }

}

结果是：HashMap迭代没按顺序输出，LinkedHashMap按照插入的顺序输出。

更多关于HashMap查看http://www.cnblogs.com/crazylqy/p/4255895.html

三． Set
1).HashSet
HashSet使用HashMap来保持元素。Key = 元素，value是一个公有的对象，对每个元素都一样，在HashMap里面key是惟一的，当然很适合于构造set集合。等同于用HashMap包装了次，显示Set自己的特性。

四． Collections
最后还要提到集合类里面一个很重要的类:Collections，它有很多自己独特的静态方法。当然它主要提供几种特殊集合(List, Map,Set)，可以调用静态方法来获得：Unmodifiable*(不可修改集合，不可添加或删除元素)，Synchronize*(保持同步集合，它的基本每个方法都加锁，防止并发操作)，Checked*(声明之始传入特定类型，以后的操作都会验证加入元素是否属于已定类型)，Singleton*(集合中只包含一个元素)。它们都是通过包装集合类中的抽象类获得，产生不同的行为。

上面是常见的几种集合类，其它类我很少使用到。
不记得是谁说过，我们最容易记住图像化的知识。在学习了部分集合类知识后，总结下，以便以后忘记了还能翻看下

posted @ 2015-01-28 10:34 crazyYong 阅读(1029) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

java集合（1）- 类底层数据结构分析

Java 集合类图

2.详解

公告