Game on numeric arrays

At first glance it looks like it doesn't matter in what order the items are removed. The end result will always be the same.

If that statement is correct, your code will give the right answer for any individual game.

There is however 1 edge case for which you will give the wrong result. It's for a game that has no possible moves from the start. (For example: 0 1 1). This can be easily fixed by not setting the winner during the loop, but just after the loop. All we need to do is "swap" players 1 more time after a game to see who won.

Since we don't actually need to keep track of the winner anymore (you print the winner right after a game and don't use the variable after that) we might as well just get rid of the variable altoghether.

As for the code review. Let me start by giving my resulting code after all improvements to what you currently have and then point out some things I did.

public class Solution {
    public enum Player {
        A {@Override public Player turn() {return B;}},
        B {@Override public Player turn() {return A;}},;

        public abstract Player turn();
    }

    public static void main(String[] args) throws Exception {
        try (Scanner in = new Scanner(System.in)) {
            int nbOfGames = in.nextInt();
            Player currentPlayer = Player.A;
            for (int i = 0; i < nbOfGames; i++) {
                currentPlayer = playGame(readSequence(in), currentPlayer);
                System.out.println(currentPlayer);
                currentPlayer = Player.A; //In a new game always player A's turn first.
            }
        }
    }

    public static List<Integer> readSequence(Scanner in) {
        int n = in.nextInt();
        List<Integer> sequence = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            sequence.add(in.nextInt());
        }
        return sequence;
    }

    /**
     * returns the winner.
     */
    public static Player playGame(List<Integer> sequence, Player startingPlayer) {
        Player currentPlayer = startingPlayer;
        for (int i = 1; i < sequence.size() - 1; i++) {
            if (sequence.get(i - 1) == 0 && (sequence.get(i + 1) == 0)) {
                currentPlayer = currentPlayer.turn();
                sequence.remove(i);
                i = 0; // set to 0 so it turns to 1 again after this iteration ends.
            }
        }
        return currentPlayer.turn();
    }
}

Renamed Players -> Player. An instance of this "class" is a single player.

Split up reading input sequence to its own method.

Split up playing a single game to its own method.

When reading the input, directly put it into a List<Integer> instead of converting it afterwards.

Removed Players winner since it's obsolete.

Renamed sequence_i to i in for loop for reading input sequence.

Renamed g to nbOfGames to clarify its meaning.

Renamed a0 to i when looping over nbOfGames (No clash with other index names since they are in their own methods).

Used Try-with-resource feature so I don't have to care about closing the scanner.

Made the choice explicit of which player has to start for each sequence. Indirectly fixed the ambiguity of who wins when a game has no valid turns to start with.

Stored the sequence as a List<Integer> instead of ArrayList<Integer>. It's always better to code against an interface instead of a specific implementation. In this case we only care that it's a List not what kind of list.

Perhaps some more things that I did unconciously.

A fun side effect of splitting off the playGame method like this is that it's also easier to test it without user input. You can just create a list with your wanted test sequence and see if the method returns the correct player.