Vector Class

The Vector class implements a growable array of objects. Vectors fall in legacy classes, but now it is fully compatible with collections. It is found in java.util package and implement the List interface, so we can use all the methods.

Features of Vector class #

• Vector implements a dynamic array which means it can grow or shrink as required. Like an array, it contains components that can be accessed using an integer index.

• They are very similar to ArrayList, but Vector is synchronized and has some legacy methods that the collection framework does not contain.

• It also maintains an insertion order like an ArrayList. Still, it is rarely used in a non-thread environment as it is synchronized, and due to this, it gives a poor performance in adding, searching, deleting, and updating its elements.

• The Iterators returned by the Vector class are fail-fast. In the case of concurrent modification, it fails and throws the Concurrent Modification Exception.

Syntax #

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

Constructors #

Vector() #

Creates a default vector of the initial capacity is 10.

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

Vector(int size) #

Creates a vector whose initial capacity is specified by size.

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

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

Vector(Collection c) #

Creates a vector that contains the elements of collection c.

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

Methods #

Operations on vector class #

Adding Elements #

In order 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.

// Java Program to Add Elements in Vector Class

// Importing required classes
import java.io.*;
import java.util.*;

// Main class
// AddElementsToVector
class GFG {

	// Main driver method
	public static void main(String[] arg)
	{

		// Case 1
		// Creating a default vector
		Vector v1 = new Vector();

		// Adding custom elements
		// using add() method
		v1.add(1);
		v1.add(2);
		v1.add("Tit");
		v1.add("forTat");
		v1.add(3);

		// Printing the vector elements to the console
		System.out.println("Vector v1 is " + v1);

		// Case 2
		// Creating generic vector
		Vector<Integer> v2 = new Vector<Integer>();

		// Adding custom elements
		// using add() method
		v2.add(1);
		v2.add(2);
		v2.add(3);

		// Printing the vector elements to the console
		System.out.println("Vector v2 is " + v2);
	}
}

Output

Vector v1 is [1, 2, Tit, forTat, 3]
Vector v2 is [1, 2, 3]

Updating Elements #

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

// Java code to change the
// elements in vector class

import java.util.*;

public class UpdatingVector {
	
	public static void main(String args[])
	{
		// Creating an empty Vector
		Vector<Integer> vec_tor = new Vector<Integer>();

		// Use add() method to add elements in the vector
		vec_tor.add(12);
		vec_tor.add(23);
		vec_tor.add(22);
		vec_tor.add(10);
		vec_tor.add(20);

		// Displaying the Vector
		System.out.println("Vector: " + vec_tor);

		// Using set() method to replace 12 with 21
		System.out.println("The Object that is replaced is: "
						+ vec_tor.set(0, 21));

		// Using set() method to replace 20 with 50
		System.out.println("The Object that is replaced is: "
						+ vec_tor.set(4, 50));

		// Displaying the modified vector
		System.out.println("The new Vector is:" + vec_tor);
	}
}

Output

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]

Removing Elements #

In order 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): Since a Vector is indexed, 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.

// Java code illustrating the removal
// of elements from vector

import java.util.*;
import java.io.*;

class RemovingElementsFromVector {
	
	public static void main(String[] arg)
	{

		// create default vector of capacity 10
		Vector v = new Vector();

		// Add elements using add() method
		v.add(1);
		v.add(2);
		v.add("Tit");
		v.add("forTat");
		v.add(4);

		// removing first occurrence element at 1
		v.remove(1);

		// checking vector
		System.out.println("after removal: " + v);
	}
}

Output

after removal: [1, Tit, forTat, 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.

// Java program to iterate the elements
// in a Vector

import java.util.*;

public class IteratingVector {

	public static void main(String args[])
	{
		// create an instance of vector
		Vector<String> v = new Vector<>();

		// Add elements using add() method
		v.add("Tit");
		v.add("Tat");
		v.add(1, "For");

		// Using the Get method and the
		// for loop
		for (int i = 0; i < v.size(); i++) {

			System.out.print(v.get(i) + " ");
		}

		System.out.println();

		// Using the for each loop
		for (String str : v)
			System.out.print(str + " ");
	}
}

Output

Tit For Tat 
Tit For Tat