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 // Java Program Implementing Vector import java.util.Vector; public class Geeks { public static void main(String[] args) { // Create a new vector Vector<Integer> v = new Vector<>(3, 2); // Add elements to the vector v.addElement(1); v.addElement(2); v.addElement(3); // Insert an element at index 1 v.insertElementAt(0, 1); // Remove the element at index 2 v.removeElementAt(2); // Print the elements of the vector for (int i : v) { System.out.println(i); } } }
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
Method | Description |
|---|
| add(E e) | Appends the specified element to the end of this Vector. |
| add(int index, E element) | Inserts the specified element at the specified position in this Vector. |
addAll(Collection<? extends E> c) | Appends all of the elements in the specified Collection to the end of this Vector, in the order that they are returned by the specified Collection's Iterator. |
addAll(int index, Collection<? extends E> c) | Insert all of the elements in the specified Collection into this Vector at the specified position. |
| addElement(E obj) | Adds the specified component to the end of this vector, increasing its size by one. |
| capacity() | Returns the current capacity of this vector. |
| clear() | Removes all of the elements from this Vector. |
| clone() | Returns a clone of this vector. |
| contains(Object o) | Returns true if this vector contains the specified element. |
| containsAll(Collection<?> c) | Returns true if this Vector contains all of the elements in the specified Collection. |
| copyInto(Object[] anArray) | Copies the components of this vector into the specified array. |
| elementAt(int index) | Returns the component at the specified index. |
| elements() | Returns an enumeration of the components of this vector. |
| ensureCapacity(int minCapacity) | 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. |
| equals(Object o) | Compares the specified Object with this Vector for equality. |
| firstElement() | Returns the first component (the item at index 0) of this vector. |
forEach(Consumer<? super E> action) | Performs the given action for each element of the Iterable until all elements have been processed or the action throws an exception. |
| get(int index) | Returns the element at the specified position in this Vector. |
| hashCode() | Returns the hash code value for this Vector. |
| indexOf(Object o) | Returns the index of the first occurrence of the specified element in this vector, or -1 if this vector does not contain the element. |
| indexOf(Object o, int index) | Returns the index of the first occurrence of the specified element in this vector, searching forwards from the index, or returns -1 if the element is not found. |
| insertElementAt(E obj, int index) | Inserts the specified object as a component in this vector at the specified index. |
| isEmpty() | Tests if this vector has no components. |
| iterator() | Returns an iterator over the elements in this list in a proper sequence. |
| lastElement() | Returns the last component of the vector. |
| lastIndexOf(Object o) | Returns the index of the last occurrence of the specified element in this vector, or -1 if this vector does not contain the element. |
| lastIndexOf(Object o, int index) | Returns the index of the last occurrence of the specified element in this vector, searching backward from the index, or returns -1 if the element is not found. |
| listIterator() | Returns a list iterator over the elements in this list (in proper sequence). |
| listIterator(int index) | Returns a list iterator over the elements in this list (in proper sequence), starting at the specified position in the list. |
| remove(int index) | Removes the element at the specified position in this Vector. |
| remove(Object o) | Removes the first occurrence of the specified element in this Vector. If the Vector does not contain the element, it is unchanged. |
| removeAll(Collection<?> c) | Removes from this Vector all of its elements contained in the specified Collection. |
| removeAllElements() | Removes all components from this vector and sets its size to zero. |
| removeElement(Object obj) | Removes the first (lowest-indexed) occurrence of the argument from this vector. |
| removeElementAt(int index) | Deletes the component at the specified index. |
| removeIf(Predicate<? super E> filter) | Removes all of the elements of this collection that satisfy the given predicate. |
removeRange(int fromIndex, int toIndex) | Removes from this list all of the elements whose index is between fromIndex, inclusive, and toIndex, exclusive. |
| replaceAll(UnaryOperator<E> operator) | Replaces each element of this list with the result of applying the operator to that element. |
| retainAll(Collection<?> c) | Retains only the elements in this Vector contained in the specified Collection. |
| set(int index, E element) | Replaces the element at the specified position in this Vector with the specified element. |
| setElementAt(E obj, int index) | Sets the component at the specified index of this vector to be the specified object. |
| setSize(int newSize) | Sets the size of this vector. |
| size() | Returns the number of components in this vector. |
| sort(Comparator<? super E> c) | Sorts this list according to the order induced by the specified Comparator. |
| spliterator() | Creates a late-binding and fail-fast Spliterator over the elements in this list. |
| subList(int fromIndex, int toIndex) | Returns a view of the portion of this List between fromIndex, inclusive, and toIndex, exclusive. |
| toArray() | Returns an array containing all of the elements in this Vector in the correct order. |
| toArray(T[] a) | Returns an array containing all of the elements in this Vector in the correct order; the runtime type of the returned array is that of the specified array. |
| toString() | Returns a string representation of this Vector, containing the String representation of each element. |
| trimToSize() | Trims the capacity of this vector to be the vector's current size. |
Let us first discuss and implement how to create and use a Vector prior to landing upon the methods of this class.
Example:
Java // Java Program to demonstrate working of Vector // via creating and using it import java.io.*; import java.util.*; // Main class class Geeks { // Main driver method public static void main(String[] args) { // Size of the Vector int n = 5; // Declaring the Vector with // initial size n Vector<Integer> v = new Vector<Integer>(n); // Appending new elements at // the end of the vector for (int i = 1; i <= n; i++) v.add(i); // Printing elements System.out.println(v); // Remove element at index 3 v.remove(3); // Displaying the vector // after deletion System.out.println(v); // iterating over vector elements // using for loop for (int i = 0; i < v.size(); i++) // Printing elements one by one System.out.print(v.get(i) + " "); } } Output[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.
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 // Java Program to Add Elements in Vector Class import java.io.*; import java.util.*; // Main class // AddElementsToVector class Geeks { // 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("geeks"); v1.add("forGeeks"); 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); } } OutputVector 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 // Java program to change the // elements in vector class import java.util.*; // Driver Class public class Geeks { public static void main(String args[]) { // Creating an empty Vector Vector<Integer> v = new Vector<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); } } OutputVector: [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 // Java program illustrating the removal // of elements from vector import java.util.*; import java.io.*; class Geeks { 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("Geeks"); v.add("forGeeks"); v.add(4); // Removing first occurrence element at 1 v.remove(1); System.out.println("After removal: " + v); } } OutputAfter 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 // Java program to iterate the elements // in a Vector import java.util.*; public class Geeks { public static void main(String args[]) { // create an instance of vector Vector<String> v = new Vector<>(); // Add elements using add() method v.add("Geeks"); v.add("Geeks"); 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 + " "); } } OutputGeeks 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.
Similar Reads
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 nat
12 min read
Vector add() Method in Java To add an element to a Vector in Java, you can use the add() method, which appends an element to the end of the vector.Implementation:Java// Java code to illustrate Adding // Element in Vector import java.util.*; public class GFG { public static void main(String args[]) { // Creating an empty Vector
3 min read
Vector set() Method in Java The Java.util.Vector.set() method is used to replace any particular element in the vector, created using the Vector class, with another element. Syntax: Vector.set(int index, Object element) Parameters: This function accepts two mandatory parameters as shown in the above syntax and described below.
2 min read
Vector remove() Method in Java remove(int index) The java.util.vector.remove(int index) method is used to remove an element from a Vector from a specific position or index. Syntax: Vector.remove(int index) Parameters: This method accepts a mandatory parameter index is of integer data type and specifies the position of the element
2 min read
Vector get() Method in Java The java.util.vector.get() method is used to fetch or retrieve an element at a specific index from a Vector. Syntax: Vector.get(int index) Parameters: This method accepts a mandatory parameter index which is of integer data type. It specifies the position or index of the element to be fetched from t
2 min read
Vector addAll() Method in Java In Java, the addAll() method is used to add all elements from a specified Collection to the current Vector. The addAll() method allows you to efficiently append multiple elements to a vector in one operation.Implementation:Java// Java Program to addAll elements // From Vector to Vector import java.u
3 min read
Vector addElement() Method in Java The Java.util.Vector.addElement() method is used to append a specified element to the end of this vector by increasing the size of the vector by 1. The functionality of this method is similar to that of the add() method of Vector class.Syntax: boolean addElement(Object element)Parameters: This funct
2 min read
Vector capacity() Method in Java The Java.util.Vector.capacity() method in Java is used to get the capacity of the Vector or the length of the array present in the Vector.Syntax of Vector capacity() methodVector.capacity()Parameters: The method does not take any parameter. Return Value: The method returns the capacity or the intern
2 min read
Vector clear() Method in Java The Java.util.Vector.clear() method is used to remove all the elements from a Vector. Using the clear() method only clears all the element from the vector and does not delete the vector. In other words, we can say that the clear() method is used to only empty an existing vector. Syntax:Vector.clear(
2 min read
Java Vector clone() Method In Java, the clone() method of the Vector class is used to return a shallow copy of the vector. It just creates a copy of the vector. The copy will have a reference to a clone of the internal data array but not a reference to the original internal data array.Example 1: In this example, we use the cl
3 min read