Understanding your problem

Let's see this excerpt:

    for(int i=0; i < jogadores.length;i++){
        if(jogadores[i]== null){
            System.out.println("Deseja adicionar jogador? sim ou não");
            while(input.next().equals("sim")){
                System.out.println("Digite um nome");
                String nome = input.next();
                Jogador J = new Jogador(nome);
                jogadores[i] = J;

            }
        }
    }

First, at this point if is always true. It is therefore unnecessary.

Note that we have while within for . for traverses the array of players. while does what? It populates the same player several times. It should not be what you want. So I recommend that the code be this:

    out: for (int i = 0; i < jogadores.length; i++) {
        boolean adicionar = lerBoolean(
                input,
                "Deseja adicionar jogador? sim ou não",
                "Não entendi. Vamos tentar novamente.");
        if (!adicionar) break;
        System.out.println("Digite um nome");
        String nome = input.next();
        jogadores[i] = new Jogador(nome);
    }

This lerBoolean method would look like this:

    public static boolean lerBoolean(String mensagem, String naoEntendi) {
        while (true) {
            System.out.println(mensagem);
            String resposta = input.next().toUpperCase().trim();
            if (resposta.startsWith("S")) return true;
            if (resposta.startsWith("N")) return false;
            System.out.println(naoEntendi);
        }
    }

Other possible code improvements

Not to be limited to number 2 players, I suggest changing this:

Jogador[] jogadores = new Jogador[2];

So:

List<Jogador> jogadores = new ArrayList<>();

And so, the code of the loop looks like this:

   while (true) {
        boolean adicionar = lerBoolean(
                input,
                "Deseja adicionar jogador? sim ou não",
                "Não entendi. Vamos tentar novamente.");
        if (!adicionar) break;
        System.out.println("Digite um nome");
        String nome = input.next();
        jogadores.add(new Jogador(nome));
    }

This also removes the i variable, allows you to have any number of players, and frees you from the need to check for any null somewhere in the array. The second loop could then be simplified to this:

for (Jogador j : jogadores) {
    boolean aceita = lerBoolean(
                input,
                j.getNome() + " Deseja apostar? sim ou não",
                "Não entendi. Vamos tentar novamente.");
    if (aceita) {
        apostar(j);
    } else if (j.getSemapostas() == 3) {
        System.out.println("Você está sem apostar há três rodadas.");
        apostar(j);
    } else {
        j.SemApostar();
    }
}

This is best done by putting the apostar method inside the Jogador class, after all who performs the after is the player, and therefore the method is his. With this apostar(j); becomes j.apostar(); . I also suggest renaming the getSemapostas method to getSemApostas , SemApostar to semApostar and Rodar to rodar , since the convention dictates that the initial of each word (except the first) in the method name should be uppercase.

This can also be optimized in another way: If the player has already been three rounds without a bet, then he does not even have to ask if he wants to bet or not, as he is forced to do so:

for (Jogador j : jogadores) {
    if (j.semApostas() == 3) {
        System.out.println("Você está sem apostar há três rodadas.");
        apostar(j);
    } else {
        boolean aceita = lerBoolean(
                input,
                j.getNome() + " Deseja apostar? sim ou não",
                "Não entendi. Vamos tentar novamente.");
        if (aceita) {
            apostar(j);
        } else {
            j.SemApostar();
        }
    }
}

Incidentally, it would be interesting to put this as a method to fazerApostas part. I'll address this further.

