精华内容
下载资源
问答
  • vector和arraylist

    2017-11-12 15:47:20
    vector和arraylist 区别vector 和 arrayList 都是对一段数组进行操作, 都继承了AbstractListvector 实现的都是线程安全的 public synchronized E get(int index) public synchronized E set(int index, E element)...

    vector和arraylist 区别

    vector 和 arrayList 都是对一段数组进行操作, 都继承了AbstractList

    vector 实现的都是线程安全的

    • public synchronized E get(int index)
    • public synchronized E set(int index, E element)
    • public synchronized boolean add(E e)
    • public synchronized E remove(int index)

    ArrayList实现的是非线程安全

    • public E get(int index)
    • public E set(int index, E element)
    • public boolean add(E e)
    • public E remove(int index)
    展开全文
  • Vector和ArrayList

    2016-08-03 10:15:54
    Vector和ArrayList Vector和ArrayList在使用上非常相似,都可用来表示一组数量可变的对象应用的集合,并且可以随机地访问其中的元素。  Vector的方法都是同步的(Synchronized),是线程安全的(thread-safe),而...

    VectorArrayList VectorArrayList在使用上非常相似,都可用来表示一组数量可变的对象应用的集合,并且可以随机地访问其中的元素。 
    Vector
    的方法都是同步的(Synchronized),是线程安全的(thread-safe),而ArrayList的方法不是,由于线程的同步必然要影响性能,因此,ArrayList的性能比Vector好。
    VectorArrayList中的元素超过它的初始大小时,Vector会将它的容量翻倍,ArrayList只增加50%的大小,这样,ArrayList就有利于节约内存空间

    ArrayList
    Vector在从指定位置取得元素,从容器的末尾增加和删除元素都非常的有效,所有的这些操作都能在一个常数级的时间(O(1))内完成。但是从一个其他的位置增加和删除一个元素就显得颇为费时,差不多需要的时间为O(n-i),这里的n代表元素个数,i代表要增加和删除的元素所在的位置。这些操作需花费更多的时间,因为你需要挨个移动i和更高

    位置的元素。

    这意味着,如果你取得一个元素,或者从数组末尾增加或删除一个元素的话,随便你使用VectorArrayList。如果你想要对数组内容做其他操作的话,那么就为自己好另一个容器吧。比喻说,LinkedList可以在常数级时间(O(1))内为任意一个位置的元素增加和删除。但是,取得一个元素,会稍微慢一点,时间要用O(i) ,这个i是元素的位置。通过ArrayList也是很简单的,因为你可以简单使用一个索引,而不是构造一个iterator LinkedList也为每个插入的元素建立一个内部对象。所以,你也必须知道,同时产生了垃圾对象。

    展开全文
  • 主要介绍了java Vector和ArrayList的分析及比较的相关资料,Vector是多线程安全的,而ArrayList不是,本文主要做对比对这两个方法,需要的朋友可以参考下
  • Vector和ArrayList异同

    2018-05-23 20:52:40
    Java 中Vector和ArrayList的区别SDK提供了有序集合接口java.util.List的几种实现,其中三种最为人们熟知的是Vector、ArrayList和LinkedList。有关这些List类的性能差别是一个经常被问及的问题。在这篇文章中,我要...

    Java 中Vector和ArrayList的区别


    SDK提供了有序集合接口java.util.List的几种实现,其中三种最为人们熟知的是Vector、ArrayList和LinkedList。有关这些List类的性能差别是一个经常被问及的问题。在这篇文章中,我要探讨的就是LinkedList和Vector/ArrayList之间的性能差异。

    为全面分析这些类之间的性能差异,我们必须知道它们的实现方法。因此,接下来我首先从性能的角度出发,简要介绍这些类的实现特点。

    一、Vector和ArrayList的实现
    Vector和ArrayList都带有一个底层的Object[]数组,这个Object[]数组用来保存元素。通过索引访问元素时,只需简单地通过索引访问内部数组的元素:
    public Object get(int index)
    { //首先检查index是否合法...此处不显示这部分代码 return
    elementData[index]; }

     

    内部数组可以大于Vector/ArrayList对象拥有元素的数量,两者的差值作为剩余空间,以便实现快速添加新元素。有了剩余空间,添加元素变得非常简单,只需把新的元素保存到内部数组中的一个空余的位置,然后为新的空余位置增加索引值:
    public boolean add(Object o)
    { ensureCapacity(size + 1); //稍后介绍 elementData[size++] = o; return true;
    //List.add(Object) 的返回值 }


    把元素插入集合中任意指定的位置(而不是集合的末尾)略微复杂一点:插入点之上的所有数组元素都必须向前移动一个位置,然后才能进行赋值:
    public void add(int index, Object element) {
    //首先检查index是否合法...此处不显示这部分代码
    ensureCapacity(size+1);
    System.arraycopy(elementData, index, elementData, index + 1,
    size - index);
    elementData[index] = element;
    size++;
    }


    剩余空间被用光时,如果需要加入更多的元素,Vector/ArrayList对象必须用一个更大的新数组替换其内部Object[]数组,把所有的数组元素复制到新的数组。根据SDK版本的不同,新的数组要比原来的大50%或者100%(下面显示的代码把数组扩大100%):
    public void ensureCapacity(int minCapacity) {
    int oldCapacity = elementData.length;
    if (minCapacity > oldCapacity) {
    Object oldData[] = elementData;
    int newCapacity = Math.max(oldCapacity * 2, minCapacity);
    elementData = new Object[newCapacity];
    System.arraycopy(oldData, 0, elementData, 0, size);
    }
    }


    Vector类和ArrayList类的主要不同之处在于同步。除了两个只用于串行化的方法,没有一个ArrayList的方法具有同步执行的能力;相反,Vector的大多数方法具有同步能力,或直接或间接。因此,Vector是线程安全的,但ArrayList不是。这使得ArrayList要比Vector快速。对于一些最新的JVM,两个类在速度上的差异可以忽略不计:严格地说,对于这些JVM,这两个类在速度上的差异小于比较这些类性能的测试所显示的时间差异。

    通过索引访问和更新元素时,Vector和ArrayList的实现有着卓越的性能,因为不存在除范围检查之外的其他开销。除非内部数组空间耗尽必须进行扩展,否则,向列表的末尾添加元素或者从列表的末尾删除元素时,都同样有着优秀的性能。插入元素和删除元素总是要进行数组复制(当数组先必须进行扩展时,需要两次复制)。被复制元素的数量和[size-index]成比例,即和插入/删除点到集合中最后索引位置之间的距离成比例。对于插入操作,把元素插入到集合最前面(索引0)时性能最差,插入到集合最后面时(最后一个现有元素之后)时性能最好。随着集合规模的增大,数组复制的开销也迅速增加,因为每次插入操作必须复制的元素数量增加了。



    展开全文
  • Vector和ArrayList对比

    2018-11-30 09:44:12
    可以看到,Vector和ArrayList都实现了List和RandomAccess接口,都继承了AbstractList。通过他们的继承结构,大致可以猜测他们在元素的处理上存在很多相同的地方。 存储结构 Vector和ArrayList...

    本文会对ArrayListVector进行分析,为什么会关注这两个类,主要是因为他们拥有相同的继承结构,接下来就来探索下这两个类实现和效率的异同。

    继承结构

    可以看到,VectorArrayList都实现了ListRandomAccess接口,都继承了AbstractList。通过他们的继承结构,大致可以猜测他们在元素的处理上存在很多相同的地方。

    存储结构

    VectorArrayList都使用 Object [] elementData保存数据,但是不同的ArrayListelementData使用transient做了标记,这说明ArrayListelementData不参与对象序列化的过程。

    添加元素

    • Vector

      add(E)

      add(int, E)

      addElement(E obj)

      addAll(Collection<? extends E> c)

      addAll(int, Collection<? extends E> c)

      insertElementAt(E obj, int )
    • ArrayList

      add(E)

      add(int, E)

      addAll(Collection<? extends E> c)

      addAll(int, Collection<? extends E> c)

    在元素的添加上,VectorArrayList差不多提供了相同的接口,但是最大的不同是Vector提供的接口中,除了add(int, E)之外,都是同步接口,但是add(int, E)最终会调用同步方法insertElementAt(E obj, int ),故Vector添加元素都是同步方法;ArrayList添加元素的方法都是非同步方法。

    访问

    • Vector

      get(int index)

      elementAt(int index)
    • ArrayList

      get(int index)

    在对元素的随机访问上,VectorArrayList多了一个elementAt(int index)函数,但是elementAt(int index)get(int index)原理是一样的,故可以总结为VectorArrayList在随机访问元素时实现了同样的接口。最大的不同仍然是Vector对元素的随机访问是同步的,而ArrayList是非同步的。

    遍历

    ArrayList提供了foreach, Iterator的遍历方式,Vector除此之外还提供了另外两种遍历方式:

        Vector<String> sVector = new Vector<>();
        for (int i = 0 ; i < 5 ; i++) {
    		sVector.add("test" + i);
    	}
    	
    	sVector.forEach(new Consumer<String>() {
    		@Override
    		public void accept(String t) {
    			// TODO Auto-generated method stub
    			System.out.println(t);	
    		}
    	});
    		
    		
    	Enumeration<String> enumeration = sVector.elements();
    	while (enumeration.hasMoreElements()) {
    		System.out.println(enumeration.nextElement());
    	}
    

    Vector中,这两种方式和使用Iterator方式遍历最大的区别是他们不是同步的,主要原因是以上两种遍历方法不会在遍历过程中对集合中的数据进行修改。

    扩容

    由于使用数组存储元素,在元素不断的增加程中,VectorArrayList都需要对数组容量进行增加,在数组容量变化上,VectorArrayList选择了不一样的策略。

    • Vector
    	private void grow(int minCapacity) {
    		// overflow-conscious code
    		int oldCapacity = elementData.length;
    		int newCapacity = oldCapacity + ((capacityIncrement > 0) ?capacityIncrement : oldCapacity);
    		.......
    	}
    

    在扩容的时候,如果capacityIncrement > 0(caoaciryIncrement是新建Vector时传递的第二个参数,但是在具体使用很少使用这个参数,故大多数情况下capacityIncrement=0),则将容量增加capacityIncrement,否则容量直接增加一倍。

    • ArrayList
    	private void grow(int minCapacity) {
    		// overflow-conscious code
    		int oldCapacity = elementData.length;
    		int newCapacity = oldCapacity + (oldCapacity >> 1);
    		......
    	}
    

    ArrayList的扩容很简单,直接在原来容量的基础上增加了50%。

    效率究竟差多少

    Vector是线程安全的容器,它的很多方法都使用synchronzied方法进行了修饰,说明要使用Vector实例,需要先获得锁,这一过程比较耗时,但是究竟能耗时多少,是不是比ArrayList耗时很多?本文不打算去测试在多线程环境下两者的对比,因为在使用ArrayList的时候,大多数场景是单线程的环境,本文就在单线程的环境中对VectorArrayList进行对比,这种对比不是精确的对比,只是对比一下快慢。本文从添加,遍历和随机访问三个方面进行对比。测量的方法比较简单,就是先向集合中添加元素,然后再去遍历元素,最后分别统计添加元素,遍历元素和随机访问的耗时,测试的java环境是jdk1.8.0_181。

    • Vector
    	long start = System.currentTimeMillis();
    	for (int i = 0 ; i < 500000 ; i++) {
    		sVector.add("qiwoo_test_add" + i);
    	}
    	long end = System.currentTimeMillis();
    	System.out.println("vector add time consuming:" + (end - start));
    
    	Iterator<String> iterator = sVector.iterator();
    	long visitStart = System.currentTimeMillis();
    	while (iterator.hasNext()) {
    		String str = iterator.next();
    	}
    	long visitEnd = System.currentTimeMillis();
    	System.out.println("vector visit time consuming:" + (visitEnd -visitStart));
    		
    	long randAccessStart = System.currentTimeMillis();
    	for (int i = 0 ; i < 500000 ; i++) {
    		sVector.get(i);
    	}
    	long randAccessend = System.currentTimeMillis();
    	System.out.println("vector random access time consuming:" +(randAccessend - randAccessStart));
    

    在我的电脑上,运行的结果如下:

    vector add time consuming:95

    vector visit time consuming:18

    vector random access time consuming:14

    • ArrayList
    	long start = System.currentTimeMillis();
    	for (int i = 0 ; i < 500000 ; i++) {
    		sArray.add("qiwoo_test_add" + i);
    	}
    	long end = System.currentTimeMillis();
    	System.out.println("array add time consuming:" + (end - start));
    	
    	
    	
    	Iterator<String> iterator = sArray.iterator();
    	long visitStart = System.currentTimeMillis();
    	while (iterator.hasNext()) {
    		String str = iterator.next();
    	}
    	long visitEnd = System.currentTimeMillis();
    	System.out.println("array visit time consuming:" + (visitEnd -visitStart));
    	
    	long randAccessStart = System.currentTimeMillis();
    	for (int i = 0 ; i < 500000 ; i++) {
    		sArray.get(i);
    	}
    	long randAccessend = System.currentTimeMillis();
    	System.out.println("array random access time consuming:" +(randAccessend - randAccessStart));
    		
    

    在我的电脑上运行结果如下:

    array add time consuming:82

    array visit time consuming:11

    array random access time consuming:5

    上面的结果可以发现,在单线程环境下,在元素添加和遍历上,Vector均比ArrayList慢了一些,其中添加元素慢了8%左右,遍历元素慢了64%,随机访问慢了1.8倍,这些数据可能受数据量的不同而不同,但是整体的趋势应该是一致的。


    以上测试的时候,数据量为500000,但是实际进行Android开发的过程中产生的数据量比较少,参考下google设计容器时的数量考虑,接下来把数据量设置为1000,看下运行结果的差异

    • Vector

      vector add time consuming:2

      vector visit time consuming:1

      array random access time consuming:0
    • ArrayList

      array add time consuming:2

      array visit time consuming:1

      array random access time consuming:0

    当数据量到1000时,VectorArrayList在元素的添加,遍历和随机访问上已经没有什么性能差异或者说差异很小。

    总结

    ArrayListVector都是java中比较重要的容器,他们都可以存储各种对象,它们有相同的继承结构,提供大致相同的功能,主要的差异点如下:

    • Vector是线程安全的容易,可以在并发环境中安全地使用,而ArrayList是非线程安全的
    • ArrayList进行扩容时增加50%,Vector提供了扩容时的增量设置,但通常将容量扩大1倍
    • Vector可以使用Enumeration和Iterator进行元素遍历,ArrayList只提供了Iterator的方式
    • 由于使用的线程同步,Vector的效率比ArrayList

    自java1.6之后,为了优化synchronized,java引入了偏向锁,在单线程环境中,Vector的效率已经被提高了。从刚才的对比也可以发现,在单线程环境中,数据量较少(测试数据量在100000性能差异较小)的情况下,VectorArrayList的性能差异已经不明显了。

    关注微信公众号,最新技术干货实时推送

    image

    展开全文
  • 继承结构可以看到,Vector和ArrayList都实现了List和RandomAccess接口,都继承了AbstractList。通过他们的继承结构,大致可以猜测他们在元素的处理上存在很多相同的地方。存储结构Vector和ArrayList都使用 O...
  • Vector和ArrayList的区别

    2014-11-16 14:40:11
    Vector和ArrayList
  • 主要为大家详细介绍了Java中Vector和ArrayList的区别,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 首先看这两类都实现List接口,而List接口一共有三个实现类,分别是ArrayListVector和LinkedList。List用于存放多个元素,能够维护元素的次序,并且允许元素的重复。3个具体实现类的相关区别如下:ArrayList是最...
  • vector ArrayList

    千次阅读 2005-05-21 15:26:00
    英文原文:...采用Vector还是ArrayList,应该考虑以下4个因素:Synchronization Vector是Synchronized, 它的所有方法都是thread safe的。ArrayList是unsynchronized。所以,如果带抹布需
  • Vector和ArrayList异同如下存储方式看Vector与ArrayList想相比 vector的安全系数更高ArrayList的采用数组的方式实现存储数据,实现了可以改变数组的大小 ,它允许然后元素 (包括null)特点:(1)ArrayList没有同步...
  • 主要介绍了Java中的Vector和ArrayList区别及比较,本文从API、同步、数据增长、使用模式4个方面总结了它们之间的不同之处,需要的朋友可以参考下
  • Vector和ArrayList比较

    2015-09-19 09:01:15
    Vector和ArrayList的源码的分析: 今天研究了一下Vector和ArrayList的源码,又加深了对这两个类的理解。 List接口下一共实现了三个类:ArrayList,Vector,LinkedList。LinkedList就不
  • Vector和ArrayList的比较

    2017-03-06 21:11:20
    Vector和ArrayList的比较
  • 浅谈Vector和ArrayList的区别 联系 Vector与ArrayList本质上都是一个Object[] 数组,ArrayList提供了size属性,Vector提供了elementCount属性,他们的作用是记录集合内有效元素的个数。 与我们平常调用的arrayList....
  • 参考:Java中Vector和ArrayList的区别
  • vector和arrayList的区别

    2017-09-17 20:13:39
    转载自:http://www.cnblogs.com/plmnko/archive/2010/10/10/1847362.html AND http://blog.csdn.net/tayanxunhua/article/details/10037403 ...首先Vector和ArrayList都是基于数组实现的。他们的不同
  • Vector和ArrayList区别

    2014-05-23 22:33:00
    Vector和ArrayList在使用上非常相似,都可用来表示一组数量可变的对象应用的集合,并且可以随机地访问其中的元素。 Vector的方法都是同步的(Synchronized),是线程安全的(thread-safe),而ArrayList的方法不是,...
  • Vector和ArrayList的联系和区别 1、联系:  实用原理相同  功能相同  都是长度可变的数组结构,很多情况下可以互用 2、两者的主要区别:   转载于:...

空空如也

空空如也

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

vector和arraylist