Since you want to use stack to implement it and use == to judge, you should control it when pushing so that the objects added to the two stacks are the same.

public class MinStack {
    Stack<Integer> minstack = new Stack<Integer>();
    Stack<Integer> stack = new Stack<Integer>();
   
    public MinStack() {     
    }
    
    public void push(int x) {
        Integer val = new Integer(x);
        if(minstack.empty() || val <= minstack.peek())
            minstack.push(val);
        stack.push(val);
    }
    public void pop() {
        if(minstack.peek()==(stack.peek()))
            minstack.pop();
        stack.pop();
    }
    public int top() {
        return stack.peek();   
    }
    public int getMin(){
        return minstack.peek();  
    }
}

== compares references, and equals compares values.

== is to compare whether the addresses referenced by two strings are the same, that is, whether they point to the same object, while the equals method compares whether the contents of the strings are the same.
For example

String a = "abc";
String b = "abc";

a == b returns true, a.equals(b) also returns true.
Because the program has a string pool when it is running, when creating a string, it will first check whether there is a corresponding string in the pool. If it already exists, just point the reference to it. If not, create a new one.
In the above example, when a is created, an "abc" will be created first in the string pool, and then a points to it; when b is created, since "abc" already exists, b can point directly to it.
If changed to:

String a = "abc";
String b = new String("abc");

Then a == b returns false, and a.equals(b) returns true. Because when b is created, a new "abc" will be created regardless of whether "abc" exists, so the character creation objects pointed to by a and b are different, so false is returned.