java集合(二)List集合之Vector详解

简介
Vector的内部实现类似于ArrayList,Vector也是基于一个容量能够动态增长的数组来实现的,该类是JDK1.0版本添加的类,它的很多实现方法都加入了同步语句,因此是线程安全的(但Vector其实也只是相对安全,有些时候还是要加入同步语句来保证线程的安全,我们后面会有例子来说明这一点)。

Vector类声明如下

public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable

Vector继承于AbstractList,实现了List、RandomAccess、Cloneable、 Serializable等接口。

ArrayList实现了List接口,可以对它进行队列操作;实现了RandmoAccess接口,即提供了随机访问功能;实现了Cloneable接口,能被克隆;实现了Serializable接口,因此它支持序列化,能够通过序列化传输。

Vector源码详解
Vector内部通过一个Object数组来存储数据:

protected Object[] elementData;

Vector使用elementCount变量来表示实际存储的元素个数:

protected int elementCount;

Vector有四个构造方法:

// 创建一个空的Vector,并且指定了Vector的初始容量和扩容时的增长系数
public Vector(int initialCapacity, int capacityIncrement) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                            initialCapacity);
    this.elementData = new Object[initialCapacity];
    this.capacityIncrement = capacityIncrement;
}

// 创建一个空的Vector,并且指定了Vector的初始容量
public Vector(int initialCapacity) {
    this(initialCapacity, 0);
}

// 创建一个空的Vector,并且指定了Vector的初始容量为10
public Vector() {
    this(10);
}

// 根据其他集合来创建一个非空的Vector
public Vector(Collection<? extends E> c) {
    elementData = c.toArray();
    elementCount = elementData.length;
    // c.toArray might (incorrectly) not return Object[] (see 6260652)
    if (elementData.getClass() != Object[].class)
        elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
}

我们下面主要来看一看Vector的add和remove方法

add方法

Vector有两个重载的Add方法:

// 在数组elementData尾部添加一个元素
public synchronized boolean add(E e)
// 在数组elementData指定位置index处添加元素
public void add(int index, E element)
add(E e)方法

add(E e)方法源码如下:

// 在数组elementData尾部添加一个元素
public synchronized boolean add(E e) {
    modCount++;
    // 容量大小判断
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = e;
    return true;
}

该方法首先要判断elementData数组的容量是否能够容纳新的元素,若不能,则需要进行扩容操作,然后将元素e放置在数组的size位置。ensureCapacityHelper(int)方法源码如下:

private void ensureCapacityHelper(int minCapacity) {
    // overflow-conscious code
    // 增加元素后,ArrayList中要存储的元素个数为minCapacity
    // 若此时minCapacity > elementData原始的容量,则要按照minCapacity进行扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

扩容的最终操作是通过grow(int)方法来实现的:

private void grow(int minCapacity) {
    // overflow-conscious code
    // 获取elementData的原始容量
    int oldCapacity = elementData.length;
    // 计算新的容量
    // 如果在构造方法中设置了capacityIncrement > 0,那么新数组长度就是原数组长度 + capacityIncrement
    // 否则,新数组长度就是原数组长度 * 2
    int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                        capacityIncrement : oldCapacity);
    // 若进行扩容后,capacity仍然比实际需要的小,则新容量更改为实际需要的大小,即minCapacity
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    // 如果新数组的长度比虚拟机能够提供给数组的最大存储空间大,则将新数组长度更改为最大正数:Integer.MAX_VALUE
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // 按照新的容量newCapacity创建一个新数组,然后再将原数组中的内容copy到新数组中
    elementData = Arrays.copyOf(elementData, newCapacity);
}

和ArrayList的扩容步骤很相似,这里不再介绍。

add(int index, E element)方法

add(int index, E element)方法源码如下:

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

该方式其实是调用了insertElementAt方法:

public synchronized void insertElementAt(E obj, int index) {
    // fail-fast机制
    modCount++;
    // 判断index下标的合法性
    if (index > elementCount) {
        throw new ArrayIndexOutOfBoundsException(index
                                                    + " > " + elementCount);
    }
    // 判断容量大小
    ensureCapacityHelper(elementCount + 1);
    // 数组拷贝,将index到末尾的元素拷贝到index + 1到末尾的位置,将index的位置留出来
    System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
    elementData[index] = obj;
    elementCount++;
}

remove方法

remove方法在Vector中同样有两种实现方式:

// 根据元素删除
public boolean remove(Object o)
// 根据index下标删除元素
public synchronized E remove(int index)

我们先看remove(Object o)方法。

remove(Object o)方法

remove(Object o)方法源码如下:

public boolean remove(Object o) {
    return removeElement(o);
}

其内部通过removeElement方法来删除元素:

