Programs

Vector in Java | Java Vector Class with Examples

In programming, one of the most commonly used data structures is Vector in Java. Arrays are static data structures that can linearly store data. Similarly, vector in java also store the data linearly, but they are not restricted to a fixed size. Instead, its size can grow or shrink as per requirement. The parent class is AbstractList class and is implemented on List Interface.

Before you start to use vectors, import it from the java.util.package as follow:

 import java.util.Vector 

Declaration and Assessing Elements of a Vector

Here is how a vector in java is declared:

public class Vector<V> extends AbstractList<V>

implements List<V>, RandomAccess, Cloneable, Serializable

Here, V is the type of element which can be int, string, char, etc.

Like we access data members in arrays, we can do that in vectors, too, by using the element’s index. For example, the second element of Vector E can be accessed as E[2].

Some common errors made while declaring a vector in java:

  •   An IllegalArgumentException is thrown if the initial size of the vector is a negative value
  •   A NullPointerException is thrown if the specified collection is null
  •   The size of the vector is less than or equal to the capacity of the vector
  •   Capacity is doubled in every increment cycle if vector increment is not specified

Constructors

1. Vector(int initialCapacity, int Increment)

This creates a vector in java with an initial capacity as specified, and the increment is also specified. With increment, the number of elements allocated each time the vector is resized upward is specified.

Syntax: Vector<V> e = new Vector<V>(int initialCapacity, int Increment);

2. Vector(int initialCapacity)

It creates a vector in java with an initial capacity equal to size as specified.

Syntax: Vector<V> e = new Vector<V>(int initialCapacity);

3. Vector()

It creates a vector in java with an initial default capacity of 10.

Syntax: Vector<V> e = new Vector<V>();

4. Vector(Collection c)

It creates a vector in java whose elements are those of collection c.

Syntax: Vector<V> e = new Vector<V>(Collection c);

Here is an example to demonstrate the creation and use of a vector in java:

Code

import java.util.*;

public class Main{

public static void main(String[] args)

{

         // Create default vector

         Vector a = new Vector();

     // Create a vector of specified Size

         Vector b = new Vector(20);

     // Create a vector of specified Size and Increment

         Vector c = new Vector(30,10);

         b.add(100);

         b.add(200);

         b.add(300);

     // Create a vector with a specified collection

         Vector d = new Vector(b)

     System.out.println(“Vector a of capacity ” + a.capacity());

     System.out.println(“Vector b of capacity ” + b.capacity());

     System.out.println(“Vector c of capacity ” + c.capacity());

System.out.println(“Vector d of capacity ” + d.capacity());

}}

Output

Note: .capacity()  is used to return the capacity of the vector.

A vector in java has three protected parameters as follows:

1. Int elementCount()- It tells the number of elements a vector contains

2. Int capcityIncremen()- When the vector’s size becomes greater than the capacity, the capacity is automatically increased with this.

3. Object[] elementData()- Elements of the vector are stored in array.

Methods

Here are some frequently used methods of vector in java:

1. Add Elements

Boolean add(Object o)- An element is appended at the end of the vector

Void add( int index V element)- The given element is added to the specified index in the vector

Code for adding the elements in Vector in java:

import java.util.*;

import java.io.*;

public class AddElementsToVector {     

           public static void main(String[] arg)

           {

                          // Create a default vector

                          Vector a = new Vector();

                          // Adding elements using add() method

                          a.add(1);

                          a.add(2);

                          a.add(“vect”);

                          a.add(“for”);

                          a.add(3); 

                          System.out.println(“Vector a is ” + a);

                          // Create a generic vector

                          Vector<Integer> b = new Vector<Integer>();

 

                          b.add(0);

                          b.add(1);

                          b.add(2);

                          System.out.println(“Vector b is ” + b);

           }

}

Output

2. Remove Elements

Boolean Remove(object o) – used to remove the element at the specified index in the vector

When the element is removed, all the elements are shifted left to fill the spaces; the indices are then updated.

Code to illustrate the removal of elements from vector in java:

import java.util.*;

import java.io.*;

 

public class Remove {

          

           public static void main(String[] arg)

           {

 

                          // Create a default vector

                          Vector a = new Vector();

 

                          // Adding elements using add() method

                          a.add(1);

                          a.add(2);

                          a.add(“vect”);

                          a.add(“for”);

                          a.add(4);

 

                          // Remove element

                          a.remove(2);

 

                          // Check

                          System.out.println(“after removal: ” + a);

           }

}

Output

Checkout: How to make a successful career in Java?

3. Change Elements

The set () method can be used to change the element after adding the elements. The element’s index can be referenced as a vector is indexed. This method takes the index and the updated element.

Code to change the elements in vector in java

import java.util.*;

public class Update {

           public static void main(String args[])

           {

                          // Create an empty Vector

                          Vector<Integer> a = new Vector<Integer>();

 

                          // Add elements

                          a.add(1);

                          a.add(2);

                          a.add(3);

                          a.add(10);

                          a.add(20);

 

                          // Display

                          System.out.println(“Vector: ” + a);

 

                          // Replace

                          System.out.println(“Replacing”

                                                                                   + a.set(0, 22));

                          System.out.println(“Replacing “

                                                                                   + a.set(4, 50));

 

                          // Display the modified vector

                          System.out.println(“The new Vector is:” + a);

           }

}

