Solving maze problem with backtracking solution using stack
Your solution looks correct. Your don't need to find a similar implementation to validate yours. You just need to verify yours works correctly, by stepping through the logic as if with a debugger, and verifying all execution paths, and considering all possible corner cases. 

By the way, recursive solutions use a stack too, just implicitly. They take advantage of the function call stack, which stores the program state every time you step into a function, and pops it when leaving a function, returning to the caller. Manually implementing a stack based solution is typically less convenient, but more powerful and efficient, because you have full control over the stack and its entries, which can be perfectly sized.

Although your solution works, I would write it slightly differently:


The logic would be slightly easier to understand if all the conditions of the movement were organized in the same if-else chain inside the loop
Instead of adding the next position to the stack, it's more conventional to add the current one
The Stack class is no longer recommended in Java, use Deque and ArrayDeque instead
Instead of int[] end = new int[]{maxY, maxX};, a shorter more convenient form exists: int[] end = {maxY, maxX};. (Unfortunately this form works only at initialization, it doesn't work for assignment in general.)
It's more natural to store coordinates as (x, y) pair instead of (y, x) pair


Like this:

public static boolean solve(boolean[][] maze) {
    int maxY = maze.length - 1;
    int maxX = maze[0].length - 1;

    Deque&lt;int[]&gt; stack = new ArrayDeque&lt;&gt;();
    int x = 0;
    int y = 0;

    while (true) {
        if (x == maxX &amp;&amp; y == maxY) {
            // Found the exit!
            return true;
        } else if (x + 1 &lt;= maxX &amp;&amp; maze[y][x + 1]) {
            // Try moving right
            stack.push(new int[]{x + 1, y});
            x++;
        } else if (y + 1 &lt;= maxY &amp;&amp; maze[y + 1][x]) {
            // Try moving down
            stack.push(new int[]{x, y + 1});
            y++;
        } else if (!stack.isEmpty()) {
            // Mark as dead end (so we will not try to reach here again)
            maze[y][x] = false;
            int[] current = stack.pop();
            x = current[0];
            y = current[1];
        } else {
            // No way to go -&gt; impossible to reach the exit
            return false;
        }
    }
}