blogjava-凯发k8网页登录

       (这篇文章是从网上摘录,地址忘了,如涉及凯发k8网页登录的版权请和我联系zhyiwww@163.com)

1.        vector 是线程同步的，所以它也是线程安全的，而 arraylist 是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用 arraylist 效率比较高。

2.        如果集合中的元素的数目大于目前集合数组的长度时， vector 增长率为目前数组长度的 100%, 而 arraylist 增长率为目前数组长度的 50%. 如过在集合中使用数据量比较大的数据，用 vector 有一定的优势。

3.         如果查找一个指定位置的数据， vector 和 arraylist 使用的时间是相同的，都是 0(1), 这个时候使用 vector 和 arraylist 都可以。而如果移动一个指定位置的数据花费的时间为 0(n-i)n 为总长度，这个时候就应该考虑到使用 linklist, 因为它移动一个指定位置的数据所花费的时间为 0(1), 而查询一个指定位置的数据时花费的时间为 0(i) 。

另：

如果你注意到对vector和list的所开始支持的java版本你就应该可以找到答案了。java对vector的支持since 1.0；对list则是since 1.2。这两个版本之间，sun对于java api做了很多的改动，其中的一个refactoring就是提出了所谓的collection framework，list就是在那个时候被introduced，它完全符合1.2版本的collection framework，而vector则是在colleciton framework出现之前就已经存在了，但java api并没有将vector变成deprecated，主要是backward compatiable的问题，最终jcp将vector做了refactoring的处理，让它符合所定制的collection framework了事。另外，hashtable和hashmap的区别是同样的道理。

结论：

尽量采用 list 和 hashmap ， rather than vector&hashtable

       凯发k8网页登录的版权所有，转载请声明出处 zhyiwww@163.com

为了弄清楚这个问题 , 我又看了一遍 collection 部分 , 并且看了些其中的源码 , 觉得对其中的实现又明白了一点 , 现在说出来和大家共享 .

我们先看一下 set 类的关系图：

现在我们就从 set 说起。

set 接口为我们提供了一个 add() 方法，以让我们添加元素。所以我们看一下在其实现类 hashset 中是如何实现的呢？

我们看 hashset 中的 add() 方法实现；

    public boolean add( e o ) {

              return  map.put(o, present)==null;

}

你可能回问怎么回出来 map 了呢？

map 又是一个什么变量呢？

我们来看 map 是在在哪定义的。原来，在 hashset 中定义了这样的两个变量：

    private transient hashmap map;

    private static final object present = new object();

我们再看一下上面的 add() 方法。

map.put(o, present)==null

实际执行的是 map 的方法，并且我们添加的对象是 map 中的 key,value 是执行的同一个对象 present.

因为map中的key是不允许重复的，所以set中的元素不能重复。

下面我们再看一下， map 又是如何保证其 key 不重复的呢？

现在我们看一下 map 中的 put() 方法的实现：

hashmap 实现了 map ，在 hashmap 中是这样实现的：

    public v put(k key, v value) {

      k k = masknull(key);

        int hash = hash(k);

        int i = indexfor(hash, table.length);

        for (entry e = table[i]; e != null; e = e.next) {

            if (e.hash == hash && eq(k, e.key)) {

                v oldvalue = e.value;

                e.value = value;

                e.recordaccess(this);

                return oldvalue;

            }

        }

        modcount ;

        addentry(hash, k, value, i);

        return null;

    }

我们我们按照方法的执行一步一步的来看一下，其实现的过程。

k k = masknull(key);

这一步是要判断当前的要添加的对象的 key 是否为空，如果为空的话，那么就生成一个新的对象作为其 key 。实现如下：

    static final object null_key = new object();

     * returns internal representation for key. use null_key if key is null.

    static t masknull(t key) {

        return key == null ? (t)null_key : key;

    }

之后

int hash = hash(k);

我们看一下 hash() 方法的实现：

    static int hash(object x) {

        int h = x.hashcode();

        h = ~(h << 9);

        h ^=  (h >>> 14);

        h =  (h << 4);

        h ^=  (h >>> 10);

        return h;

    }

这一步其实是要得到当前要添加对象的 hashcode, 方法中，首先通过 int h = x.hashcode() 取得了当前的要添加对象的 hashcode, 然后

        h = ~(h << 9);

        h ^=  (h >>> 14);

        h =  (h << 4);

        h ^=  (h >>> 10);

生成一个新的 hashcode.

接着执行的是

（从此处开始，我理解的比较肤浅，请看到此出的朋友多多指点）

int i = indexfor(hash, table.length);

这个方法是要 returns index for hash code h.

    static int indexfor(int h, int length) {

        return h & (length-1);

    }

      下面就要根据 hashmap 中的元素逐个的比较，看是否相同，如果不同就回添加一个新的元素。是通过循环判断来实现的。

        for (entry e = table[i]; e != null; e = e.next) {

            if (e.hash == hash && eq(k, e.key)) {

                v oldvalue = e.value;

                e.value = value;

                e.recordaccess(this);

这句我的理解是：在内存中的可以访问元素又多了一个。也就是说，添加之后，可以通过hashmap来访问此元素了。

                return oldvalue;

            }

        }

通过循环判断是否有完全相同的对象，包括 hashcode 和 value 值。如果已经存在就返回其值，如果不存在就执行一下操作。

        modcount ;

        addentry(hash, k, value, i);

        return null;

对象不存在，首先修改 hashmap 的修改次数，即 modcount 加 1. 然后将对象添加到数组中。

    void addentry(int hash, k key, v value, int bucketindex) {

      entry e = table[bucketindex];

        table[bucketindex] = new entry(hash, key, value, e);

        if (size >= threshold)

            resize(2 * table.length);

}

仍然是数组，我们来看一下 , 在 hashmap 中用来存放对象的数组的定义：

    transient entry[] table;

至此，我想大家也许应该明白了，为什么在 set 中是不允许存放重复值的。

通过才的分析，我们可以看到， map 的一些特征：

1.       在 map 中也是不能存放完全相同的元素的

2.       如果你存入的对象的 key 值已经存在的话，那么新的 value 将会取代老的 value 值，但是并不会添加新的元素进去。

我们可以通过一个测试程序来证明这一点：

  public void maptest() {

    map m = new hashmap();

    /**

     * we  can  put  the  int  1 and the  value  1  into  the  map

     * but  we  cannot  get  the  1 as  int  from the map

     * why ?

     * we  only  get  the  1  as  integer  from  the map,

     * so  we  only  get the object  from the map,if we  put the  value  into

     * the map,we  will get one  instance of  the wrapper  of  that

     */

    m.put(1, 1);

    //int i = m.get(1);

    integer i = (integer) m.get(1);

    system.out.println(i);

    m.put(1, 1);

    m.put(1, 1);

    system.out.println("map   :    " m);

    system.out.println("map  size    :   " m.size());

    m.put(1, 2);

    system.out.println("map   :    " m);

    system.out.println("map  size    :   " m.size());

  }

运行的结果是：

map   :    {1=1}

map  size    :   1

map   :    {1=2}

map  size    :   1

希望此文能大家有所帮助。