Formatando números no JTable

private void defineRenderers() {
		DefaultTableCellRenderer rendererCentro = new DefaultTableCellRenderer();
		rendererCentro.setHorizontalAlignment(SwingConstants.CENTER);
		DefaultTableCellRenderer rendererDireita = new DefaultTableCellRenderer();
		rendererDireita.setHorizontalAlignment(SwingConstants.RIGHT);
		DefaultTableCellRenderer rendererEsquerda = new DefaultTableCellRenderer();
		rendererEsquerda.setHorizontalAlignment(SwingConstants.LEFT);

		JTableHeader header = tabela.getTableHeader(); 
		header.setPreferredSize(new Dimension(0, 25)); 
		TableColumnModel modeloDaColuna = tabela.getColumnModel();
		
		modeloDaColuna.getColumn(0).setCellRenderer(rendererEsquerda);
		modeloDaColuna.getColumn(1).setCellRenderer(rendererDireita);
		modeloDaColuna.getColumn(2).setCellRenderer(rendererDireita);
		modeloDaColuna.getColumn(3).setCellRenderer(rendererDireita);
		modeloDaColuna.getColumn(4).setCellRenderer(rendererDireita);
		
		modeloDaColuna.getColumn(0).setPreferredWidth(300);
		modeloDaColuna.getColumn(1).setMaxWidth(80);
		modeloDaColuna.getColumn(2).setMaxWidth(80);
		modeloDaColuna.getColumn(3).setMaxWidth(80);
		modeloDaColuna.getColumn(4).setMaxWidth(80);
	}

public static void atualizaLista(){
        String dbURL = "jdbc:mysql://localhost/jusms";
        Connection c = null;
        ResultSet r = null;

        try
        {
           Class.forName("com.mysql.jdbc.Driver").newInstance();
           c = DriverManager.getConnection(dbURL, "", "");
           Statement s = c.createStatement();
           r = s.executeQuery("SELECT * FROM users ORDER BY login");

           while (r.next()){
               DefaultTableModel modelo = (DefaultTableModel)getTabela().getModel();
               modelo.addRow(new String [] {r.getString("nome"), r.getString("login")});
               getTabela().setModel(modelo);
           }

        } catch (InstantiationException e)
        {
           e.printStackTrace();
        } catch (IllegalAccessException e)
        {
           e.printStackTrace();
        } catch (ClassNotFoundException e)
        {
           e.printStackTrace();
        } catch (SQLException e)
        {
           e.printStackTrace();
        } finally
        {
           try
           {
              r.close();
              c.close();
           } catch (SQLException e1)
           {
              e1.printStackTrace();
           }
        }
    }

[<em>]repaint();

[</em>]revalidate();

[*]updateUI();

package objetos;

import bancodados.Conexao;
import javax.swing.table.AbstractTableModel;
import java.util.Vector;

public class ContinenteTableModel extends AbstractTableModel
{
    //Títulos das colunas.
    static protected String[] columnNames = {"Continente"};
    // Tipos das colunas.
    static protected Class[]  cTypes = {String.class};
    //Array com informações dos continentes.
    protected Continente[] o;
    
    public ContinenteTableModel()
    {
        o = new Continente[0];
    }
    
    public ContinenteTableModel(Conexao con)
    {
        Continente c = new Continente();
        Vector v = new Vector();
        v = c.loadTableModel(con); //Consulta no BD.
        o = new Continente[v.size()];
        v.copyInto(o);
    }

    public void addValue(Continente pJ)
    {
        int q = o.length;
        Continente[] u = new Continente[q + 1];

        for(int r = 0; r < q; r++)
        {
            u[r] = o[r];
        }

        u[u.length - 1] = pJ;
        o = new Continente[u.length];
        o = u;
    }

    public void deleteValue(Continente pJ)
    {
        int q = o.length;
        Continente[] u = new Continente[q - 1];

        boolean s = false;
        for(int r = 0; r < q; r++)
        {
            if(o[r].getCodContinente() == pJ.getCodContinente())
            {
                if(r < u.length)
                    u[r] = o[r + 1];
                s = true;
            }
            else
            {
                if(r < u.length)
                {
                    if(!s)
                    {
                        u[r] = o[r];
                    }
                    else
                    {
                        u[r] = o[r + 1];
                    }
                }
            }
        }

        o = new Continente[q - 1];
        o = u;
    }

    /** Returns the number of columns in the model. A
     * <code>JTable</code> uses this method to determine how many columns it
     * should create and display by default.
     *
     * @return the number of columns in the model
     * @see #getRowCount
     *
     */
    public int getColumnCount()
    {
        return columnNames.length;
    }

    public String getColumnName(int column) 
    {
        return columnNames[column];
    }

    /** Returns the number of rows in the model. A
     * <code>JTable</code> uses this method to determine how many rows it
     * should display.  This method should be quick, as it
     * is called frequently during rendering.
     *
     * @return the number of rows in the model
     * @see #getColumnCount
     *
     */
    public int getRowCount()
    {
        return o.length;
    }
    
