Code to replace list of integers with nearest bigger element
As I already mentioned in a comment there's a bug in your replace2:
 input list 3,1,2,4 should result in 4,2,4,4 instead of all 4's since the 2 is the first bigger number on the right of number 1



Going for a List just for debugging seems odd to me. If you want to print a list to console you can use Arrays.toString(myArray) which looks exactly the same as myList.toString(). If you use a decent IDE you should be able to see the values clearly as well at a breakpoint. (I use IntelliJ and I know there are other IDE's that do this as well). In this case I would stick to using an array.

Since I currently only have java 8 installed for work I had a little trouble porting your program to java 8 to test it. The List.of() isn't available yet and any workaround to quickly initialise an explicit ArrayList gave me trouble. I instead changed all your ArrayList types to the more general List and it works. There's no reason to limit your method to ArrayList only.
Generally it's better to code using the interface instead of an explicit implementation. If at some point you would want to use a LinkedList instead of an ArrayList for example you can't use your current method.



Idea for a correct solution:
Loop through the list from right to left. Store the relevant larger numbers in a stack. At each step of the loop update the stack to only contain relevant larger numbers and replace the current element with the first (= smallest) larger element.

More concretely (try yourself first, use this if you're still stuck):

public static void replaceStack(int[] input) {
    if (input.length &lt; 2) {
        return; //empty or 1 element list are trivial
    }
    Deque&lt;Integer&gt; largerKnown = new LinkedList&lt;&gt;(); //Java Stack implementation
    largerKnown.add(input[input.length - 1]); //last element is never replaced
    for (int i = input.length - 2; i &gt;= 0; i--) { //loop from second to last downwards
        while (first element of stack is smaller) {
            remove first element from stack
        }
        if (largerKnown.isEmpty()) {
            largerKnown.addFirst(input[i]);
        } else {
            update the input[i] and add the old value of input[i] to the front of the stack
        }
    }
}


You'll still have to actually implement parts of this algorithm yourself. It shouldn't be that hard.