Further, it provides only a default constructor to create an empty stack object.

One of the main use case of the Stack class is to reverse a sequence of elements. This can be done by pushing elements onto the stack and then popping them off one by one from the top.

The collection class provides various methods for manipulating elements present in the stack, such as push(), pop(), peek(), and empty().

Methods Of Stack Class

push(): The push method is used to add an element to the top of the stack

pop(): The pop method is used to remove and return the element at the top.

peek(): The peek method returns the element at the top without removing it.

empty(): It returns true if the stack is empty, otherwise, false.

search(): It searches an element, and returns offset, otherwise, -1 to signify not found.

Other Inherited Methods

Here’s a program example to reverse a sequence of integers using Stack:

Program: 

import java.util.Stack;

public class Main
{
  public static void main (String[]args)
  {
    Stack < Integer > stack = new Stack <> ();
    stack.push (1);
    stack.push (2);
    stack.push (3);
    stack.push (4);
    while (!stack.empty ())
      {
  System.out.println ("Element :: "+ stack.pop ());
      }
  }
}

Output:

Element :: 4
Element :: 3
Element :: 2
Element :: 1

Over Stack class, the Deque interface should be used as it provides a more complete and flexible API. The Deque interface extends the Queue interface and supports both LIFO and First-In-First-Out (FIFO) operations. The ArrayDeque class implements the Deque interface which is a resizable array and is a good choice for most use cases.

import java.util.ArrayDeque;
public class Main
{
  public static void main (String[]args)
  {
    ArrayDeque < Integer > deque = new ArrayDeque <> ();
    deque.push (1);
    deque.push (2);
    deque.push (3);
    deque.push (4);
    while (!deque.isEmpty ())
      {
  System.out.println ("Element :: "+deque.pop ());
      }
  }
}

Element :: 4
Element :: 3
Element :: 2
Element :: 1

It is similar to ArrayList, but is synchronized  and supports legacy methods which duplicates the behaviour of methods defined by Collection Framework.  It implements Serializable and RandomAccess interface. Its most of the methods are thread safe.

It is a legacy class and fully compatible with Collection, meaning one can use enhanced for loops to iterate through its elements.

Points to Remember

1) Its underlying data structure is dynamic array. It has the capability to grow or shrink as required. Like array, it uses zero  based index to access, add, delete, and update an element.

2) It is a legacy class, as a result, it supports legacy methods along with predefined methods by Collection framework. Further, it is synchronized.

3) It preserves insertion order that signifies all elements get stored in same order in which they inserted

4)  It can be used where multiple threads require to perform operations on same list. However, it can impact performance inversely, since, it’s synchronized.

Constructors of Vector

1. Vector v = new Vector();

The default constructor that creates the list with initial capacity of 10.

When vector crosses its capacity, a new vector object is created by the compiler and the values of first vector object is copied to new one. Lastly, reference variable starts pointing to new one and old reference becomes eligible for garbage collection.

How to calculate the capacity of vector?

capacity of new vector = 2 * current capacity

2. Vector v = new Vector(int capacity);

The constructor creates a vector with the given capacity provided in parameter.

3. Vector v = new Vector(int initialCapacity, int incrementalCapacity);

It creates a vector with initial capacity provided in the parameter. The incrementalCapacity specifies the new incremental capacity every time when the list resized  to be allocated .

4.Vector v = new Vector(Collection obj);

It creates equivalent list similar to the collection object provided in the constructor.

Methods in Vector

• addElement(Object obj): Insert an element to the end of the list.
• removeElement(Object obj): Removes the very first occurrence of the given element
• insertElementAt(Object obj, int indx): Inserts the given element at the specified position, moving elements greater than that index by 1.
• removeElementAt(int indx): Deletes the element at the specified index.
• setElementAt(Object obj, int indx): Replaces the element at the specified position with the specified element.
• elementAt(int indx): Returns the element at the given position.
• firstElement(): Returns the first element in the list.
• lastElement(): Returns the last element in the list.
• copyInto(Object[] o):  Copies elements to the given arrays passed as parameter.
• indexOf(Object o): Returns the index of the first occurrence of the specified element.
• trimToSize(): Reduces the capacity of the given vector to the current size.
• ensureCapacity(int minCapacity): Increases the capacity to ensure that the list can hold at least the specified number of elements.
• setSize() : Set the size of the given vector, storing null values to new empty spaces.
• capacity(): Returns the current capacity of the vector.

Disadvantages of using Vector Class