Java中集合框架必备：详解Vector类！

哈喽，各位小伙伴们，你们好呀，我是喵手。运营社区：C站/掘金/腾讯云；欢迎大家常来逛逛

  今天我要给大家分享一些自己日常学习到的一些知识点，并以文字的形式跟大家一起交流，互相学习，一个人虽可以走的更快，但一群人可以走的更远。

  我是一名后端开发爱好者，工作日常接触到最多的就是Java语言啦，所以我都尽量抽业余时间把自己所学到所会的，通过文章的形式进行输出，希望以这种方式帮助到更多的初学者或者想入门的小伙伴们，同时也能对自己的技术进行沉淀，加以复盘，查缺补漏。

小伙伴们在批阅的过程中，如果觉得文章不错，欢迎点赞、收藏、关注哦。三连即是对作者我写作道路上最好的鼓励与支持！

前言

  在Java开发中，我们经常需要处理一些集合类型的数据，如列表、数组等。而其中一个比较常用的集合类型就是Vector。Vector是一种动态数组，能够存储任意类型对象，具有较好的可扩展性。

摘要

  本文将详细介绍Java中的Vector类，包括其定义、使用、优缺点等方面。通过本文的阅读，读者可以深入了解Vector的底层实现和常用方法，同时掌握Vector在实际开发中的应用场景和注意事项。

Vector类

简介

  Vector类是Java中提供的一个动态数组容器，在Java 1.0版本中就已经存在，属于Java Collection Framework的一部分。与数组相比，Vector能够动态调整容量，可以自动扩容，同时提供了一些常用的操作方法，例如添加元素、删除元素、修改元素、查找元素等。

  Vector的底层实现是基于Object数组的，每次增加元素时都会检查当前容量是否足够，如果不够则会自动扩容，同时将原数组中的元素复制到新数组中。Vector类的主要特点如下：

• 线程安全，支持多线程并发访问；
• 可以存储任意类型对象，包括null；
• 可以自动扩容，增量为当前容量的一半；
• 提供了一些常用的操作方法，如添加、删除、修改、查找等。

源代码解析

以下是Vector类的主要源代码：

public class Vector<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
        
    protected Object[] elementData;
    protected int elementCount;
    protected int capacityIncrement;

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

    //添加元素
    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityInternal(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

    //获取元素
    public synchronized E get(int index) {
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        return elementData(index);
    }

    //删除元素
    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;
        return oldValue;
    }

    //修改元素
    public synchronized E set(int index, E element) {
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

    //获取元素个数
    public synchronized int size() {
        return elementCount;
    }

    //判断是否包含元素
    public synchronized boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

    //查找元素位置
    public synchronized int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < elementCount; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < elementCount; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

    //扩容
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        ensureExplicitCapacity(minCapacity);
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    //自动扩容
    private void grow(int minCapacity) {
        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);
    }
}

  Vector类继承于AbstractList类，并实现了List、RandomAccess、Cloneable和Serializable接口。其中，elementData是存储元素的底层数据结构，而elementCount表示当前已经存储的元素数量。

  Vector提供了一些常用的方法，例如add()、get()、remove()、set()等。其中，add()方法用于添加元素，如果当前容量不够，则会自动扩容；get()方法用于获取指定位置的元素；remove()方法用于删除指定位置的元素；set()方法用于修改指定位置的元素。

  为了保证线程安全性，Vector采用了synchronized关键字对部分方法进行同步，例如add()、get()、remove()、set()等。同时，Vector还提供了一些同步方法，例如synchronizedAdd()、synchronizedGet()、synchronizedRemove()、synchronizedSet()等，用于在多线程并发环境下进行操作。

如下是部分源码截图：

应用场景案例

Vector在实际开发中有着广泛的应用场景，例如：

• 网络编程中的数据传输：Vector可以很方便地存储网络传输中的大量数据，比如Socket通信中的数据流；
• 图形界面编程中的图形元素：Vector可以存储GUI中的各种元素，例如按钮、标签、文本框等；
• 文件操作中的数据读写：Vector可以存储读取的文件内容，便于进行后续的数据处理。

优缺点分析

