How to Implement Stack in Java using LinkedList and Generics?

// Java Program to Implement Stack Using LinkedList
// and Generics
// importing the required packages
import java.util.Scanner;

class LinkedStack<T> {
    // create a Node class
    private class Node {

        // A Node contains two parts inside it one is 'data'
        // part and the other is 'next' which has a
        // reference to the next Node
        T data;
        Node next;

        // define a parameterized constructor which
        // initializes the local variables of Node class
        public Node(T data, Node next)
        {
            this.data = data;
            this.next = next;
        }

        public String toString()
        {
            // returns the data in
            // string format
            return data.toString();
        }
    }

    // Here top acts as a reference to the Node
    private Node top;
    public boolean isEmpty() { return top == null; }
    public void push(T ele)
    {
        // Every time  when a new element is pushed onto the
        // stack a new Node is created and top is pointed to
        // it
        top = new Node(ele, top);
    }

    public T pop()
    {

        // check if elements present on Stack or not
        if (top == null)
            return null;
        else {
            // if present do the following
            // Assign the topmost element of
            // stack into a variable
            T element = top.data;
            // make top to point it's next
            // node
            top = top.next;
            // Popped element is returned to
            // the main
            return element;
        }
    }

    public T peek()
    {
        // return the element which is
        // at beginning of the stack
        return top.data;
    }

    public int size()
    {
        // This method returns the no.of elements present on
        // the stack
        int count = 0;
        Node temp = top;

        while (temp != null) {
            // increment count
            count += 1;
            // make temp to point it's
            // next Node
            temp = temp.next;
        }

        return count;
    }

    public void display()
    {
        // This method displays every element of the Stack
        // LinkedList
        System.out.println(
            "The elements of the stack are: ");
        Node temp = top;
        while (temp != null) {
            // print the data in 'temp'
            System.out.print(temp.data + "->");
            // make temp to point it's
            // next Node
            temp = temp.next;
        }
        // indicates that last Node is not
        // pointing to any Node
        System.out.println("null");

        System.out.println();
    }
}

// main method
public class GFG {

    // main driver method
    public static void main(String[] args)
    {
        // create an object of LinkedStack
        LinkedStack<Double> ls = new LinkedStack<>();

        // push an element onto the stack
        // push 10
        ls.push(10.0);

        // push 20
        ls.push(20.0);

        // display the contents of the stack
        // try to push some more elements
        ls.display();

        ls.push(30.0);
        ls.push(40.0);

        System.out.println(
            "After pushing 10.0,20.0,30.0,40.0");

        ls.display();

        // pop element from stack(40.0 is popped
        // out)
        ls.pop();

        // 30.0 is popped out
        // printing the stack after poping the elements
        ls.pop();

        System.out.println("after pop() operation");
        ls.display();

        // display the topmost element of the stack
        System.out.println(
            "current Topmost element of stack: "
            + ls.peek());

        // display the no.of elements of the stack
        System.out.println("current size of the stack: "
                           + ls.size());

        System.out.println();

        // Now create another Object with String Type
        // parameter
        LinkedStack<String> lss = new LinkedStack<>();

        // push a String message
        // onto the stack
        lss.push("How's your day?");
        lss.push("geek");
        lss.push("Hello!!");

        // Display the contents of the stack
        lss.display();
        lss.pop();
        System.out.println("after pop() operation");

        lss.display();

        // display the topmost string on
        // the stack
        System.out.println(
            "current Topmost element of stack: "
            + lss.peek());

        System.out.println("current size of the stack: "
                           + lss.size());
        // Although the implementation is using generics try
        // yourself and perform the above operations using
        // different datatypes as type parameters..
    }
}

// main method
public class GFG {
    // main driver method
    public static void main(String[] args)
    {
        // create an object of LinkedStack
        LinkedStack<Double> ls = new LinkedStack<>();

        Scanner sc = new Scanner(System.in);

        do {
            // As we are writing a menu driven program so
            // user can choose the operation he wants
            System.out.println("-----MENU-----");

            System.out.print(
                "1.push\n2.pop\n3.peek\n4.display\n5.size\n6.exit\n");

            System.out.println("Enter your choice:");

            int choice = sc.nextInt();

            switch (choice) {            
              case 1:
                System.out.println("Enter the element to push :");
                Double ele = sc.nextDouble();
                ls.push(ele);
                break;
            
              case 2:
                System.out.print("Poped element: ");
                System.out.println(ls.pop());
                break;
            
              case 3:
                System.out.println("topmost element :");
                System.out.println(ls.peek());
                break;
            
              case 4:
                ls.display();
                break;
            
              case 5:
                System.out.println("Total elements on stack: "+ ls.size());
                break;
            
              case 6:
                System.exit(1);
            
              default:
                System.out.println("Invalid choice!!");
            }
        } 
      while (true);
    }
}

public interface IStack<T> {
    // This Interface has the abstract methods
    // to be implemented by the LinkedStack
    // checks whether Stack is empty or not
    boolean isEmpty();

    // inserts an element onto the stack
    void push(T ele);

    // deletes and returns the beginning element on
    // the stack
    T pop();

    // returns the beginning element of the stack
    T peek();

    // returns the no.of elements present on stack
    int size();
}