Vector class in Java

The Vector class implements a growable array of objects. Just like an array, we can access its elements by using an integer index but the size of a Vector can grow or shrink as per our need.

Vector is now a part of the Collection framework since Java 1.2 and hence it implements the Collection interface along with some others as shown in the below image but it also contains some of the legacy methods from when it was not part of the collection framework.

Some insights about Vector class

• A Vector is synchronized but if the thread-safe environment is not needed, then it is recommended to use the ArrayList instead.
• The Vector contains some of the legacy methods that are not part of the Collection framework.
• Vector maintains the insertion order.
• Iterators returned by the vector’s class iterator and listIterator are fail-fast. We will discuss the fail-fast iterators later in the post.

Things you should know about “Capacity” and “capacityIncrement” in Vector

Each vector tries to optimize the storage management by maintaining a capacity and a capacityIncrement. The capacity is always at least as large as the vector’s size ( usually, it is greater than the vector’s size). The default capacity that is assigned to a vector at the time of the creation of an object is 10. So, in starting, if we don’t assign any capacity ourselves, then the size of a vector object is 0 while its capacity is 10.

Now, let’s talk about capacityIncrement. If the initial capacity is filled ( when the size of the vector is equal to the capacity assigned to it ), then we have to increase the capacity of the vector to accommodate more elements. But how do we know that how much capacity is to be increased? Here comes the capacityIncrement in the picture. If we don’t provide any value for the capacityIncrement or provided any value that is less than or equal to zero ( <=0 ), then the capacity of the vector would be doubled, otherwise, the capacity of the vector would be incremented by an amount defined by the capacityIncrement. Don’t worry we will look at it with an example afterward.

Declaration of Vector class

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

Constructors of the Vector class

There are four overloaded constructors of the Vector class, out of which one is the default constructor and three are the parameterized ones.

• public Vector()
• public Vector(int initialCapacity)
• public Vector(int initialCapacity, int capacityIncrement)
• public Vector(Collection c)

Now, we would only have to write the below line for making a vector object that will contain string elements using the default constructor.

Vector<String> v = new Vector<String>();

The default constructor will call the public Vector(int initialCapacity) with initialCapacity =10.

    public Vector() {
        this(10);
    }

Finally, the public Vector(int initialCapacity) will further call the public Vector(int initialCapacity, int capacityIncrement) constructor with capacityIncrement =0.

    public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }

In this way, an initial capacity of 10 will be assigned to the vector, even though the size of the vector is still zero. Below is the sample code to illustrate the same.

import java.util.Vector;

public class Codekru {

	public static void main(String[] args) {

		Vector<String> v = new Vector<String>();
		
		System.out.println("Capcity of the vector:"+v.capacity());
		System.out.println("Size of the vector: "+v.size());
		

	}
}

Output –

Capcity of the vector:10
Size of the vector: 0

Add the elements into a vector

We can easily add elements to a vector using the add() method by just passing the element into its argument. Right now, we will just show you the implementation of add() method and will cover it in more detail in another post.

import java.util.Vector;

public class Codekru {

	public static void main(String[] args) {

		Vector<String> v = new Vector<String>();
		
		v.add("first");  // appending the element at the end of the vector
		v.add("second"); 
		
		System.out.println("Vector: "+v.toString());
		
	}
}

Output –

Vector: [first, second]

And now let’s get back to the fail-fast iterators

Iterator is one of the many ways to iterate over a vector. The iterator returned by the vector class iterator and the listIterator methods is fail-fast. This means that if the vector is structurally modified after the iterator is created in any way except through the iterator’s own add or remove methods, then the iterator will throw a ConcurrentModificationException. Let’s show you this in action.

import java.util.Iterator;
import java.util.Vector;

public class Codekru {

	public static void main(String[] args) {

		Vector<String> v = new Vector<String>();

		v.add("first"); // appending the element at the end of the vector
		v.add("second");

		Iterator<String> it = v.iterator();

		// iterating over the vector
		while (it.hasNext()) {
			System.out.println(it.next());
		}

		// adding the third element
		v.add("third");

		// Now, iterating over the vector will throw an exception
		while (it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

Output –

first
second
Exception in thread "main" java.util.ConcurrentModificationException
	at java.base/java.util.Vector$Itr.checkForComodification(Vector.java:1292)
	at java.base/java.util.Vector$Itr.next(Vector.java:1248)

Vector class methods

Hope you have liked the article. If you have any doubts or concerns, please feel free to write us in the comments or mail us at admin@codekru.com.

Related Articles

• LinkedList class in Java
• ArrayList class in Java