Redimensionar largura das colunas de jTable com TableModel próprio

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<Jogador> 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<Jogador>();
	}

	/* Cria um CadastroTableModel carregado com
	 * a lista de jogadores especificada. */
	public CadastroTableModel(List<Jogador> listaDeJogadores) {
		linhas = new ArrayList<Jogador>(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<Jogador> 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();
	}
}