精华内容
下载资源
问答
  • ArrayList和Vector

    万次阅读 2019-04-10 22:07:42
    所以,首先查找了一些关于ArrayList和Vector的一些资料,并查看了部分源码。接下来,写一下对ArrayList和Vector的一些理解。 ArrayList和Vector的使用非常的相似,都可用来表示一种数量可变的对象的集合。通过看...

        今天,因为回顾Java基础知识,写了上一篇博客,最后写到了HashMap,然后联想到Java常用的数据结构。所以,首先查找了一些关于ArrayList和Vector的一些资料,并查看了部分源码。接下来,写一下对ArrayList和Vector的一些理解。

        ArrayList和Vector的使用非常的相似,都可用来表示一种数量可变的对象的集合。通过看Vector的源码可以看到,Vector的很多方法都是使用synchronized修饰的,也就是说,这些方法都是同步的,是线程安全的。下面是Vector部分源码,跟add操作相关的代码(确实是有同步操作):

        public void add(int index, E element) {
            insertElementAt(element, index);
        }
    
        public synchronized void insertElementAt(E obj, int index) {
            modCount++;
            if (index > elementCount) {
                throw new ArrayIndexOutOfBoundsException(index
                                                         + " > " + elementCount);
            }
            ensureCapacityHelper(elementCount + 1);
            System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
            elementData[index] = obj;
            elementCount++;
        }

     

        我们都知道,同步方法会带来额外的开销。因此,理论上来讲,如果对线程安全要求不高,使用ArrayList比使用Vector效率更高。但是,这个效率的差别很大吗?接下来,我们就探讨一下Vector和ArrayList在一些操作上效率的不同。

    一、插入数据的效率

        我们分别往Vector和ArrayList中插入1万,10万和100万条相同的数据,看一下二者的效率差别有多大。如下是测试代码:

    import java.util.Vector;
    
    public class VectorDemo {
    	
    	public static void main(String[] args) {
    		Vector<String> vector = new Vector<>();
    		Long start = System.currentTimeMillis();
    		for (int i = 0; i < 1000000; i++) {
    			vector.add("data" + i);
    		}
    		Long end = System.currentTimeMillis();
    		Long time = end - start;
    		System.out.println("time:"+time);
    	}
    
    }
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class ArrayListDemo {
    
    	public static void main(String[] args) {
    		List<String> list = new ArrayList<>();
    		Long start = System.currentTimeMillis();
    		for (int i = 0; i < 1000000; i++) {
    			list.add("data" + i);
    		}
    		Long end = System.currentTimeMillis();
    		Long time = end - start;
    		System.out.println("time:"+time);
    
    	}
    
    }
    

        在我使用了好几年的笔记本上,多次测试后的统计结果如下:

    插入1万条数据时间统计
      时间(ms) 平均(ms)
    ArrayList 6 5 6 6 7 4 7 6 6 6 5.9
    Vector 5 7 4 6 5 6 6 6 6 6 5.7

     

    插入10万条数据时间统计
      时间(ms) 平均(ms)
    ArrayList 34 37 37 31 34 33 30 33 31 32 33.2
    Vector 34 35 34 37 35 33 32 36 36 32 34.4

     

    插入100万条数据时间统计
      时间(ms) 平均(ms)
    ArrayList 637 657 634 652 668 672 653 631 642 651 649.7
    Vector 688 659 666 662 644 688 636 662 668 674 662.7

        插入1000万条数据的测试,我也做了几次,ArrayList和Vector都在10000毫秒左右。由上面的统计结果看,Vector和ArrayList在插入数据方面的性能差距不大,可以说是几乎没有差别!

    二、删除数据的效率

        我们分别从Vector和ArrayList中插入20万条数据,并删除1000、1万、10万条数据,比较一下删除数据的效率,我用的测试代码如下:

    import java.util.Vector;
    
    public class VectorDemo {
    
    	public static void main(String[] args) {
    		Vector<String> vector = new Vector<>();
    		for (int i = 0; i < 200000; i++) {
    			vector.add("data" + i);
    		}
    		Long start = System.currentTimeMillis();
    		for (int i = 0; i < 100000; i++) {
    			vector.remove(i);
    		}
    		Long end = System.currentTimeMillis();
    		Long time = end - start;
    		System.out.println("time:" + time);
    	}
    
    }
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class ArrayListDemo {
    
    	public static void main(String[] args) {
    		List<String> list = new ArrayList<>();
    		for (int i = 0; i < 200000; i++) {
    			list.add("data" + i);
    		}
    		Long start = System.currentTimeMillis();
    		for (int i = 0; i < 100000; i++) {
    			list.remove(i);
    		}
    		Long end = System.currentTimeMillis();
    		Long time = end - start;
    		System.out.println("time:" + time);
    
    	}
    
    }
    

        仍然是在我自己的笔记本上,统计数据如下:

    删除1000条数据时间统计
      时间(ms) 平均(ms)
    ArrayList 71 76 68 71 76 72.4
    Vector 70 78 74 73 70 73

     

    删除1万条数据时间统计
      时间(ms) 平均(ms)
    ArrayList 455 468 470 468 464 465
    Vector 478 464 457 470 468 467.4

     

    删除10万条数据时间统计
      时间(ms) 平均(ms)
    ArrayList 2175 2181 2149 2130 2161 2159.2
    Vector 2152 2209 2202 2148 2182 2178.6

        分析上述的数据,ArrayList和Vector在删除数据方面的性能,似乎也没有太大的差距。而且,不论是ArrayList还是Vector,删除数据要比插入数据慢的多。

     

    展开全文
  • ArrayList 和Vector

    2012-11-13 22:43:15
    ArrayList 和Vector 都是使用数组方式存储数据,此数组元素数大于实际存储的数据以便增 加和插入元素,它们都允许直接按序号索引元素,但是插入元素要涉及数组元素移动等内存 操作,所以索引数据快而插入数据慢,...
    ArrayList 和Vector 都是使用数组方式存储数据,此数组元素数大于实际存储的数据以便增
    加和插入元素,它们都允许直接按序号索引元素,但是插入元素要涉及数组元素移动等内存
    操作,所以索引数据快而插入数据慢,Vector 由于使用了synchronized 方法(线程安全),
    通常性能上较ArrayList 差,而LinkedList 使用双向链表实现存储,按序号索引数据需要进
    行前向或后向遍历,但是插入数据时只需要记录本项的前后项即可,所以插入速度较快。
    展开全文
  • ArrayList和Vector 的区别

    2020-08-29 02:16:52
    ArrayList和Vector

    ArrayList和Vector都是继承AbstractList,ArrayList 是有序存储的链表结构,都可以通过下标访问数据。ArrayLsit比较新。 Vector 比较旧, Java 一出现就有了,ArrayList 是java2出现的。

    1. 首先来说 ArrayList 提供了
    private static final int DEFAULT_CAPACITY = 10;
    

    所以说也就是说ArrayList 有默认的初始大小,大小为十

    Vector 对应的地方呢

    protected int elementCount; 
    

    但是Vector提供的构造方法中

     public Vector() {
            this(10);
        }
    

    所以说Vector 的初始值也是10,当然你也可以使用其他的构造方法初始化Vector

    Vector 提供了初始化的构造方法

     public Vector(int initialCapacity, int capacityIncrement)
    

    可以初始化容量和容量增长因子

    Vector 默认增长为原来两倍,而 ArrayList 是原来的 1.5 倍

    ArrayLsit新的容量计算:

     int newCapacity = oldCapacity + (oldCapacity >> 1)
    
    1. Vector 类中都是加入synchronized 的关键字的,所以Vector 是线程安全的,而ArrayList 实体类中一个synchronized 关键字都没有, 所以Vector 的效率肯定是比ArrayList低。

      Vector:

      public synchronized int indexOf(Object o, int index) {
      

      ArrayList:

      public int indexOf(Object o) {
      
    2. 他们的最大值都是

       private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
      

      我在网上搜了一下,大致是说 减8只是为了避免一些机器内存溢出,最大长度依然是Integer.MAX_VALUE,并不是Integer.MAX_VALUE-8, 所以-8 是为减少出错的机率。

    展开全文
  • ArrayList Vector 的区别常用方法
  • ArrayList和Vector区别

    2019-03-01 18:17:47
    ArrayList和Vector区别 collection集合 ├List │├LinkedList │├ArrayList │└Vector │ └Stack └Set Map ├Hashtable ├HashMap └WeakHashMap 相同点: 1、ArrayList和Vector都是继承了相同的父类...

    ArrayList和Vector区别

    collection集合

    ├List
    │├LinkedList
    │├ArrayList
    │└Vector
    │ └Stack
    └Set

    Map
    ├Hashtable
    ├HashMap
    └WeakHashMap

    相同点:

    1、ArrayList和Vector都是继承了相同的父类(AbstractList )和实现了相同的接口(List)。
    2、底层都是数组(Object[])实现的
    3、初始默认长度都为10。

    区别:

    1、线程安全:
    Vector中的许多方法多数添加了synchronized关键字,来确保线程安全。Vector线程安全,ArrayList线程不安全。
    2、扩容方式:
    ArrayList以1.5倍的方式在扩容。Vector 当扩容容量增量大于0时、新数组长度为原数组长度+扩容容量增量、否则新数组长度为原数组长度的2倍。
    3、效率:
    如果不考虑到线程的安全因素,一般用Arraylist效率比较高。
    4、内存空间
    当Vector或ArrayList中的元素超过它的初始大小时,Vector会将它的容量翻倍,而ArrayList只增加50%的大小,这样,ArrayList就有利于节约内存空间。

    扩容方式不同

    ArrayList的扩容方法:grow()
    ArrayList以1.5倍的方式在扩容

     /**
         * Increases the capacity to ensure that it can hold at least the
         * number of elements specified by the minimum capacity argument.
         *
         * @param minCapacity the desired minimum capacity
         */
        private void grow(int minCapacity) {
            // overflow-conscious code
            int oldCapacity = elementData.length;
            int newCapacity = oldCapacity + (oldCapacity >> 1);
            if (newCapacity - minCapacity < 0)
                newCapacity = minCapacity;
            if (newCapacity - MAX_ARRAY_SIZE > 0)
                newCapacity = hugeCapacity(minCapacity);
            // minCapacity is usually close to size, so this is a win:
            elementData = Arrays.copyOf(elementData, newCapacity);
        }
    

    Vector的扩容方法:grow()
    Vector当扩容容量增量大于0时、新数组长度为原数组长度+扩容容量增量、否则新数组长度为原数组长度的2倍。

     private void grow(int minCapacity) {
            // overflow-conscious code
            int oldCapacity = elementData.length;
            int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                             capacityIncrement : oldCapacity);
            if (newCapacity - minCapacity < 0)
                newCapacity = minCapacity;
            if (newCapacity - MAX_ARRAY_SIZE > 0)
                newCapacity = hugeCapacity(minCapacity);
            elementData = Arrays.copyOf(elementData, newCapacity);
        }
    
    展开全文
  • 主要介绍了java ArrayList和Vector的区别详解的相关资料,并附简单实例代码,需要的朋友可以参考下
  • ArrayList和Vector的区别

    千次阅读 2019-05-31 09:49:20
    ArrayList和Vector的区别 ArrayList和Vector这两个集合本质上并没有什么太大的不停,他们都实现了List接口,而且底层都是基于Java数组来存储集合元素。 在ArrayList集合类的源代码中也可以看到下面一行: transient...
  • ArrayList Vector 的区别

    千次阅读 2019-05-06 10:19:33
    ArrayList Vector 的区别是什么? Vector 的方法都是同步的,线程安全;ArrayList 非线程安全,但性能比Vector好 默认初始化容量都是10,Vector 扩容默认会翻倍,可指定扩容的大小;ArrayList只增加 50% ...
  • 相同点:1、ArrayList和Vector都是继承了相同的父类和实现了相同的接口2、底层都是数组实现的3、初始默认长度都为10。不同点:1、同步性:Vector中的public方法多数添加了synchronized关键字,以确保方法同步,也即...
  • ArrayList和Vector实现类

    2017-08-10 15:08:14
    ArrayList和Vector类都是基于数组实现的List类,所以ArrayList和Vector类封装了一个动态的、允许再分配的Object[]数组。ArrayList或Vector对象使用initialCapacity参数来设置该数组的长度,当向ArrayList或Vector中...
  • ArrayList和vector的区别

    千次阅读 2019-05-18 17:52:08
    ArrayList和Vector的的相同点: 1、底层实现都是基于数组 2、理论存储最大元素容量是Integer.MAX_VALUE(2^31-1) 3、他们继承的类和实现的接口都是一样的 jdk1.8中ArrayList类的截图 jdk1.8中Vector类的截图...
  • ArrayList和Vector的区别相同点:1、ArrayList和Vector都是继承了相同的父类和实现了相同的接口2、底层都是数组实现的3、初始默认长度都为10。不同点:1、同步性:Vector中的public方法多数添加了synchronized关键字...
  • ArrayList和Vector的联系和区别 联系 ArrayList和Vector两者内部都是通过数组实现的,允许快速随机访问。 数组的缺点是每个元素之间不能有间隔,当数组大小不满足时需要增加存储能力,就要将已经有数组的数据复制到...
  • ArrayList和Vector和LinkedList的区别
  • arrayList和vector的区别

    2019-11-21 11:29:31
    arrayList和vector的区别 首先看这两类都实现List接口,而List接口一共有三个实现类,分别是ArrayList、Vector和LinkedList。List用于存放多个元素,能够维护元素的次序,并且允许元素的重复。3个具体实现类的相关...
  • Java中 ArrayList Vector

    2017-03-27 07:58:21
    Java中 ArrayList Vector
  • ArrayList Vector ArrayList 线程不安全 效率高 常用 (需要自己加锁) Vector 线程安全的 效率低(内部加锁了,很少用问)
  • ArrayList和Vector 相同点: ArrayList和Vector都实现于List接口 不同点: 1.线程安全行不同 ArrayList的add方法没有加Sychronized关键字,是线程不安全的类 Vector类是线程安全类 2.数组扩容方式不同 ...
  • ArrayList和Vector竟然又被提起

    千次阅读 2021-02-22 13:01:30
    Arraylist和vector CopyOnWriteArrayList Vector是线程同步的,可以由两个线程安全的访问一个Vector对象,但是一个线程访问Vector的话代码要在同步上消耗大量的时间。Vector扩容一次为原来的两倍 ArrayList不是同步...
  • Java ArrayList和Vector的区别ArrayList和Vector都使用了数组实现,可以认为ArrayList或Vector封装了对内部数组的操作。如添加、删除、插入等。 对ArrayList或者Vector的操作,等价于对内部对象数据的操作。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,060
精华内容 3,624
关键字:

arraylist和vector