vector

作者: 初阳拾叁 | 来源:发表于2019-08-13 22:45 被阅读0次

1.静态变量和成员变量

 /**
     * 基础数据结构
     */
    protected Object[] elementData;

    /**
     * 数据个数
     */
    protected int elementCount;

    /**
     * 数据增长个数
     */
    protected int capacityIncrement;

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -2767605614048989439L;

2. 构造方法

   /**
     * 两个参数的构造方法,第一个是默认大小,第二个是每次增长大小
     */
    public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }

    /**
     * 只有初始大小的构造方法,默认增长大小为0(这是每次增长为初始大小,即每次增长一倍)
     */
    public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }

    /**
     *默认构造方法,默认初始大小为10 ,增长大小为10
     */
    public Vector() {
        this(10);
    }

    /**
     * 传入集合的构造方法,默认大小为传入集合的大小,增长大小为传入集合大大小
     */
    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);
    }

3.增删改查

 /**
     * Returns the element at the specified position in this Vector.
     *
     * @param index index of the element to return
     * @return object at the specified index
     * @throws ArrayIndexOutOfBoundsException if the index is out of range
     *            ({@code index < 0 || index >= size()})
     * @since 1.2
     */
    public synchronized E get(int index) {
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);

        return elementData(index);
    }

    /**
     * Replaces the element at the specified position in this Vector with the
     * specified element.
     *
     * @param index index of the element to replace
     * @param element element to be stored at the specified position
     * @return the element previously at the specified position
     * @throws ArrayIndexOutOfBoundsException if the index is out of range
     *         ({@code index < 0 || index >= size()})
     * @since 1.2
     */
    public synchronized E set(int index, E element) {
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

    /**
     * Appends the specified element to the end of this Vector.
     *
     * @param e element to be appended to this Vector
     * @return {@code true} (as specified by {@link Collection#add})
     * @since 1.2
     */
    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }
 /**
     * Increases the capacity of this vector, if necessary, to ensure
     * that it can hold at least the number of components specified by
     * the minimum capacity argument.
     *
     * <p>If the current capacity of this vector is less than
     * {@code minCapacity}, then its capacity is increased by replacing its
     * internal data array, kept in the field {@code elementData}, with a
     * larger one.  The size of the new data array will be the old size plus
     * {@code capacityIncrement}, unless the value of
     * {@code capacityIncrement} is less than or equal to zero, in which case
     * the new capacity will be twice the old capacity; but if this new size
     * is still smaller than {@code minCapacity}, then the new capacity will
     * be {@code minCapacity}.
     *
     * @param minCapacity the desired minimum capacity
     */
    public synchronized void ensureCapacity(int minCapacity) {
        if (minCapacity > 0) {
            modCount++;
            ensureCapacityHelper(minCapacity);
        }
    }

    /**
     * This implements the unsynchronized semantics of ensureCapacity.
     * Synchronized methods in this class can internally call this
     * method for ensuring capacity without incurring the cost of an
     * extra synchronization.
     *
     * @see #ensureCapacity(int)
     */
    private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    /**
     * The maximum size of array to allocate.
     * Some VMs reserve some header words in an array.
     * Attempts to allocate larger arrays may result in
     * OutOfMemoryError: Requested array size exceeds VM limit
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    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);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

    /**
     * Removes the first occurrence of the specified element in this Vector
     * If the Vector does not contain the element, it is unchanged.  More
     * formally, removes the element with the lowest index i such that
     * {@code (o==null ? get(i)==null : o.equals(get(i)))} (if such
     * an element exists).
     *
     * @param o element to be removed from this Vector, if present
     * @return true if the Vector contained the specified element
     * @since 1.2
     */
    public boolean remove(Object o) {
        return removeElement(o);
    }

和arrayList类似,但是这写方法都有同步关键字synchronized。方法线程安全,但是速度更慢了。

总结

  1. 线程安全,默认大小为10,每次扩容为传入的扩容大小(当没有传入时或者为0时,直接初始值翻倍)
  2. 基本上所有的对外的方法都带着synchronized,线程安全但是效率低下
  3. 基础类型和arrayList一样

相关文章

  • c++常用数据结构

    问题:vector与数组的区别? 1、vector vector v;//创建vector v....

  • 指针

    ①动态指针问题. vector * pvt = new vector [100]; vector * tt; tt...

  • 2021-12-01 opencv findContours a

    std::vector contours; std::vector hi...

  • 13.C++ vector 操作

    vector初始化 vector大小 数组方式操作vector 迭代器方式操作vector 反向迭代器操作vect...

  • c++零散知识

    1、vector vector对象内存增长原理,当向vector添加新元素而vector没有足够的内存保存新元素时...

  • vector

    一、vector介绍:可边长数组1、vector的定义:vector name;注:vecto...

  • Collection-Vector

    jdk版本:1.8.0_77参考文档:jdk 1.8 docs Vector类图 Vector特点 Vector对...

  • vector 简单用法

    vector 简单用法 数组传进vector方式: int a[3]={1,2,3} vector test;...

  • 点乘与叉乘

    public static Vector3 Cross(Vector3 lhs, Vector3 rhs);叉乘的...

  • 1.两数之和 by 2018-04-19

    class Solution {public:vector twoSum(vector & nums, int ...

网友评论

      本文标题:vector

      本文链接:https://www.haomeiwen.com/subject/uzbijctx.html