Code problem in Java

Question

I am doing a program in basic Java. At the moment there are 6 classes, however, you are having problems in 2 classes at the time of registration. I’m making a SET to register the name of the player in the chain list and then in case 6 I’m trying to print to see if it’s really working. (But it doesn’t print anything)

Chain list:

public class ListaEncadeada {

  private Nodo inicio;
  private Nodo fim;
  private int quantos;
  private int capacidade;

  public ListaEncadeada(int capacidade) {
    this.capacidade = capacidade;
  }

  public ListaEncadeada() {
    this.capacidade = 100;
  }

  public int getCapacidade() {
    return capacidade;
  }

  public int incluirJogador(Jogador umJogador) {

    Nodo temp = new Nodo();
    temp.setInfo(umJogador);
    if (quantos == 0) {
      inicio = fim = temp;
    } else if (quantos <= capacidade) {
      fim.setProx(temp);
      fim = temp;
    }
    quantos++;
    return 2;
  }

  public int getTamanho() {
    return quantos;
  }

  public Jogador get(int indice) {
    if ((indice >= 0) && (indice < quantos)) {
      Nodo temp = inicio;
      for (int i = 0; i < indice; i++) {
        temp = temp.getProx();
      }
      return temp.getInfo();
    }
    return null;
  }
}

and the interface is like this:

import java.util.Scanner;
import java.util.ArrayList;
import java.util.List;

public class Menu {
  private int qnts = 0;

  public void menuPrincipal() {
    Scanner entrada = new Scanner(System.in);
    int opcao;
    ListaEncadeada listaJogadores = new ListaEncadeada();
    do {
      System.out.println("------------------------General------------------------");
      System.out.println("1- Cadastro de jogador");
      System.out.println("2-Jogar");
      System.out.println("3-Ver pontuação da partida");
      System.out.println("4-Ver pontuação geral");
      System.out.println("5-Sair");
      opcao = entrada.nextInt();
      switch (opcao) {
        case 1:
          System.out.println("---------------CADASTRO DE JOGADOR----------------");
          System.out.println("Digite o nome do jogador:");
          Jogador player = new Jogador();
          player.setNome(entrada.nextLine());
          entrada.nextLine();
          listaJogadores.incluirJogador(player);

          //inserir na lista encadeada e verificar
          break;
        //
        case 2:
          System.out.println("----------------JOGAR----------------");
          System.out.println("Jogador 1:");
          String player1, player2;
          player1 = entrada.nextLine();
          System.out.println("Jogador 2:");
          player2 = entrada.nextLine();
          break;
        //
        case 3:
          System.out.println("----------------PONTUAÇÃO DA PARTIDA----------------");
          break;
        //
        case 4:
          System.out.println("----------------PONTUAÇÃO GERAL----------------");
          System.out.println(
              "Jogador | Numero de jogos | Numero de vitórias | Empates | Pontos | Derrotas |");
          int i;
          for (i = 0; i < listaJogadores.getTamanho(); i++) {
            /*System.out.println(""+listaJogadores.get(i).getNome()+"|"+listaJogadores.get(i).getNumJogos()+"|"+listaJogadores.get(i).getNumWin()+"|"+listaJogadores.get(i).getEmpates()+"|"+listaJogadores.get(i).getPontos()+"|"+listaJogadores.get(i).getDerrotas());  */
          }

          System.out.println("");

          break;
        //
        case 5:
          System.out.println("SAINDO DO PROGRAMA...");
          break;

        //teste
        case 6:

          System.out.println(listaJogadores.get(0).getNome());
          break;
        //

      }
    } while (opcao != 5);
  }
}

in case 6 also tried so and did not give:

Jogador jogadori= new Jogador();
jogadori.setNome(listaJogadores.get(0).getNome());

If anyone can help me thank you! I don’t know why I’m not able to include players in the list.

Answer 1

The problem is here:

player.setNome(entrada.nextLine());
entrada.nextLine();

You actually reversed the instructions. The first nextLine is that it only picks up the last line left of the last nextInt above and only the second nextLine is that it picks up the correct text for the player’s name.

Just reverse it to look like this:

