Vector Class in Java

The Vector class in Java implements a growable array of objects. Vectors were legacy classes, but now it is fully compatible with collections. It comes under java.util package and implement the List interface.

Key Features of Vector:

• It expands as elements are added.
• Vector class is synchronized in nature means it is thread-safe by default.
• Like an ArrayList, it maintains insertion order.
• It allows duplicates and nulls.
• It implements List, RandomAccess, Cloneable, and Serializable.

Vector Class Declaration

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

Here, E is the type of element.

• It extends AbstractList and implements List interfaces.
• It implements Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess interfaces.
• The directly known subclass is Stack.

Now let’s go through an example, then we will deep dive into the topic.

Example:

// Java Program Implementing Vectorimportjava.util.Vector;publicclassGeeks{publicstaticvoidmain(String[]args){// Create a new vectorVector<Integer>v=newVector<>(3,2);// Add elements to the vectorv.addElement(1);v.addElement(2);v.addElement(3);// Insert an element at index 1v.insertElementAt(0,1);// Remove the element at index 2v.removeElementAt(2);// Print the elements of the vectorfor(inti:v){System.out.println(i);}}}

1 0 3 

We can use all the methods of the List interface as shown below as follows:

Important points regarding the Increment of vector capacity are as follows:

If the increment is specified, Vector will expand according to it in each allocation cycle. Still, if the increment is not specified, then the vector’s capacity gets doubled in each allocation cycle. Vector defines three protected data members:

• int capacityIncrement: Contains the increment value.
• int elementCount: Number of elements currently in vector stored in it.
• Object elementData[]: Array that holds the vector is stored in it.

Common Errors in the declaration of Vectors are as follows:

• Vector throws an IllegalArgumentException if the InitialSize of the vector defined is negative.
• If the specified collection is null, It throws NullPointerException. 

Constructors of Vector

1. Vector(): Creates a default vector of the initial capacity is 10.

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

2. Vector(int size): Creates a vector whose initial capacity is specified by size.

Vector<E> v = new Vector<E>(int size);

3. Vector(int size, int incr): Creates a vector whose initial capacity is specified by size and increment is specified by incr. It specifies the number of elements to allocate each time a vector is resized upward.

Vector<E> v = new Vector<E>(int size, int incr);

4. Vector(Collection c): Creates a vector that contains the elements of collection c.

Vector<E> v = new Vector<E>(Collection c);

Methods in Vector Class

Let us first discuss and implement how to create and use a Vector prior to landing upon the methods of this class.

Example:

// Java Program to demonstrate working of Vector// via creating and using itimportjava.io.*;importjava.util.*;// Main classclassGeeks{// Main driver methodpublicstaticvoidmain(String[]args){// Size of the Vectorintn=5;// Declaring the Vector with// initial size nVector<Integer>v=newVector<Integer>(n);// Appending new elements at// the end of the vectorfor(inti=1;i<=n;i++)v.add(i);// Printing elementsSystem.out.println(v);// Remove element at index 3v.remove(3);// Displaying the vector// after deletionSystem.out.println(v);// iterating over vector elements// using for loopfor(inti=0;i<v.size();i++)// Printing elements one by oneSystem.out.print(v.get(i)+" ");}}