public synchronized boolean removeElement(Object obj) {
    // fail-fast机制
    modCount++;
    // 查找元素obj在数组中的下标
    int i = indexOf(obj);
    // 若下标 >= 0
    if (i >= 0) {
        // 调用removeElementAt(int)方法删除元素
        removeElementAt(i);
        return true;
    }
    return false;
}

我们先来看indexOf(Object)方法:

public int indexOf(Object o) {
    return indexOf(o, 0);
}
public synchronized int indexOf(Object o, int index) {
    // 若要查找的元素为null
    if (o == null) {
        for (int i = index ; i < elementCount ; i++)
            if (elementData[i]==null)
                return i;
    }
    // 若要查找的元素不为null
    else {
        for (int i = index ; i < elementCount ; i++)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

Vector查找元素时,是分为元素为null和不为null两种方式来判断的,这也说明Vector允许添加null元素;同时,如果这个元素在Vector中存在多个,则只会找出从index开始,最先出现的那个。

找到元素对应的下标,若下标 >= 0,则说明元素在数组中存在,然后通过removeElementAt(int)方法来删除元素,removeElementAt(int)方法源码如下:

public synchronized void removeElementAt(int index) {
    modCount++;
    // index下标合法性检验
    if (index >= elementCount) {
        throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                                    elementCount);
    }
    else if (index < 0) {
        throw new ArrayIndexOutOfBoundsException(index);
    }
    // 要移动的元素个数
    int j = elementCount - index - 1;
    if (j > 0) {
        // 将index之后的元素向前移动一位
        System.arraycopy(elementData, index + 1, elementData, index, j);
    }
    elementCount--;
    elementData[elementCount] = null; /* to let gc do its work */
}
remove(int index)方法

remove(int index)方法源码如下:

public synchronized E remove(int index) {
    modCount++;
    // index下标合法性检验
    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;
}

Vector的相对线程安全

我们前面说过Vector是相对线程安全的,为什么这么说呢?

我们看下面一段代码:

public class VectorTest {
    static class MyThread extends Thread {
        private CountDownLatch countDownLatch;
        private Vector<String> vector;
        private String element;

        public MyThread(CountDownLatch countDownLatch, Vector<String> vector, String element) {
            this.countDownLatch = countDownLatch;
            this.vector = vector;
            this.element = element;
        }

        @Override
        public void run() {
            super.run();

            try {
                if (!vector.contains(element)) {
                    // 注意这里
                    Thread.sleep(1000);
                    vector.add(element);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                countDownLatch.countDown();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(2);
        Vector<String> vector = new Vector<>();

        MyThread myThread1 = new MyThread(countDownLatch, vector, "abc");
        MyThread myThread2 = new MyThread(countDownLatch, vector, "abc");

        myThread1.start();
        myThread2.start();

        countDownLatch.await();

        int vectorSize = vector.size();
        System.out.println("vector size: " + vectorSize);
        for (int i = 0; i < vectorSize; i++) {
            System.out.println("index " + i + ": " + vector.get(i));
        }
    }
}

运行结果(不唯一):

vector size: 2
index 0: abc
index 1: abc

注意注释处的一段代码,该段代码是判断元素element是否存在,不存在的话,则将其添加到vector之中,如果线程1和线程2同时运行该段代码,设想一下如下情景:

线程1通过vector.contains(element)同步方法来判断元素是否存在,此时,该方法返回false,即表明线程1可以将element元素插入Vector中;但是运行完该方法之后,线程1开始sleep,那这时,线程2开始运行vector.contains(element)同步方法,该方法仍然返回了false,即线程2可以将element元素插入Vector中,然后线程2开始sleep,最终结果,就是线程1和线程2都将元素“abc”添加到了vector之中,这就是我们为什么说Vector是相对线程安全的了。

要解决该问题,需要我们在自己的业务代码代码中进行同步控制,比如将那一段代码修改为如下:

synchronized (vector) {
    if (!vector.contains(element)) {
        Thread.sleep(1000);
        vector.add(element);
    }
}

则程序运行结果为:

vector size: 1
index 0: abc

可以看到,这才是我们预期的结果。

原文地址:https://www.cnblogs.com/yuexiaoyun/p/12056926.html

时间: 2024-11-09 00:50:36

java集合(二)List集合之Vector详解的相关文章

Java基础13:反射与注解详解

Java基础13:反射与注解详解 什么是反射? 反射(Reflection)是Java 程序开发语言的特征之一,它允许运行中的 Java 程序获取自身的信息,并且可以操作类或对象的内部属性. Oracle官方对反射的解释是 Reflection enables Java code to discover information about the fields, methods and constructors of loaded classes, and to use reflected fi

Android 开源框架Universal-Image-Loader完全解析(二)--- 图片缓存策略详解

本篇文章继续为大家介绍Universal-Image-Loader这个开源的图片加载框架,介绍的是图片缓存策略方面的,如果大家对这个开源框架的使用还不了解,大家可以看看我之前写的一篇文章Android 开源框架Universal-Image-Loader完全解析(一)--- 基本介绍及使用,我们一般去加载大量的图片的时候,都会做缓存策略,缓存又分为内存缓存和硬盘缓存,我之前也写了几篇异步加载大量图片的文章,使用的内存缓存是LruCache这个类,LRU是Least Recently Used 近

Java的String和StringBuffer和StringBuilder详解

Java的String和StringBuffer和StringBuilder详解 作者:chszs,转载需注明.博客主页:http://blog.csdn.net/chszs 前言 最近发现团队成员在Java代码方面的质量不够高,准备写一些基础的文章,供大家参考. 一.定义 String是不可变字符序列. StringBuffer是可变的字符序列. StringBuilder也是可变的字符序列. 1.StringBuffer和StringBuilder的唯一区别 StringBuffer对象是线

java笔记--反射进阶之总结与详解

一.反射进阶之动态设置类的私有域 "封装"是Java的三大特性之一,为了能更好保证其封装性,我们往往需要将域设置成私有的, 然后通过提供相对应的set和get方法来操作这个域.但是我们仍然可以用java的反射机制来 修改类的私有域,由于修改类的私有域会破坏Java"封装"的特性,故请慎重操作. 主要技术:     Field类提供有关类或接口的单个字段的信息,以及对它的动态访问权限.     访问的字段可能是一个类(静态)字段或实例字段.             常

“全栈2019”Java异常第九章:throws关键字详解

难度 初级 学习时间 10分钟 适合人群 零基础 开发语言 Java 开发环境 JDK v11 IntelliJ IDEA v2018.3 文章原文链接 "全栈2019"Java异常第九章:throws关键字详解 下一章 "全栈2019"Java异常第十章:throw与throws区别详解 学习小组 加入同步学习小组,共同交流与进步. 方式一:关注头条号Gorhaf,私信"Java学习小组". 方式二:关注公众号Gorhaf,回复"Ja

“全栈2019”Java异常第十八章:Exception详解

难度 初级 学习时间 10分钟 适合人群 零基础 开发语言 Java 开发环境 JDK v11 IntelliJ IDEA v2018.3 文章原文链接 "全栈2019"Java异常第十八章:Exception详解 下一章 "全栈2019"Java异常第十九章:RuntimeException详解 学习小组 加入同步学习小组,共同交流与进步. 方式一:关注头条号Gorhaf,私信"Java学习小组". 方式二:关注公众号Gorhaf,回复&quo

Java深入学习11:Lock锁详解

Java深入学习11:Lock锁详解 一.Lock锁是什么 java.util.concurrent.locks包下常用的类与接口(lock是jdk 1.5后新增的) Lock 接口支持那些语义不同(重入.公平等)的锁规则,可以在非阻塞式结构的上下文(包括 hand-over-hand 和锁重排算法)中使用这些规则.主要的实现是 ReentrantLock. Lock 实现提供了比 synchronized 关键字 更广泛的锁操作,它能以更优雅的方式处理线程同步问题.也就是说,Lock提供了比s

Java知多少(54)断言详解

断言的概念 断言用于证明和测试程序的假设,比如“这里的值大于 5”.断言可以在运行时从代码中完全删除,所以对代码的运行速度没有影响. 断言的使用 断言有两种方法: 一种是 assert<<布尔表达式>> : 另一种是 assert<<布尔表达式>> :<<细节描述>>. 如果布尔表达式的值为false , 将抛出AssertionError 异常: 细节描述是AssertionError异常的描述文本使用 javac –source

Java知多少(41)泛型详解

我们知道,使用变量之前要定义,定义一个变量时必须要指明它的数据类型,什么样的数据类型赋给什么样的值. 假如我们现在要定义一个类来表示坐标,要求坐标的数据类型可以是整数.小数和字符串,例如: 1 x = 10.y = 10 2 x = 12.88.y = 129.65 3 x = "东京180度".y = "北纬210度" 针对不同的数据类型,除了借助方法重载,还可以借助自动装箱和向上转型.我们知道,基本数据类型可以自动装箱,被转换成对应的包装类:Object 是所有

java定时任务类Timer和TimerTask用法详解

原文:java定时任务类Timer和TimerTask用法详解 代码下载地址:http://www.zuidaima.com/share/1550463277550592.htm package com.zuidaima.util; import java.io.IOException; import java.util.Timer; import test.MyTask; /* * 本类给出了使用Timer和TimerTaske的主要方法,其中包括定制任务,添加任务 * 退出任务,退出定时器.