Output

4. Iterate the Vector

There are several ways to loop through a vector. One of them is the get() method. Here is a program to iterate the elements in a Vector in java:

import java.util.*;

public class Iterate {

 

           public static void main(String args[])

           {

                          // creating an instance of vector

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

 

                          // Add elements using add() method

                          a.add(“vector”);

                          a.add(“in”);

                          a.add(1, “java”);

 

                          // Use Get method and the for loop

                          for (int i = 0; i < a.size(); i++) {

 

                                        System.out.print(a.get(i) + ” “);

                          }

                          System.out.println();

                          // Use for each loop

                          for (String str : a)

                                        System.out.print(str + ” “);

           }

}

Output

Read: Java Architecture & Components

Other Important Methods

  • Int size() – used to return the size of the vector
  • Object get(int index) –  used to return the element at the specified position in the vector
  • Object firstElement() – used to return the first element of vector in java
  • Object lastElement() – used to return the last element of vector in java
  •   Boolean equals(Object o) – used to compare the vector with the given object for equality. Returns true if all elements are true at their respective indices
  • Void trimtosize() – used to remove additional capacity and keep the capacity equal to the size

More About Vectors

  •   A vector in java is a dynamic data structure that can be accessed using an integer index.
  •   Though similar to ArrayList, it is synchronized, containing some legacy methods not available in the collection framework.
  •   Insertion order is maintained.
  •   It is rarely used in a non-thread environment.
  •   Due to synchronization, vectors have a poor performance in searching, adding, updating, and deleting elements.
  •   Iterators of vector class fail fast and throw the ConcurrentModificationException in case of concurrent modification.
  •   A stack is its directly known subclass.

Memory Allocation in Vectors

As seen above, vectors do not have a defined size. Instead, a vector in java can change its size dynamically. It is assumed that the vectors allocate indefinite space to store elements. However, it is not so. The vector’s size is changed based on two fields- ‘capacity increment ‘ and ‘capacity.’

When a vector is declared, a ‘capacity’ field equal to the size is allocated, and elements equal to the capacity can be added. As soon as the next element is inserted, the array’s size is increased by ‘capacityIncrement’ size. This gives the vector ability to change its size—the capacity doubles for a default constructor when a new element is inserted. 

Learn Software Courses online from the World’s top Universities. Earn Executive PG Programs, Advanced Certificate Programs, or Masters Programs to fast-track your career.

Advantages of Vector in Java

The dynamic size of vectors avoids memory wastage, and the size of our data structure can be changed any time in the middle of the program.

Both vectors and ArrayLists are dynamic. However, vectors are more advantageous as:

  • Vectors are synchronized.
  •   It has some legacy functions that cannot be implemented on ArrayLists.

Conclusion

A vector in java is a dynamic array with no size limit that is part of the Java Collection Framework since Java 1.2. We saw various constructors and popularly used methods of vectors in this blog. It is also worth attention that the Vector class should be used in a thread-safe environment only.

If you’re interested to learn more about Java, OOPs & full-stack software development, check out upGrad & IIIT-B’s Executive PG Programme in Software Development – Specialisation in Full Stack Development which is designed for working professionals and offers 500+ hours of rigorous training, 9+ projects, and assignments, IIIT-B Alumni status, practical hands-on capstone projects & job assistance with top firms.

What is a vector in Java?

A vector is a data structure in Java. Like the name suggests, a vector is a kind of sequence of elements. It uses a dynamic array that grows and shrinks as it is accessed. It has a size() method to get the current size of the vector and a capacity() method to get the capacity of the vector. These two methods return the values greater than zero. The capacity of the vector is the number of elements that can be stored inside the vector without having to allocate a new array. The size of the vector is the number of elements currently stored inside the vector.

What are the advantages of vectors over arrays?

Arrays are of fixed size, which means they cannot grow or shrink as needed. Vectors are implemented as dynamically resizable arrays, allowing them to grow and shrink as needed. This is useful for constant growth of the data; for example, a program that reads text files line by line will be able to grow in tandem with the size of the file. Vectors are generally more efficient than arrays. This is because vectors are implemented as arrays of references (java.lang.Objects), whereas arrays are implemented as arrays of objects.

What is ArrayList in Java?

Class ArrayList represents a dynamic array. It can grow as necessary to accommodate new elements. The array is actually implemented as a list of references to objects. Whenever an element needs to be created, a reference to a new object is made available. This is possible because of the fact that ArrayList is implemented as a dynamically resizable list. ArrayList inherits most of its methods and fields from AbstractList. ArrayList is faster than an array since it doesn't have to create new objects. Mutating methods that change the size of the array such as add, set and remove, are called destructive methods since they permanently change the size of the array.

Want to share this article?

Become a Full Stack Developer

Leave a comment

Your email address will not be published. Required fields are marked *

Leave a comment

Your email address will not be published. Required fields are marked *

×
Get Free career counselling from upGrad experts!
Book a session with an industry professional today!
No Thanks
Let's do it
Get Free career counselling from upGrad experts!
Book a Session with an industry professional today!
Let's do it
No Thanks