Dynamic array based stack

I'm trying to create a dynamic array based stack and I am getting an index out of bound error when I try to push elements elements onto a full array. I also made the array generic to accommodate all types of stacks.

import java.util.Arrays;
import java.util.Iterator;

public class Stack<T> {
	private int topStack;
	private int stackSize;
	private T[] stack;

	// Constructor
	public Stack(T[] arr) {
		stack = arr;
		stackSize = arr.length;
		topStack = -1;
	}

	// isEmpty
	public boolean isEmpty() {
		if (topStack == -1)
			return true;
		return false;
	}

	// isFull method
	public boolean isFull() {
		if ((topStack + 1) == stackSize)
			return true;
		return false;
	}

	// increment array by 10 spaces <-----------------------------------
	public void incrementArray() {
		T[] temp = (T[]) new Object[stackSize*2];
		System.arraycopy(stack, 0, temp, 0, stack.length);
		stack=temp;
		stackSize=stackSize*2;
	}

	// decrement array
	public void decrementArray() {
		stackSize=stackSize/2;
		T[] temp = (T[]) new Object[stackSize];
		System.arraycopy(stack, 0, temp, 0, stackSize);
		stack=temp;
	}

	// push method which adds element to top of stack
	public void push(T element) {
		if (isFull())
			incrementArray();
		topStack=topStack+1;
		stack[topStack] = element;
	}

	// peek method which shows top of stack without popping it
	public T peek() {
		return stack[topStack];
	}

	// pop which copies top of stack, deletes top and returns copy
	public T pop() throws EmptyStackException {
		if (isEmpty()) {
			throw new EmptyStackException();
		}
		int temp = topStack+1;
		if(temp<stackSize/2)
			decrementArray();
		return stack[topStack--];
	}

	public static void main(String[] args)  {
		Stack operands = new Stack<>(new Integer[0]);
		
			operands.push(2);
			operands.push(1);

	}
}

I'm trying to increase the stack size instead of having it overflow out of bounds.

You should give your stack an initial size > 0. As it stands, your initial stackSize is 0. And guess what stackSize*2 is equal to? And another observation is that you created a generic stack but did not specify a type when creating it in main

Also, note that you can change

public boolean isEmpty() {
if (topStack == -1)
return true;
return false;
}

to

public boolean isEmpty() {
return topStack == -1;
}

You can make similar changes in other methods that return a boolean.

When your code does not behave the way it should, think about what is going on and why that might happen. Placing ubiquitous print statements thru out your code is a good first step to check on key values to see if they are what you expect them to be. A more sophisticated method is to use a debugging tool to step thru your program as it executes to look at the values of various fields.

you should use linked list stack which is dynamically allocated memory. those stack never overflow. it is overflow when your computer memory will full

public class DynamicStack {
static  class Node{
int data;
Node next;
Node(int d){
data = d;
next = null;
}
}
static class Stack{
public static  Node topHead;
public static boolean isEmpty(){
return topHead == null;
}
public static void push(int data){
Node newnode = new Node(data);
if(isEmpty()){
topHead = newnode;
return;
}
newnode.next = topHead;
topHead = newnode;
}
public static int pop(){
if (isEmpty()) {
return -1;
}
int data = topHead.data;
topHead = topHead.next;
return data;
}
public static int peek(){
if (isEmpty()) {
return -1;
}
return topHead.data;
}
}
public static void main(String[] args) {
Stack st = new Stack();
st.push(1);
st.push(2);
st.push(3);
st.push(4);
while (!st.isEmpty()) {
System.out.println(st.peek());
st.pop();
}
}
}

i hope this is useful for you