    /** Returns the value for the cell at <code>columnIndex</code> and
     * <code>rowIndex</code>.
     *
     * @param	rowIndex	the row whose value is to be queried
     * @param	columnIndex 	the column whose value is to be queried
     * @return	the value Object at the specified cell
     *
     */
    public Object getValueAt(int rowIndex, int columnIndex)
    {
        if(rowIndex < o.length)
        {
            switch (columnIndex)
            {
		//-1 - para quando eu quiser buscar o Registro inteiro.
                case -1:
                    return o[rowIndex];
                case 0:
                    return new String(o[rowIndex].getContinente());
                default:
                    return null;
            }
        }
        else
            return null;
    }

    public Class getColumnClass(int c)
    {
        return cTypes[c];
    }

    /*
     * Don't need to implement this method unless your table's
     * data can change.
     */
    public void setValueAt(Object value, int row, int col)
    {
        if(row < o.length)
        {
            switch (col)
            {
                case 0:
                    o[row].setContinente(value.toString());
                    break;
            }
        }
        fireTableCellUpdated(row, col);
    }
}

package objetos;

import bancodados.Conexao;
import bancodados.BDContinente;
import java.util.*;

public class Continente
{
    private int codContinente;
    private String continente, erro;
    private boolean excessao;

    public Continente()
    {
        codContinente = 0;
        continente = "";
        erro = "";
        excessao = false;
    }

    public Continente(Continente c)
    {
        codContinente = c.getCodContinente();
        continente = c.getContinente();
        erro = c.getErro();
        excessao = c.getExcessao();
    }

    public void setCodContinente(int codigo)
    {
        try
        {
            codContinente = codigo;
        }
        catch(Exception e)
        {
            codContinente = 0;
        }
    }

    public void setContinente(String nome)
    {
        try
        {
            continente = nome;
        }
        catch(Exception e)
        {
            continente = "";
        }
    }

    public void setErro(String s)
    {
        try
        {
            erro += s.trim() + " ";
        }
        catch(Exception e)
        {
            erro = "";
        }
    }

    public void setExcessao(boolean b)
    {
        try
        {
            excessao = b;
        }
        catch(Exception e)
        {
            excessao = false;
        }
    }

    public void limpaErro()
    {
        try
        {
            erro = "";
        }
        catch(Exception e)
        {
            erro = "";
        }
    }

    public int getCodContinente()
    {
        try
        {
            return codContinente;
        }
        catch(Exception e)
        {
            return 0;
        }
    }

    public String getContinente()
    {
        try
        {
            return continente;
        }
        catch(Exception e)
        {
            return "";
        }
    }

    public String getErro()
    {
        try
        {
            return erro;
        }
        catch(Exception e)
        {
            return "";
        }
    }

    public boolean getExcessao()
    {
        try
        {
            return excessao;
        }
        catch(Exception e)
        {
            return false;
        }
    }

    public Vector loadTableModel(Conexao con)
    {
        Vector retorno = new Vector();

        try
        {
            BDContinente bdC = new BDContinente();

            retorno = bdC.loadTableModel(con);
        }
        catch (Exception e)
        {
        }
        return retorno;        
    }
}

package bancodados;


import objetos.Continente;
import objetos.ValidaData;
import java.sql.*;
import java.util.*;

public class BDContinente
{
    public Vector loadTableModel(Conexao con)
    {
        Continente c;
        Vector tabela = new Vector(1, 10);

        try
        {
            Statement statement = con.connect.createStatement();

            String query = "SELECT * FROM Continente ORDER BY Continente ASC";

            ResultSet rs = statement.executeQuery(query);

            try
            {
                while (rs.next())
                {
                    c = new Continente();
                    c.setCodContinente(rs.getInt("CodContinente"));
                    c.setContinente(rs.getString("Continente"));

                    tabela.addElement(c);
                }
            }
            catch(SQLException sqlex)
            {
                sqlex.printStackTrace();
            }

            statement.close();
        }
        catch(SQLException sqlex)
        {
            sqlex.printStackTrace();
        }
        tabela.trimToSize();

        return tabela;
    }
}

package bancodados;

import java.util.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.sql.*;

public class Conexao
{
   public Conexao()
   {
      try
      {
	 url = "jdbc:mysql://localhost/jusms";
         Class.forName("com.mysql.jdbc.Driver").newInstance();
	 connect = DriverManager.getConnection(dbURL, "", "");
	 conexao = true;
	 status = "Conexão com banco de dados ativado.";

      }
      catch(ClassNotFoundException cnfex)
      {
         cnfex.printStackTrace();
         conexao = false;
         status = "Conexão com banco de dados desativado.";
      }
      catch(Exception ex)
      {
         ex.printStackTrace();
         status = "Conexão com banco de dados desativado.";
      }
   }

   public void disconnect()
   {
       try
       {
           connect.close();
       }
       catch(Exception e)
       {
       }
   }

   public Connection getConexao()
   {
       return connect;
   }

   public String getStatus()
   {
      return status;
   }

   protected String url;
   protected String status;
   protected boolean conexao;
   protected Connection connect;
}

//variáveis necessárias na classe GUI (Interface gráfica)
//Cria conexao com o BD;
private Conexao conexao = new Conexao();
private ContinenteTableModel cTM;

//conexao - instância da classe Conexao.
               cTM = new ContinenteTableModel(conexao);
                tabPrincipal.setModel(sorter);