{"id":11591,"date":"2023-01-06T07:24:45","date_gmt":"2023-01-06T07:24:45","guid":{"rendered":"https:\/\/www.prepbytes.com\/blog\/?p=11591"},"modified":"2023-01-09T07:48:13","modified_gmt":"2023-01-09T07:48:13","slug":"stack-program-in-java","status":"publish","type":"post","link":"https:\/\/prepbytes.com\/blog\/stack-program-in-java\/","title":{"rendered":"Stack Program in Java"},"content":{"rendered":"

\"\"<\/p>\n

In this article, we will write a Stack program in Java. We will learn about the stack class in Java, how to create a stack, different methods of a stack in Java, and how to iterate over a stack in Java. So, let\u2019s get started.<\/p>\n

What is Stack Data structure?<\/h2>\n

The Stack data structure is a linear data structure based on the FILO (First in Last out) or LIFO (Last in First out) principle. The word stack can be easily imagined as a pile of objects, one above the another. For instance, in a stack of books, the book kept at the top was the last element to enter the stack and if we want to empty the stack by removing the elements one by one, the book at the top of the stack will be the first element we will choose to remove from the stack as it is the most convenient one to be removed.<\/p>\n

So, a \u201cstack\u201d of real-world objects in general also follows the Last in First out (LIFO) principle. A stack data structure is shown below.<\/p>\n

\"\"<\/p>\n

So, the above image shows an empty stack. <\/p>\n

Push Operation in Stack:<\/h3>\n

To put an element inside a stack<\/strong> is generally referred to as a push<\/strong> operation. For instance, when we push 10 in the stack, the stack will now contain 10.<\/p>\n

\"\"<\/p>\n

So, let us push some more elements in the stack as shown below.<\/p>\n

\"\"<\/p>\n

So, we can see that the element that is pushed last into the stack is at the top of the stack. This is the general behavior of the stack data structure.<\/p>\n

Pop Operation in Stack:<\/h3>\n

Now, let us try to remove some elements from the stack. Removing an element<\/strong> from the stack is referred to as a pop<\/strong> operation.<\/p>\n

\"\"<\/p>\n

So, we can see that when we pop from the stack, the topmost element of the stack gets removed. The stack after popping once is shown below.<\/p>\n

\"\"<\/p>\n

So, 40 is now the top of the stack. If we pop once again, then 40 will be removed from the stack as shown below.<\/p>\n

\"\"<\/p>\n

So, this is what stack data structure is and the push and pop are the 2 main operations on a stack. <\/p>\n

Peek Operation in Stack<\/h3>\n

Let us also understand the third very main operation called the top or peek of the stack.<\/strong> The top or peek simply means giving the topmost element of the stack. For instance, the top\/peek of the stack is shown below for different stacks.<\/p>\n

\"\"<\/p>\n

So, at any moment, the element that is the topmost element of the stack is called the peek of the stack. <\/p>\n

Let us now also understand the working of push, pop, and top operations in a stack.<\/p>\n

Stack Program in Java – Working of Push, Pop, and Peek Operations<\/h2>\n

So, we have studied and understood the different operations of a Stack data structure. However, let us now understand how these operations work. Consider an empty stack shown below.<\/p>\n

\"\"<\/p>\n

A stack data structure can be created using an array or a list when it comes to its implementation. An empty stack is a stack whose top = -1.<\/strong> Since the top pointer points to the topmost element of the stack and -1 is an invalid index, we can say that the stack is empty.<\/p>\n

What happens when we push an element into the stack? This is shown below.<\/p>\n

\"\"<\/p>\n

So, when we push an element into the stack, the top pointer first increments its value<\/strong> and brings it to the position where the upcoming element (i.e. upcoming top) would be inserted.Then, at that position<\/strong> in the array or the list, we insert the element.<\/strong> This is shown both diagramatically and with the help of pseudo-code in the image above.<\/p>\n

Now, let us learn how the pop operation works. Consider the stack filled with some values as shown below.<\/p>\n

\"\"<\/p>\n

Now, let us pop an element from this stack.<\/p>\n

\"\"<\/p>\n

So, the image above shows what happens when we pop an element from the stack both diagrammatically and by pseudo-code. The element at which the top pointer is pointing is first removed<\/strong> from the underlying array or list and then the value of the top pointer is decremented.<\/strong> <\/p>\n

What happens when we perform the operation peek()? Well, we simply return the element at the top i.e. we return the element to which the top pointer is pointing.<\/strong><\/p>\n

Now, just one more question left. We have seen what happens when the stack is empty. However, is a stack ever full? What happens if a stack is full?<\/strong><\/p>\n

So, if we implement a stack using an array<\/strong>, we know when it will be full i.e. when top = array.length<\/strong> as the array has a fixed size i.e. we are restricting the number of elements that can be pushed into the stack.<\/p>\n

However, if we are using a list to implement a stack, we can\u2019t say when it will be full. We can just say that if the memory limit exceeds,<\/strong> the stack will be full.<\/p>\n

Now that we have understood all the operations of a stack, let us create our own stack class and write a stack program in Java.<\/p>\n

Stack Program in Java – Implementing our own Stack<\/strong><\/p>\n\t\t\t\t\t\t