Código do TableModel:
[code]package gerenciamentodecampeonatos;
import java.util.ArrayList;
import java.util.List;
import javax.swing.table.AbstractTableModel;
/**
*
-
@author C. Neto
/
public class CadastroTableModel extends AbstractTableModel {
/ Lista de Jogadores que representam as linhas. */
private List linhas;/* Array de Strings com o nome das colunas. /
private String[] colunas = new String[] {
"", “Nome”, “Email”, “NumUSP”, “Tel”};/* Cria um CadastroTableModel vazio. */
public CadastroTableModel() {
linhas = new ArrayList();
}/* Cria um CadastroTableModel carregado com
- a lista de jogadores especificada. */
public CadastroTableModel(List listaDeJogadores) {
linhas = new ArrayList(listaDeJogadores);
}
/* Retorna a quantidade de colunas. */
@Override
public int getColumnCount() {
// Está retornando o tamanho do array “colunas”.
// Mas como o array é fixo, vai sempre retornar 5.
return colunas.length;
}/* Retorna a quantidade de linhas. */
@Override
public int getRowCount() {
// Retorna o tamanho da lista de jogadores.
return linhas.size();
}/* Retorna o nome da coluna no índice especificado.
- Este método é usado pela JTable para saber o texto do cabeçalho. */
@Override
public String getColumnName(int columnIndex) {
// Retorna o conteúdo do Array que possui o nome das colunas
// no índice especificado.
return colunas[columnIndex];
};
/* Retorna a classe dos elementos da coluna especificada.
- Este método é usado pela JTable na hora de definir o editor da célula. */
@Override
public Class<?> getColumnClass(int columnIndex) {
// Retorna a classe referente a coluna especificada.
// Aqui é feito um switch para verificar qual é a coluna
// e retornar o tipo adequado. As colunas são as mesmas
// que foram especificadas no array “colunas”.
switch (columnIndex) {
case 0: // Primeira coluna é o id, que é um int.
return int.class;
case 1: // Segunda coluna é o nome, que é uma String…
return String.class;
case 2: // Terceira coluna é o email,
return String.class;
case 3: // Quarta coluna é o número USP,
return int.class;
case 4: // Quinta coluna é o telefone.
return String.class;
default:
// Se o índice da coluna não for válido, lança um
// IndexOutOfBoundsException (Exceção de índice fora dos limites).
// Não foi necessário verificar se o índice da linha é inválido,
// pois o próprio ArrayList lança a exceção caso seja inválido.
throw new IndexOutOfBoundsException(“columnIndex out of bounds”);
}
}
/* Retorna o valor da célula especificada
-
pelos índices da linha e da coluna. */
@Override
public Object getValueAt(int rowIndex, int columnIndex) {
// Pega o jogador da linha especificada.
Jogador jog = linhas.get(rowIndex);// Retorna o campo referente a coluna especificada.
// Aqui é feito um switch para verificar qual é a coluna
// e retornar o campo adequado. As colunas são as mesmas
// que foram especificadas no array “colunas”.
switch (columnIndex) {
case 0: // Primeira coluna é o id.
return jog.getId();
case 1: // Segunda coluna é o nome.
return jog.getNome();
case 2: // Terceira coluna é email.
return jog.getEmail();
case 3: // Quarta coluna é o número USP.
return jog.getNumUSP();
case 4: // Quinta coluna é o telefone.
return jog.getTelefone();
default:
// Se o índice da coluna não for válido, lança um
// IndexOutOfBoundsException (Exceção de índice fora dos limites).
// Não foi necessário verificar se o índice da linha é inválido,
// pois o próprio ArrayList lança a exceção caso seja inválido.
throw new IndexOutOfBoundsException(“columnIndex out of bounds”);
}
}
/* Seta o valor da célula especificada
-
pelos índices da linha e da coluna.
-
Aqui ele está implementado para não fazer nada,
-
até porque este table model não é editável. */
public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
// Pega o jogador da linha especificada.
Jogador jog = linhas.get(rowIndex);// Retorna o campo referente a coluna especificada.
// Aqui é feito um switch para verificar qual é a coluna
// e setar o campo adequado. As colunas são as mesmas
// que foram especificadas no array “colunas”.
switch (columnIndex) {
case 0: // Primeira coluna é o id.
if (aValue.getClass() == int.class)
jog.setId (Integer.parseInt(aValue.toString()));
case 1: // Segunda coluna é o nome.
if (aValue.getClass() == String.class)
jog.setNome(aValue.toString());
case 2: // Terceira coluna é email.
if (aValue.getClass() == String.class)
jog.setEmail(aValue.toString());
case 3: // Quarta coluna é o número USP.
if (aValue.getClass() == int.class)
jog.setNumUSP (Integer.parseInt(aValue.toString()));
case 4: // Quinta coluna é o telefone.
if (aValue.getClass() == String.class)
jog.setTelefone(aValue.toString());
default:
// Se o índice da coluna não for válido, lança um
// IndexOutOfBoundsException (Exceção de índice fora dos limites).
// Não foi necessário verificar se o índice da linha é inválido,
// pois o próprio ArrayList lança a exceção caso seja inválido.
throw new IndexOutOfBoundsException(“columnIndex out of bounds”);
}
}
/* Retorna um valor booleano que define se a célula em questão
- pode ser editada ou não.
- Este método é utilizado pela JTable na hora de definir o editor da célula.
- Neste caso, estará sempre retornando false, não permitindo que nenhuma
- célula seja editada. */
@Override
public boolean isCellEditable(int rowIndex, int columnIndex) {
return false;
}
/* Retorna o jogador da linha especificada. */
public Jogador getJogador(int indiceLinha) {
return linhas.get(indiceLinha);
}/* Adiciona um registro. */
public void addJogador(Jogador jog) {
// Adiciona o registro.
linhas.add(jog);// Pega a quantidade de registros e subtrai um para achar // o último índice. É preciso subtrair um, pois os índices // começam pelo zero. int ultimoIndice = getRowCount() - 1; // Reporta a mudança. O JTable recebe a notificação // e se redesenha permitindo que visualizemos a atualização. fireTableRowsInserted(ultimoIndice, ultimoIndice);}
/* Remove a linha especificada. */
public void removeJogador(int indiceLinha) {
// Remove o jogador da linha especificada.
linhas.remove(indiceLinha);// Reporta a mudança. O JTable recebe a notificação // e se redesenha permitindo que visualizemos a atualização. fireTableRowsDeleted(indiceLinha, indiceLinha);}
/* Adiciona uma lista de jogadores ao final dos registros. */
public void addListaDeJogador(List jog) {
// Pega o tamanho antigo da tabela.
int tamanhoAntigo = getRowCount();// Adiciona os registros. linhas.addAll(jog); // Reporta a mudança. O JTable recebe a notificação // e se redesenha permitindo que visualizemos a atualização. fireTableRowsInserted(tamanhoAntigo, getRowCount() - 1);}
/* Remove todos os registros. */
public void limpar() {
// Remove todos os elementos da lista de jogadores.
linhas.clear();// Reporta a mudança. O JTable recebe a notificação // e se redesenha permitindo que visualizemos a atualização. fireTableDataChanged();}
/* Verifica se este table model está vazio. */
public boolean isEmpty() {
return linhas.isEmpty();
}
}[/code] - a lista de jogadores especificada. */
Agora vem a dúvida…como setar a largura das colunas dentro do TableModel? Eu precisaria de um método pra isso e chamar no meu programa ou posso fazer isso no construtor?
Outra dúvida, como aplicar esse TableModel na minha jTable da minha aplicação?