[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5 

Note:

• If the vector increment is not specified then it’s capacity will be doubled in every increment cycle.
• The capacity of a vector cannot be below the size, it may equal to it.

Performing Different Operations on Vector Class in Java

Let us discuss various operations on Vector class that are listed as follows:

• Adding elements
• Updating elements
• Removing elements
• Iterating over elements

1. Adding Elements

To add the elements to the Vector, we use the add() method. This method is overloaded to perform multiple operations based on different parameters. They are listed below as follows:

• add(Object): This method is used to add an element at the end of the Vector.
• add(int index, Object): This method is used to add an element at a specific index in the Vector.

Example:

// Java Program to Add Elements in Vector Classimportjava.io.*;importjava.util.*;// Main class// AddElementsToVectorclassGeeks{// Main driver methodpublicstaticvoidmain(String[]arg){// Case 1// Creating a default vectorVectorv1=newVector();// Adding custom elements// using add() methodv1.add(1);v1.add(2);v1.add("geeks");v1.add("forGeeks");v1.add(3);// Printing the vector elements to the consoleSystem.out.println("Vector v1 is "+v1);// Case 2// Creating generic vectorVector<Integer>v2=newVector<Integer>();// Adding custom elements// using add() methodv2.add(1);v2.add(2);v2.add(3);// Printing the vector elements to the consoleSystem.out.println("Vector v2 is "+v2);}}

Vector v1 is [1, 2, geeks, forGeeks, 3] Vector v2 is [1, 2, 3] 

2. Updating Elements

After adding the elements, if we want to change the element, it can be done using the set() method. A Vector is indexed, the element which we want to change is referenced by the index of the element. So, this method takes an index and the updated element to be inserted at that index.

Example:

// Java program to change the// elements in vector classimportjava.util.*;// Driver ClasspublicclassGeeks{publicstaticvoidmain(Stringargs[]){// Creating an empty Vector Vector<Integer>v=newVector<Integer>();// Use add() method to add // elements in the vector v.add(12);v.add(23);v.add(22);v.add(10);v.add(20);// Displaying the Vector System.out.println("Vector: "+v);// Using set() method to replace 12 with 21 System.out.println("The Object that is replaced is: "+v.set(0,21));// Using set() method to replace 20 with 50 System.out.println("The Object that is replaced is: "+v.set(4,50));// Displaying the modified vector System.out.println("The new Vector is:"+v);}}

Vector: [12, 23, 22, 10, 20] The Object that is replaced is: 12 The Object that is replaced is: 20 The new Vector is:[21, 23, 22, 10, 50] 

3. Removing Elements

To remove an element from a Vector, we can use the remove() method. This method is overloaded to perform multiple operations based on different parameters. They are:

• remove(Object): This method is used to remove an object from the Vector. If there are multiple such objects, then the first occurrence of the object is removed.
• remove(int index): Vector is indexed, so this method takes an integer value which simply removes the element present at that specific index in the Vector. After removing the element, all the elements are moved to the left to fill the space and the indices of the objects are updated.

Example:

// Java program illustrating the removal// of elements from vectorimportjava.util.*;importjava.io.*;classGeeks{publicstaticvoidmain(String[]arg){// Create default vector of capacity 10Vectorv=newVector();// Add elements using add() methodv.add(1);v.add(2);v.add("Geeks");v.add("forGeeks");v.add(4);// Removing first occurrence element at 1v.remove(1);System.out.println("After removal: "+v);}}

After removal: [1, Geeks, forGeeks, 4] 

4. Iterating the Vector

There are multiple ways to iterate through the Vector. The most famous ways are by using the basic for loop in combination with a get() method to get the element at a specific index and the advanced for a loop.

Example:

// Java program to iterate the elements// in a Vectorimportjava.util.*;publicclassGeeks{publicstaticvoidmain(Stringargs[]){// create an instance of vectorVector<String>v=newVector<>();// Add elements using add() methodv.add("Geeks");v.add("Geeks");v.add(1,"For");// Using the Get method and the// for loopfor(inti=0;i<v.size();i++){System.out.print(v.get(i)+" ");}System.out.println();// Using the for each loopfor(Stringstr:v)System.out.print(str+" ");}}

Geeks For Geeks Geeks For Geeks 

Note: Please read to the ArrayList vs Vector class in Java to grasp it better.

In Java, the Vector class is a part of the Java Collections Framework and provides a dynamic array implementation of the List interface. It was added in the original release of Java (Java 1.0) and provides a number of methods for manipulating the elements of a vector, including adding, inserting, and removing elements.

Note that the Vector class is synchronized, meaning that multiple threads can access the same vector without causing problems. However, this synchronization comes at the cost of performance, so if you don’t need to share a vector between multiple threads, it’s generally better to use an alternative class like ArrayList which is not synchronized.

Advantages of using Vector in Java

• As mentioned before, Vector is synchronized, making it safe to use in a multi-threaded environment.
• The size of a Vector can grow or shrink dynamically as elements are added or removed, so you do not have to worry about setting an initial size that will accommodate all elements.
• Vector has been part of Java since its inception and is still supported, so it’s a good option if you need to work with older Java code that uses Vector.

Disadvantages of using Vector in Java

• The synchronization in Vector can lead to slower performance compared to other collection classes, such as ArrayList.
• While Vector is still supported, newer Java code is often written using the more modern collection classes, so it may be harder to find examples and support for Vector.
• If you don’t need the synchronization features of Vector, using it will add unnecessary overhead to your code.

Reference Book:

A good reference book for learning about the Java Collections Framework and Vector is “Java Collections” by Naftalin and Wadler. This book provides a comprehensive look at the Java collections framework, including Vector, and includes many examples and exercises to help you understand how to use these classes effectively.