精华内容
下载资源
问答
  • Vector底层是数组实现的List,相关的方法都加了同步检查,因此“线程安全,效率低”。 比如,indexOf方法就增加了synchronized同步标记。1、Vector的用法import java.util.Iterator; import java.util.Vector; ...

    b0db7636f5b22a22f986b9d631706e98.png

    Vector底层是用数组实现的List,相关的方法都加了同步检查,因此“线程安全,效率低”。 比如,indexOf方法就增加了synchronized同步标记。

    5dd773bc19069a3537e7bea086fc2347.png

    1、Vector的用法

    import java.util.Iterator;
    import java.util.Vector;
    
    public class TestVector {
    	
    	public static void main(String[] args) {
    		Vector vector = new Vector();
                System.out.println("集合的容量:" + vector.capacity());
               System.out.println("元素的个数:"+vector.size());
    		//添加元素
    		vector.add("hello");
    		vector.add(1, "world");
    		vector.addElement("java");
    		System.out.println(vector);		
    		//删除元素
    //		vector.remove(0);
    //		vector.remove("java");
    //		vector.removeElement("world");
    //		vector.clear();
    		
    		//获取元素
    		System.out.println(vector.get(0));
    		//遍历集合
               //建议---节约内存,Iterator对象存在周期短
    		System.out.println("------使用Iterator(for)遍历------");
    		for(Iterator iterator = vector.iterator();iterator.hasNext();){
    			System.out.println(iterator.next());
    		}
    		System.out.println("------使用Iterator(while)遍历------");
    		Iterator ite = vector.iterator();
    		while(ite.hasNext()) {
    			System.out.println(ite.next());
    		}
    	}
    }

    2、JDK源码分析

    (1)构造方法

    public Vector() {
        this(10);
    }
    public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }
    public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "
                    + initialCapacity);
       this.elementData = new Object[initialCapacity];//new Object[10];
       this.capacityIncrement = capacityIncrement;//0
    }

    (2)容量扩充

    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity 
            + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);//20
        if (newCapacity - minCapacity < 0)//健壮性
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)//健壮性
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    3、Vector与ArrayList的区别:

    (1) Vector 的 add()方法是同步方法,ArrayList 的 add() 方法是非同步方法

    (2) Vector 扩容每次扩充 1 倍 ,ArrayList 每次扩充 0. 5 倍

    (3) Vector是在调用构造方法时,直接初始化容量为10,ArrayList 是在第一次调用添加方法时,初始化容量为 10

    (4) Vector 的版本是 JDK1.0,ArrayList,JDK1.2 版

    (5) Vector 是线程同步的,安全性高,效率低, ArrayList 是线程非同步的,安全性低,效率高

    4、如何选用ArrayList、LinkedList、Vector

    1. 需要线程安全时,用Vector。

    2. 不存在线程安全问题时,并且查找较多用ArrayList(一般使用它)。

    3. 不存在线程安全问题时,增加或删除元素较多用LinkedList。

    尚学堂百战程序员

    百战程序员_IT6000集_影响6000万学习IT的中国人【官网】

    展开全文
  • ArrayList和Vector底层是动态数组,LinkedList的底层是双向链表.ArrayList和Vector的区别就是ArrayList是线程不安全的,Vector是线程安全的,Vector中的方法都是同步方法(synchronized),所以ArrayList的执行效率要...

    ArrayList,LinkedList和Vector都继承自List接口。ArrayList和Vector的底层是动态数组,LinkedList的底层是双向链表.

    ArrayList和Vector的区别就是ArrayList是线程不安全的,Vector是线程安全的,Vector中的方法都是同步方法(synchronized),所以ArrayList的执行效率要高于Vector,它也是用的最广泛的一种集合。

    我们重点比较一下ArrayList和LinkedList的区别,其实ArrayList和LinkedList之间的区别就是数组和双向链表之间的区别。

    数组的特点:因为数组分配的是一块连续的内存空间,使用索引来查找元素是非常快速的。但是插入,删除数据性能比较低。

    747b2cd258a4fb6089b9c755c7596979.png

    要把邓丽君删掉需要先把从王志文开始的元素挨个往前移,将邓丽君覆盖掉。

    再来看一下双向链表的结构:

    578b4778dc1385eb8107d876ee3a122e.png

    在该链表中每一个元素除了存储本身的内容之外还存储指向前一个元素的指针和指向后一个元素的指针,下图展示了一个包含三个元素的双向链表,每个链表都有一个头部,头部指向第一个元素,尾部元素也指向头部。

    6b5a58ed7404df255c52ee8895adcf4e.png

    双向链表的特点,查询效率较低,因为查询一个元素需要从头部开始查询,挨个遍历每一个元素直到找到所需元素,插入,删除效率高比如我们删掉一个元素直接把它前一个元素的指针指向它后一个元素就可以了:

    2994b828b3d926ff1ca10ac3c23809e6.png

    我们通过源码来比价一下这两种数据结构集合的特点

    1. 添加元素到集合尾部:List接口提供了一个方法可以将元素添加到集合的尾部boolean add(E e),ArrayList和LinkedList都实现了这个方法:

    先看ArrayList是如何实现的:

    public boolean add(E e) {
    ensureCapacityInternal(size + 1); //判断当前数组的容量是否够大如果不够大则扩容 elementData[size++] = e;//将元素添加到数组尾部return true;
    }

    这里的执行效率取决于:ensureCapacityInternal(size+ 1)方法的执行,在该方法中会判断数组容量是否足够,如果不够则进行扩容到原来的1.5倍。在扩容的过程中会生成一个新的数组,将原数组中的元素复制到新数组中。所以在这种情况下如果数组容量足够大ArrayList的效率是非常高的,我们也可以根据实际情况给它一个合适的初始值。

    再来看一下LinkedList集合:

    public boolean add(E e) {
        linkLast(e);
        return true;
    }
    void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
    l.next = newNode;
        size++;
        modCount++;
    }

    我们可以看到每新增一个元素就要创建一个Node对象,进行频繁的赋值操作 “final Node<E> newNode = new Node<>(l, e, null);”对效率有一定的影响。


    我们再来看一下在特定的位置插入元素:

    List接口中提供的方式是这样的:void add(int index,E element)

    在ArrayList中是这样实现的:

    public void add(int index, E element) {
        rangeCheckForAdd(index);
    
        ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

    从代码中我们可以看出,每插入一个元素就要进行大量元素复制操作:“System.arraycopy(elementData, index, elementData, index + 1,size - index);”

    857bee0d2cfe830ce20d172dafe1c7e7.png

    7b898c8da16c56de974b5e0d7feb450d.png

    从插入点往后的元素依次后移将新元素插入到空出来的位置上。效率非常低下。

    而在LinkedList中开销和在集合最后插入元素开销差不多,只需要把它前一个元素的指针指向自己,自己的指针指向下一个元素就可以了。

    总结一下:

    1. ArrayList和Vector结构一样都是动态数组,区别是ArrayList是线程不安全的,Vector是线程安全的,ArrayList性能好于Vector,ArrayList是应用最多的集合。

    2. ArrayList和LinkedList的区别是他们的数据结构不同,ArrayList是动态数组,LinkedList是双向链表,在查询操作较多,在特定位置插入数据和删除数据较少的情况下一般选用ArrayList,在特定位置插入数据,删除数据操作较多,查询较少的情况下一般选用LinkedList,但是在大多数应用中都是对查询效率要求较高,所以ArrayList集合应用更广泛一些。

    如果该文章对你有帮助别忘了 点赞,收藏加关注,你的支持就是我持续更新的动力!

    展开全文
  • 底层数组实现,使用默认的构造方法,初始化出来的容量10(JDK 8 无参构造容量为0) //2.扩容的长度元长度的基础上加二分之一 //3.实现了RandomAccess接口,底层有事数组,get读取元素的性能很好 //4.线程不...

    1.ArrayList的总结

          

        //1.底层数组实现,使用默认的构造方法,初始化出来的容量是10(JDK 8 无参构造容量为0)
        //2.扩容的长度是元长度的基础上加二分之一
        //3.实现了RandomAccess接口,底层有事数组,get读取元素的性能很好
        //4.线程不安全,所有的方法均不是同步方法,也没有加锁,因此,多线程下慎用
        //5.顺序添加很方便    
        //6.删除和插入需要赋值数组性能很差(可以使用LinkindList)

    ArrayList和Vector的区别

    标准答案

        //1.ArrayList是线程不安全的,Vector是线程安全的
        //2.扩容时候ArrayList扩0.5倍,Vector扩1倍
        

    那么问题来了

    ArrayList有没有办法使线程安全?

    Collection工具类有一个synchronizedList方法

    可以把list变为线程安全的集合,但是意义不大,因为可以使用Vector

    Vector为什么是线程安全的?

    老实讲,抛开线程,它们两个的区别不大,但是多线程就不一样了,nameVectyor是如何实现线程安全的,我们来看几个关键的方法

    public synchronized boolean add(E e) {
      modCount++;
      ensureCapacityHelper(elementCount + 1);
      elementData[elementCount++] = e;
      return true;
    }
    
    public synchronized E remove(int index) {
      modCount++;
      if (index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);
      E oldValue = elementData(index);
    
      int numMoved = elementCount - index - 1;
      if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
      elementData[--elementCount] = null; // Let gc do its work
    
      return oldValue;
    }

    就代码的实现上来说,和ArrayList并没有很多逻辑上的区别,但是Vector的关键方法都是用了synchronized修饰

     

    展开全文
  • List接口 有序,不唯一(java.util)API用法与ArrayList相同API用法点击此处直达底层数据结构与ArrayList相同都 Object 类型的数组Vector 与 ArrayList 的区别 :(1) Vector 的 add()方法同步方法ArrayList 的 add()...

    b6faba709d94583fe8bb75ad6f6c20ae.png

    List接口 有序,不唯一(java.util)

    API用法与ArrayList相同
    API用法点击此处直达

    底层数据结构与ArrayList相同都是 Object 类型的数组

    Vector 与 ArrayList 的区别 :

    (1)

    Vector 的 add()方法是同步方法

    ArrayList 的 add() 方法是非同步方法

    (2)

    Vector 扩容每次扩充 1 倍 ,

    ArrayList 每次扩充 0.5 倍

    (3)

    Vector 是在调用构造方法时,直接初始化容量为 10,

    ArrayList 是在第一次调用添加方法时,初始化 容量为 10

    (4)

    Vector 的版本是 JDK1.0,

    ArrayList,JDK1.2 版

    (5)

    Vector 是线程同步的,安全性高,效率低,

    ArrayList 是线程非同步的,安全性低,效率高

     public static void main(String[] args) {
        //创建了集合对象
        Vector vector=new Vector();
        System.out.println(vector.capacity()+"t集合中元素的个数:"+vector.size());
        //ArrayList al=new ArrayList();
        //al.add("hello");
        //添加
        vector.add("hello");
        vector.add(0, "world");
        vector.addElement("java"); //添加元素
        
        System.out.println(vector.capacity()+"t集合中元素的个数:"+vector.size());
        System.out.println("集合中元素的个数:"+vector.size());
        System.out.println(vector);
        //删除
        //vector.remove(1);
        //vector.remove("java");
        //vector.clear();
        //vector.removeElement("java");
        //获取元素的方法
        System.out.println(vector.get(1));
        
        System.out.println(vector);
        System.out.println("加强for循环");
        for(Object obj:vector){
          System.out.println(obj);
        }
        System.out.println("使用迭代器遍历集合:");
        for(Iterator ite=vector.iterator();ite.hasNext();){
          System.out.println(ite.next());
        }
        
        Iterator ite=vector.iterator(); 
        while(ite.hasNext()){
          System.out.println(ite.next());
        }
      }
    }

    b84f1d53471f51a5d0e18b18b4702bd8.png
    展开全文
  • 1.问题的提出 在没有了解vector之前,动态数组一般都又new创建的。在了解vector后发现vector那样方便好用,但方便的同时却以牺牲执行效率为代价的。...数组是底层数据类型,存放在栈中,其内存的分
  • vector底层数据结构动态数组,因此,vector的数据安排以及操作方式与std::array十很相似,它们间的唯一差别在于对空间的运用灵活性上。array为静态数组,有着静态数组最大的缺点:每次只能分配一定大小的存储...
  • Vector底层原理

    2020-02-18 18:20:45
    1 前言 本人使用的jdk1.8版本。 2 List集合继承结构 3 ArrayList与Vector的异同 ...ArrayList与Vector高度相似,了解下面的不同点之后可以参考ArrayList。...ArrayList和Vector底层接口都...Vector中对底层数组...
  • 实现 List 接口、底层使用数组保存所有元素,其操作基本上数组的操作,允许null值 实现了 RandmoAccess 接口,提供了随机访问功能 线程安全可见Vector,实时同步 适用于访问频繁场景,频繁插入或删除场景请...
  • 其实就底层实现来说Vector与ArrayList的实现大同小异,都使用数组作为底层的存储器,在上面进行了一些列的操作封装,而且都实现了List的数据接口。最主要的区别就是Vector的大部分操作增加了线程同步的功...
  • vector容器不但能像数组一样对元素进行随机访问,还能在尾部插入元素,一种简单,高效的容器,完全可以代替数组vector具有自动管理功能,对于元素的插入和删除,可动态调整所占的内存空间。 vector模版类需要两...
  • C++ vector底层数据结构

    2020-07-17 10:00:01
    底层数据结构是数组,由于数组的特点,vector也具有以下特性: 1、O(1)时间的快速访问; 2、顺序存储,所以插入到非尾结点位置所需时间复杂度为O(n),删除也一样; 3、扩容规则: 当我们新建一个vector的时候,会...
  • vector底层实现

    千次阅读 2014-10-24 10:04:12
    //stl库中vector是一个自动管理的动态数组; //其实只要明白vector的类型一个数组,怎么去实现它,其实就好办了;   //我选择了一种简单的方式去实现它;//定义一个步长(WALK_LENGTH); //在数组...
  • ArrayList 底层是数组特点:查询快,增删慢,线程不安全LinkList 底层是链表特点:查询慢,增删快,线程不安全Vector 底层是数组特点:查询快,增散漫,线程安全...
  • Vector底层数据结构是数组结构。 jdk1.0版本。线程安全的。 无论增删还是查询都非常慢。默认扩充为原来的2倍。ArrayList:底层数据结构是数组结构。线程不安全的。 所以ArrayList的出现替代了Vect...
  • C++ STL vector 底层原理

    2020-10-13 11:22:18
    vector是我们最经常用到的STL容器之一 其能够动态改变数组大小 比起C的数组方便了很多 三个指针 vector中有三个迭代器first,last,end, 分别指向了数组的开头, 数组的结尾+1以及数组的最大容量结尾 迭代器这里可以...
  • 前言 list 接口常见的三个实现...ArrayList 底层是可变数组,长度可变,数组长度不可变 ArrayList list = new ArrayList(); 初始化ArrayList的时候底层创建了三个变量 elementData 数组是Object[0] 数组长度为0 size 为0
  • List--Vector

    2021-01-09 17:11:14
    底层是数组实现的 public static void main(String[] args) { /** * v= new Vector<>() 在创建Vector对象时,就已经创建底层存储数组,长度为10 * Vector中的方法都是线程安全的 */ Vector<String> ...
  • 一、底层实现原理:数组(查询快,增删慢,线程安全) ... * 可以看出实现原理是数组 * @serial */ protected Object[] elementData; /** * * @serial */ protected int elementCount; /...
  • c++ 数组vector的比较

    2019-10-16 09:04:30
    数组是底层数据类型,存放在栈中,其内存的分配和释放完全由系统自动完成,效率最高; 动态数组是程序员由new运算符创建的,存放在堆中,需由delete运算符人工释放,否则会内存泄露; vector,存放在堆中,由STL库中...
  • package test_day_9; import java.util.Enumeration; import java.util.Iterator;...//Vector 底层是数组结构,查询可增删都很慢,是同步的 public class VectorDemos { public static void main(String[] args
  • java中常用的List的实现类有ArrayList、LinkedList...底层是数组结构,但是Vector是线程同步的,所以它也是线程安全的,效率比ArrayList低。 选取原则 在开发中的选取时主要考虑以下几个问题: 线程安全性问题 如果...
  • ArrayList 是 List 使用中最常用的实现类,它的底层数据结构是数组,ArrayList 查询速度快,效率高,但是增和删较慢,并且是线程不安全的集合; 基本属性 ArrayList 底层是一个数组,其默认的初始容量为10 //数据...
  • c++动态数组vector的使用

    千次阅读 2020-04-28 14:03:18
    Vector是一个封装了动态大小数组的顺序容器。跟任意其它类型容器一样,它能够存放各种类型的对象。 里面的底层实现一个顺序表结构 可以理解为一个能够存放任意类型的动态数组vector的使用 导入头文件 #...
  • 因为Vector和ArrayList除了数组扩容有点差别,还有加锁使Vector迈进了线程安全的行列外,底层实现大约没有太大区别的!基本一致!线程安全问题更另当别论了!继续往下看就OK! 扩容的区别: 从内部实现机制来讲...
  • 一般在面试中可能会被问到ArrayList、LinkedList、Vector三者相关的区别! 一般来说我想大概都会回答如下的这些:...Vector底层是数组结构,查询快,增删慢,线程安全,效率低。 以上就是最基本的一个优缺点,但...
  • 底层数据结构是数组,查询快,增删慢 线程安全,效率低 Vector类特有功能 1:添加功能 public void addElement(Object obj) -- add() 2:获取功能 public Object elementAt(int index) -- get() public...
  • 一般在面试中可能会被问到arraylist、linkedlist、vector三者相关的区别!...vector底层是数组结构,查询快,增删慢,线程安全,效率低。以上就是最基本的一个优缺点,但是他们的内部结构,具体怎么实现添...
  • R语言中的vector(向量),array(数组)总结

    万次阅读 多人点赞 2016-04-09 12:10:13
    对于那些有一点编程经验的人来说,vector,matrix,array,list,data.frame就相当于编程语言中的容器,因为只是将R看做数据处理工具所以它们的底层是靠什么实现的,内存怎么处理的具体也不要深究。 R语言很奇怪的是...
  • Vector作为List的另外一个典型实现类,完全支持List的全部功能,Vector类也封装了一个动态的,允许在分配的Object[]数组Vector是一个比较古老的集合,JDK1.0就已经存在,建议尽量不要使用这个集合,...

空空如也

空空如也

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

vector底层是数组