精华内容
下载资源
问答
  • ArrayList Vector 的区别

    千次阅读 2019-05-06 10:19:33
    ArrayList Vector 的区别是什么? Vector 的方法都是同步的,线程安全;ArrayList 非线程安全,但性能比Vector好 默认初始化容量都是10,Vector 扩容默认会翻倍,可指定扩容的大小;ArrayList只增加 50% ...

    ArrayList 和 Vector 的区别是什么?

    • Vector 的方法都是同步的,线程安全;ArrayList 非线程安全,但性能比Vector好
    • 默认初始化容量都是10,Vector 扩容默认会翻倍,可指定扩容的大小;ArrayList只增加 50%

     


    【Java面试题与答案】整理推荐

     

    展开全文
  • ArrayList和Vector的区别

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

    ArrayList和Vector的区别

    ArrayList和Vector这两个集合本质上并没有什么太大的不停,他们都实现了List接口,而且底层都是基于Java数组来存储集合元素。

    在ArrayList集合类的源代码中也可以看到下面一行:

        transient Object[] elementData; // non-private to simplify nested class access
    

    在Vector集合类的源代码中也可以看到类似的一行:

        protected Object[] elementData;
    

    从上面的代码中可以看出,ArrayList使用transient修饰了elementData数组,这保证系统序列化ArrayList对象时不会直接序列化elementData数组,而是通过ArrayList提供的writeObject、readObject方法来实现定制序列化;

    但对于Vector而言,它没有使用transient修饰elementData数据,而且Vector只提供了一个writeObject方法,并未完全实现订制序列化。

    从序列化机制的角度来看,ArrayList的实现比Vector的实现更安全。

    除此之外,Vector其实就是ArrayList的线程安全版本,ArrayList和Vector绝大部分方法都是相同的,只是Vector的方法增加了synchronized修饰。

    下面先来看ArrayList中的add(int index,E element)方法的源代码。

          public void add(int index, E element) {
            //检查是否下标越界
            rangeCheckForAdd(index);
            //保证ArrayList底层的数组可以保存所有集合元素
            ensureCapacityInternal(size + 1);  // Increments modCount!!
            //将elementData数组中的index位置之后的所有元素向后移动一位
            //也就是将elementData数组的index位置的元素空出来
            System.arraycopy(elementData, index, elementData, index + 1,
                             size - index);
            //将新元素将入elementData数组的index的位置
            elementData[index] = element;
            size++;
        }
    

    再来看Vector中的add(int index,E element)方法的源代码:

         public void add(int index, E element) {
            insertElementAt(element, index);
        };
    

    从上面可以看出,Vector的add(int index,E element)方法其实就是insertElementAt(int index,E element).

    接着来看insertElementAt(int index,E element)的源码。

           public synchronized void insertElementAt(E obj, int index) {
           //增加集合的修改次数
           modCount++;
           //如果添加位置大于集合长度,则抛出异常
           if (index > elementCount) {
               throw new ArrayIndexOutOfBoundsException(index
                                                        + " > " + elementCount);
           }
           //保证Vector底层的数组可以保存所有集合元素
           ensureCapacityHelper(elementCount + 1);
            //将elementData数组中的index位置之后的所有元素向后移动一位
           //也就是将elementData数组的index位置的元素空出来
           System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
             //将新元素将入elementData数组的index的位置
           elementData[index] = obj;
           elementCount++;
       }
    
    

    将ArrayList中的add(int index,E element)方法和Vector的insertElementAt(int index,E element)方法进行对比,可以发现Vector的insertElementAt(int index,E element)方法只是多了个synchronized修饰,而且多了一行代码modCount++,这并不代表ArrayList中的add(int index,E element)方法没有这行代码,ArrayList只是将这行代码放在ensureCapacityInternal中完成。

    接下来我们看ensureCapacityInternal(int minCapacity)方法的源码:

        private void ensureCapacityInternal(int minCapacity) {
            //当elementData数组为空,如果传进来的minCapacity<=10时,minCapacity取10,否则取传进来的参数
            if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
                minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
            }
    
            ensureExplicitCapacity(minCapacity);
        }
    
        private void ensureExplicitCapacity(int minCapacity) {
            modCount++;
    
            // overflow-conscious code
            //如果minCapacity大于原数组的长度,则需要扩容
            if (minCapacity - elementData.length > 0)
                grow(minCapacity);
        }
       private void grow(int minCapacity) {
            // overflow-conscious code
            int oldCapacity = elementData.length;
            //将新容量扩充为原来的1.5倍
            int newCapacity = oldCapacity + (oldCapacity >> 1);
            //如果新的newCapacity依然小于minCapacity,直接将minCapacity赋值给newCapacity
            if (newCapacity - minCapacity < 0)
                newCapacity = minCapacity;
            //如果新的newCapacity超过最大的数组长度,则进行更大的扩容 
            if (newCapacity - MAX_ARRAY_SIZE > 0)
                newCapacity = hugeCapacity(minCapacity);
            // minCapacity is usually close to size, so this is a win:
            //通过Arrays.copyOf扩充一个新数组,数组的长度为newCapacity
            elementData = Arrays.copyOf(elementData, newCapacity);
        }
    
         private void ensureCapacityHelper(int minCapacity) {
            // overflow-conscious code
              //如果minCapacity大于原数组的长度,则需要扩容
            if (minCapacity - elementData.length > 0)
                grow(minCapacity);
        }
        private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    
        private void grow(int minCapacity) {
            // overflow-conscious code
            int oldCapacity = elementData.length;
            //如果capacityIncrement大于0,则新的newCapacity等于旧的oldCapacity加上capacityIncrement,
            //如果不是,则新的newCapacity等于旧的oldCapacity*2,表示扩容两倍
            int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                             capacityIncrement : oldCapacity);
             //如果新的newCapacity依然小于minCapacity,直接将minCapacity赋值给newCapacity           
            if (newCapacity - minCapacity < 0)
                newCapacity = minCapacity;
            //如果新的newCapacity超过最大的数组长度,则进行更大的扩容
            if (newCapacity - MAX_ARRAY_SIZE > 0)
                newCapacity = hugeCapacity(minCapacity);
            //通过Arrays.copyOf扩充一个新数组,数组的长度为newCapacity    
            elementData = Arrays.copyOf(elementData, newCapacity);
        }
    

    将ArrayList中的ensureCapacityInternal和Vector中的ensureCapacityHelper方法进行对比,可以发现这两个方法几乎完全相同,只是在扩充底层数组的容量时略有区别而已。ArrayList总是将底层数组的容量扩充为原来的1.5倍,但Vector则多了一个选择。

    当capacityIncrement大于0时,扩充后的容量等于原来的容量加上这个capacityIncrement的值,如果不是大于0,则扩充为原来容量的2倍。

    Vector的ensureCapacityHelper方法在扩充数组容量时多一个选择是因为,创建Vector可以传入一个capacityIncrement参数,如下构造方法:

    Vector(int initialCapacity, int capacityIncrement):以initialCapacity作为底层数组的初始长度,以capacityIncrement作为扩充数组时的增大步长来创建Vector对象。

    但是对于ArrayList而言,它的构造方法最多只能指定一个initialCapacity参数。

    注意

    即使需要在多线程环境下使用List集合,而且需要保证List集合的线程安全,依然可以避免使用Vector,而是考虑将ArrayList包装成线程安全的集合类。Java提供了一个Collections工具类,通过该工具synchronizedList方法可以将一个普瑞的ArrayList包装成线程安全的ArrayList。

    展开全文
  • arrayList和vector的区别

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

    arrayList和vector的区别

    首先看这两类都实现List接口,而List接口一共有三个实现类,分别是ArrayList、Vector和LinkedList。List用于存放多个元素,能够维护元素的次序,并且允许元素的重复。3个具体实现类的相关区别如下:

        1.  ArrayList是最常用的List实现类,内部是通过数组实现的,它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔,当数组大小不满足时需要增加存储能力,就要讲已经有数组的数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时,需要对数组进行复制、移动、代价比较高。因此,它适合随机查找和遍历,不适合插入和删除。
        2.  Vector与ArrayList一样,也是通过数组实现的,不同的是它支持线程的同步,即某一时刻只有一个线程能够写Vector,避免多线程同时写而引起的不一致性,但实现同步需要很高的花费,因此,访问它比访问ArrayList慢。
        3.  LinkedList是用链表结构存储数据的,很适合数据的动态插入和删除,随机访问和遍历速度比较慢。另外,他还提供了List接口中没有定义的方法,专门用于操作表头和表尾元素,可以当作堆栈、队列和双向队列使用。
        4.  vector是线程(Thread)同步(Synchronized)的,所以它也是线程安全的,而Arraylist是线程异步(ASynchronized)的,是不安全的。如果不考虑到线程的安全因素,一般用Arraylist效率比较高。
    
        5. 如果集合中的元素的数目大于目前集合数组的长度时,vector增长率为目前数组长度的100%,而arraylist增长率为目前数组长度
        的50%.如过在集合中使用数据量比较大的数据,用vector有一定的优势。
    
        6. 如果查找一个指定位置的数据,vector和arraylist使用的时间是相同的,都是0(1),这个时候使用vector和arraylist都可以。而
        如果移动一个指定位置的数据花费的时间为0(n-i)n为总长度,这个时候就应该考虑到使用Linkedlist,因为它移动一个指定位置的数据
        所花费的时间为0(1),而查询一个指定位置的数据时花费的时间为0(i)。
        ArrayList 和Vector是采用数组方式存储数据,此数组元素数大于实际存储的数据以便增加和插入元素,
        都允许直接序号索引元素,但是插入数据要设计到数组元素移动 等内存操作,所以索引数据快插入数据慢,
        Vector由于使用了synchronized方法(线程安全)所以性能上比ArrayList要差
        ,LinkedList使用双向链表实现存储,按序号索引数据需要进行向前或向后遍历,但是插入数据时只需要记录本项的前后项即可,所以插入数度较快!
    
        7. 笼统来说:LinkedList:增删改快
                      ArrayList:查询快(有索引的存在)
    
    1. Vector & ArrayList

    1) Vector的方法都是同步的(Synchronized),是线程安全的(thread-safe),而ArrayList的方法不是,由于线程的同步必然要影响性能,因此,ArrayList的性能比Vector好。
    2) 当Vector或ArrayList中的元素超过它的初始大小时,Vector会将它的容量翻倍,而ArrayList只增加50%的大小,这样,ArrayList就有利于节约内存空间。

    1. Hashtable & HashMap
      Hashtable和HashMap它们的性能方面的比较类似 Vector和ArrayList,比如Hashtable的方法是同步的,而HashMap的不是。

    2. ArrayList & LinkedList

    ArrayList的内部实现是基于内部数组Object[],所以从概念上讲,它更象数组,但LinkedList的内部实现是基于一组连接的记录,所以,它更象一个链表结构,所以,它们在性能上有很大的差别:
    从上面的分析可知,在ArrayList的前面或中间插入数据时,你必须将其后的所有数据相应的后移,这样必然要花费较多时间,所以,当你的操作是在一列 数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能; 而访问链表中的某个元素时,就必须从链表的一端开始沿着连接方向一个一个元素地去查找,直到找到所需的元素为止,所以,当你的操作是在一列数据的前面或中 间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。

    如果在编程中,1、2两种情形交替出现,这时,你可以考虑使用List这样的通用接口,而不用关心具体的实现,在具体的情形下,它的性能由具体的实现来保证。

    1. 配置集合类的初始大小
      在Java集合框架中的大部分类的大小是可以随着元素个数的增加而相应的增加的,我们似乎不用关心它的初始大小,但如果我们考虑类的性能问题时,就一定要考虑尽可能地设置好集合对象的初始大小,这将大大提高代码的性能。
      比如,Hashtable缺省的初始大小为101,载入因子为0.75,即如果其中的元素个数超过75个,它就必须增加大小并重新组织元素,所以,如果你 知道在创建一个新的Hashtable对象时就知道元素的确切数目如为110,那么,就应将其初始大小设为110/0.75=148,这样,就可以避免重 新组织内存并增加大小。

    转自:the following is from:http://blessed24.javaeye.com/blog/751336

    展开全文
  • 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的区别

    千次阅读 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的区别

    2020-11-09 16:44:42
    arraylist是不同步的,线程不安全的,可能出现多个线程同时更改一个arraylist的情况,vector是线程同步的,是安全的 vector的线程同步也带来一些弊端,在只有一个线程时,维护同步需要消耗一定的资源 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,977
精华内容 1,590
关键字:

arraylist和vector的区别