In the Rodar method, this loop:

    for (int i =0;i<jogadores.length;i++){
        Jogador JG = jogadores[i];

It looks like this:

    for (Jogador jg : jogadores) {

However, the apostar(Jogador) method has problems too. Both the main and apostar(Jogador) methods are creating Scanner s different and you should only have Scanner . The apostar method is also creating a Banca instead of using an existing one and another bank is being used in the Rodar method. Therefore, Banca and input should be created in main and passed on to both methods.

Copying and pasting code is one of the worst programming practices in existence. Avoid as much as you can. In your Rodar method there is the following code copied and pasted a lot of times:

                if(<alguma condição>){ // acertou
                    if(banc.getBudget()>= JG.getFichasApostadas()*2){// verifique o budget do banco (Suficiente)
                        banc.pagarJogador(JG.getFichasApostadas()*2);// Atualise o budget do banco
                        JG.ganharFichas(JG.getFichasApostadas()*2); //paga joador
                        System.out.println(JG.getNome());
                        System.out.println(numero + " "+cor);
                        System.out.println(JG.getNome() + " acertou");
                        System.out.println("-------------------------");
                        System.out.println("saldo atual : " + JG.getFichas());
                    }else                               // verifique o budget do banco (Insuficiente)
                        System.out.println(JG.getNome() + " deixou a banca pobre");

                }
                else{                           //não acertou
                    banc.ganharDoJogador(JG.getFichasApostadas());
                    System.out.println(JG.getNome());
                    System.out.println(numero + " "+cor);
                    System.out.println(JG.getNome() +" não acertou");
                    System.out.println("-------------------------");
                    System.out.println("saldo atual : " + JG.getFichas());
                }

We can restructure this method by writing the condition of if to a variable and then doing that logic only afterwards (due to the fact that the multiplication factor can be 2 or 36, depending on the case). Almost all of the contents of this Rodar method can be entirely moved to the Banca class:

public void pagar(Roleta r, Jogador j) {
    System.out.println(j.getNome());
    int numero = r.getNumero();
    String cor = r.getCor();
    System.out.println(numero + " " + cor);
    String apostado = j.getAposta();
    boolean cond
            = apostado.equals("par") ? numero > 0 && numero % 2 == 0
            : apostado.equals("impar") ? numero > 0 && numero % 2 == 1
            : apostado.equals("vermelho") ? cor.equals("vermelho")
            : apostado.equals("preto") ? cor.equals("preto")
            : apostado.equals("menor") ? numero >= 1 && numero <= 18
            : apostado.equals("maior") ? numero >= 19 && numero <= 36
            : apostado.equals("numero") ? numero == j.getNumeroAposta();
    boolean fator = apostado.equals("numero") ? 36 : 2;

    int aposta = j.getFichasApostadas();
    int premio = aposta * fator;
    int budget = getBudget();
    if (premio > budget) premio = budget;

    if (!cond) {
        ganharDoJogador(aposta);
        System.out.println(j.getNome() + " não acertou");
    } else if (getBudget() >= premio) {
        pagarJogador(premio);
        j.ganharFichas(premio);
        System.out.println(j.getNome() + " acertou");
        if (premio == budget) System.out.println(j.getNome() + " deixou a banca pobre.");
    }

    System.out.println("-------------------------");
    System.out.println("Saldo atual: " + j.getFichas());
}

In your class Jogo , this would remain in the rodar method:

public static void rodar(Roleta r, Banca b, List<Jogador> jogadores) {
    r.rodar();
    for (Jogador j : jogadores) {
        b.pagar(r, j);
    }
}

Please note that I put the roulette and the bench as parameters, after all, you may want to do several rounds with the same players, the same bank and the same roulette. In fact, this suggests that these are the attributes of Jogo (and this method would be instance), and therefore its Jogo class is in its final form as below:

How it gets at the end

public class Jogo {
    private final List<Jogador> jogadores;
    private final Roleta roleta;
    private final Banca banca;
    private final Entrada entrada;

    public Jogo(List<Jogador> jogadores) {
        this.jogadores = jogadores;
        this.roleta = new Roleta();
        this.banca = new Banca();
        this.entrada = new Entrada();
    }

    public static void main(String[] args) {
        List<Jogador> jogadores = new ArrayList<>();

        while (true) {
            boolean adicionar = entrada.lerBoolean(
                    "Deseja adicionar jogador? sim ou não",
                    "Não entendi. Vamos tentar novamente.");
            if (!adicionar) break;
            String nome = entrada.lerString("Digite um nome");
            jogadores.add(new Jogador(nome));
        }
        Jogo j = new Jogo(jogadores);
        j.jogar();
    }

    private void fazerApostas() {
        for (Jogador j : jogadores) {
            if (j.semApostas() == 3) {
                System.out.println("Você está sem apostar há três rodadas.");
                j.apostar(entrada, banca);
            } else {
                boolean aceita = entrada.lerBoolean(
                        j.getNome() + " Deseja apostar? sim ou não",
                        "Não entendi. Vamos tentar novamente.");
                if (aceita) {
                    j.apostar(entrada, banca);
                } else {
                    j.semApostar();
                }
            }
        }
    }

    public void jogar() {
        rodar();
    }

    public void rodar() {
        fazerApostas();
        roleta.rodar();
        for (Jogador j : jogadores) {
            banca.pagar(roleta, j);
        }
    }
}

Use the strings "pair", "odd", "red", etc. to denote the type of bet is a bag. Use% s of% s and note that it already encapsulates logic to determine whether or not the roulette number is accepted:

public enum Cor {
    VERMELHO, PRETO;
}

public enum TipoAposta implements Regra {
    PAR((n, c, a) -> n > 0 && n % 2 == 0),
    IMPAR((n, c, a) -> n > 0 && n % 2 == 1),
    VERMELHO((n, c, a) -> c == Cor.VERMELHO),
    PRETO((n, c, a) -> c == Cor.PRETO),
    MENOR((n, c, a) -> n >= 1 && n <= 18),
    MAIOR((n, c, a) -> n >= 19 && n <= 36),
    NUMERO((n, c, a) -> n == a);

    private final Regra regra;

    private TipoAposta(Regra regra) {
        this.regra = regra;
    }

    @Override
    public boolean validar(int numero, Cor cor, int apostado) {
        return regra.validar(numero, cor, apostado);
    }

    public int getFator() {
        return this == NUMERO ? 36 : 2;
    }
}

public interface Regra {
    public boolean validar(int numero, Cor cor, int apostado);
}

With this, the enum method of class pagar looks like this:

public void pagar(Roleta r, Jogador j) {
    System.out.println(j.getNome());
    int numero = r.getNumero();
    Cor cor = r.getCor();
    System.out.println(numero + " " + cor);
    TipoAposta apostado = j.getAposta();
    boolean cond = apostado.validar(numero, cor, j.getNumeroAposta());
    int aposta = j.getFichasApostadas();
    int premio = aposta * apostado.getFator();
    int budget = getBudget();
    if (premio > budget) premio = budget;

    if (!cond) {
        ganharDoJogador(aposta);
        System.out.println(j.getNome() + " não acertou.");
    } else if (getBudget() >= premio) {
        pagarJogador(premio);
        j.ganharFichas(premio);
        System.out.println(j.getNome() + " acertou.");
        if (premio == budget) System.out.println(j.getNome() + " deixou a banca pobre.");
    }

    System.out.println("-------------------------");
    System.out.println("Saldo atual: " + j.getFichas());
}

The type of attribute Banca in class cor becomes Roleta instead of Cor . The type of attribute String in class aposta becomes Jogador instead of TipoAposta . The respective getters and setters also change the same way.

We also take advantage of centralizing all data read operations in a String class:

public class Entrada {

    private final Scanner input;

    public Entrada() {
        this.input = new Scanner(System.in);
    }

    public String lerString(String mensagem) {
        System.out.println(mensagem);
        return input.next();
    }

    public int lerInt(String mensagem) {
        System.out.println(mensagem);
        return input.nextInt();
    }

    public boolean lerBoolean(String mensagem, String naoEntendi) {
        while (true) {
            System.out.println(mensagem);
            String resposta = input.next().toUpperCase().trim();
            if (resposta.startsWith("S")) return true;
            if (resposta.startsWith("N")) return false;
            System.out.println(naoEntendi);
        }
    }

    public TipoCor lerTipo(String mensagem, String naoEntendi) {
        List<String> opcoes = Arrays.asList(escolhas);
        while (true) {
            System.out.println(mensagem);
            String resposta = input.next().toUpperCase().trim();
            try {
                return TipoCor.valueOf(resposta);
            } catch (IllegalArgumentException) {
                System.out.println(naoEntendi);
            }
        }
    }
}

In class Entrada , the Jogador method looks like this:

public void apostar(Entrada entrada, Banca b) {
    if (getFichas() == 0) {
        System.out.println("Você não tem fichas!");
        semApostar();
        return;
    }
    System.out.println("Apostar");
    System.out.println("--------");
    String msg = "Par ou impar\nPreto ou vermelho\nNumero\nMaior ou Menor";
    TipoAposta aposta = entrada.lerTipo(msg, "Não entendi. Vamos tentar novamente.");
    setAposta(aposta);

    System.out.println("Insire o valor (número de fichas): ");
    int fichas = entrada.lerInt();
    setFichasApostadas(fichas);
    b.ganharDoJogador(fichas);
    if (aposta == TipoAposta.NUMERO) {
        System.out.println("Qual número deseja apostar?");
        setNumeroAposta(entrada.lerInt());
    }
}

It should be possible to do a lot more simplifications and improvements, but you did not give the code apostar , Banca and Roleta to that.

Note that in class Jogador I put a Jogo method that for the moment only calls jogar . In this method is that you will make the logic to perform several rounds until all players except one are without chips.

I do not know if it will help, but I would do the code like this: So you're sure to fall into the loop at least.

 String option;
        do{
            System.out.println("Deseja adicionar jogador? sim ou não");
            option = input.next();
            if (option.equals("sim")){
                System.out.println("Digite um nome");
                String nome = input.next();
                Jogador J = new Jogador(nome);
                jogadores[i] = J;
            }
        }while(option.equals("sim"));