Vector类的主要优点如下：

• 线程安全，支持多线程并发访问；
• 可以存储任意类型对象，包括null；
• 可以自动扩容，增量为当前容量的一半；
• 提供了一些常用的操作方法，如添加、删除、修改、查找等。

而其主要缺点如下：

• 在多线程并发访问时性能较差，因为需要进行同步；
• 在进行大量元素操作时，由于扩容会导致频繁的数组复制，容易造成性能问题；
• 不适合大量修改元素的场景，因为每次修改都需要进行同步操作。

类代码方法介绍

以下是Vector类中的一些常用方法介绍：

• add(E e)：添加一个元素；
• get(int index)：获取指定位置的元素；
• remove(int index)：删除指定位置的元素；
• set(int index, E element)：修改指定位置的元素；
• size()：获取元素个数；
• contains(Object o)：判断是否包含指定元素；
• indexOf(Object o)：查找指定元素的位置。

测试用例

测试代码

以下是一个简单的测试Vector的示例代码：

package com.example.javase.collection;

import java.util.Vector;

/**
 * @Author ms
 * @Date 2023-10-20 20:21
 */
public class VectorTest {

    public static void main(String[] args) {
        Vector<String> vector = new Vector<>();
        vector.add("Java");
        vector.add("Python");
        vector.add("C++");
        vector.add("JavaScript");
        System.out.println("Vector size: " + vector.size());
        System.out.println("Vector contains Java? " + vector.contains("Java"));
        System.out.println("Vector contains Ruby? " + vector.contains("Ruby"));
        System.out.println("Vector at index 2: " + vector.get(2));
        vector.remove(1);
        System.out.println("Vector size after remove: " + vector.size());
        System.out.println("Vector at index 1 after remove: " + vector.get(1));
    }
}

运行结果如下：

Vector size: 4
Vector contains Java? true
Vector contains Ruby? false
Vector at index 2: C++
Vector size after remove: 3
Vector at index 1 after remove: C++

  上述代码通过创建一个Vector对象，并添加了4个元素，然后分别测试了Vector的一些常用方法，如获取元素个数、判断是否包含元素、获取指定位置的元素、删除指定位置的元素等。通过测试结果可以看出，Vector类的相关方法均正常工作，可以满足开发需求。

测试用例结果演示

  根据如上测试用例，在此我给大家进行深入详细的解读一下测试代码，以便于更多的同学能够理解并加深印象。

测试用例代码分析

  根据如上测试用例，在此我给大家进行深入详细的解读一下测试代码，以便于更多的同学能够理解并加深印象。

  如上测试代码主要演示了如何使用Java中的Vector类，Vector是一个动态数组，可以根据需要自动增长和收缩。在代码中，首先创建了一个String类型的Vector对象vector，然后调用其add()方法向其中添加了4个元素。接下来，通过调用size()方法获取vector的大小，contains()方法判断是否包含某个元素，get()方法获取指定位置上的元素，remove()方法删除指定位置上的元素。

  通过这个例子可以看出，Vector类提供了方便的动态数组操作方法，并且具有线程安全的特性，因此在多线程环境中使用时比较安全。但是，由于线程安全的特性会带来一些性能损失，因此在单线程环境中，可以考虑使用ArrayList等非线程安全的动态数组实现类。

总结

  本文详细介绍了Java中的Vector类，包括其定义、使用、优缺点等方面。通过本文的阅读，读者可以对Vector的底层实现和常用方法有所了解，并掌握Vector在实际开发中的应用场景和注意事项。在使用Vector时，需要注意线程安全和扩容的性能问题，结合具体需求合理选用并发集合类是很重要的，同时也需要注意避免频繁的数组复制操作。

… …

文末

好啦，以上就是我这期的全部内容，如果有任何疑问，欢迎下方留言哦，咱们下期见。

… …

学习不分先后，知识不分多少；事无巨细，当以虚心求教；三人行，必有我师焉！！！

wished for you successed ！！！

---

⭐️若喜欢我，就请关注我叭。

⭐️若对您有用，就请点赞叭。

⭐️若有疑问，就请评论留言告诉我叭。