entrada.nextLine();
player.setNome(entrada.nextLine());

As already indicated in the comments, then to be able to show all players will need to use a loop/cycle.

Take note that you have the same problem in case 2 of switch:

String player1, player2;
player1 = entrada.nextLine(); // <--- aqui

Where there must be nextLine emptiness before.

---

If you want to delve into this problem see this question from @Maniero

Answer 2

Take a look at this stuff. It will solve your problems on chained list Caelum

    public class AlunoLista {
          private String nome;
          private int idade;
          private AlunoLista proximo;
    }

public class Celula {
  private Celula proxima;
  private Object elemento;

  public Celula(Celula proxima, Object elemento) {
    this.proxima = proxima;
    this.elemento = elemento;
  }

  public Celula(Object elemento) {
    this.elemento = elemento;
  }

  public void setProxima(Celula proxima) {
    this.proxima = proxima;
  }

  public Celula getProxima() {
    return proxima;
  }

  public Object getElemento() {
    return elemento;
  }
}

public class ListaLigada {

  private Celula primeira;

  private Celula ultima;

  public void adiciona(Object elemento) {}
  public void adiciona(int posicao, Object elemento) {}
  public Object pega(int posicao) {return null;}
  public void remove(int posicao){}
  public int tamanho() {return 0;}
  public boolean contem(Object o) {return false;}
}

public void adicionaNoComeco(Object elemento) {
    Celula nova = new Celula(this.primeira, elemento);
    this.primeira = nova;

    if(this.totalDeElementos == 0){
      // caso especial da lista vazia
      this.ultima = this.primeira;
    }
    this.totalDeElementos++;
  }

public void adiciona(int posicao, Object elemento) {
  if(posicao == 0){ // No começo.
    this.adicionaNoComeco(elemento);
  } else if(posicao == this.totalDeElementos){ // No fim.
    this.adiciona(elemento);
  } else {
    Celula anterior = this.pegaCelula(posicao - 1);
    Celula nova = new Celula(anterior.getProxima(), elemento);
    anterior.setProxima(nova);
    this.totalDeElementos++;
  }
}

public String toString() {

  // Verificando se a Lista está vazia
  if(this.totalDeElementos == 0){
    return "[]";
  }

  StringBuilder builder = new StringBuilder("[");
  Celula atual = primeira;

  // Percorrendo até o penúltimo elemento.
  for (int i = 0; i 

private boolean posicaoOcupada(int posicao){
  return posicao >= 0 && posicao 

public Object pega(int posicao) {
  return this.pegaCelula(posicao).getElemento();
}

public int tamanho() {
    return this.totalDeElementos;
  }
}


public void removeDoComeco() {
  if (!this.posicaoOcupada(0)) {
    throw new IllegalArgumentException("Posição não existe");
  }

  this.primeira = this.primeira.getProxima();
  this.totalDeElementos--;

  if (this.totalDeElementos == 0) {
    this.ultima = null;
  }
}


public void removeDoFim() {
  if (!this.posicaoOcupada(this.totalDeElementos - 1)) {
    throw new IllegalArgumentException("Posição não existe");
  }
  if (this.totalDeElementos == 1) {
    this.removeDoComeco();
  } else {
    Celula penultima = this.ultima.getAnterior();
    penultima.setProxima(null);
    this.ultima = penultima;
    this.totalDeElementos--;
  }
}


public void remove(int posicao) {
  if (!this.posicaoOcupada(posicao)) {
    throw new IllegalArgumentException("Posição não existe");
  }

  if (posicao == 0) {
    this.removeDoComeco();
  } else if (posicao == this.totalDeElementos - 1) {
    this.removeDoFim();
  } else {
    Celula anterior = this.pegaCelula(posicao - 1);
    Celula atual = anterior.getProxima();
    Celula proxima = atual.getProxima();

    anterior.setProxima(proxima);
    proxima.setAnterior(anterior);

    this.totalDeElementos--;
  }
}


public boolean contem(Object elemento) {
  Celula atual = this.primeira;

  while (atual != null) {
    if (atual.getElemento().equals(elemento)) {
      return true;
    }
    atual = atual.getProxima();
  }
  return false;
}