title: How to update jtable model correctly?
body: <p>I have been thinking a lot to solve this mistake. But unfortunately I came to final cnclusion that I need help of professionals.</p>
  
  <p>Please, copy,paste this code to see issue:</p>
  
  <pre><code>public class DateFormatDemo extends JFrame
  {
      private JTable dataSearchResultTable;
  
      public DateFormatDemo()
      {
          JButton updateTable = new JButton("Update table");
          updateTable.setMaximumSize(updateTable.getPreferredSize());
          updateTable.addActionListener(new ActionListener()
          {
              @Override
              public void actionPerformed(ActionEvent e)
              {
                  updateMyTableModel();
              }
          });
          JPanel panel = new JPanel(new GridLayout(2, 1, 5, 10));
          panel.setPreferredSize(new Dimension(500, 300));
          panel.add(new JScrollPane(initDataSearchResultTable()));
          panel.add(updateTable);
          super.getContentPane().add(panel);
          super.pack();
          super.setDefaultCloseOperation(EXIT_ON_CLOSE);
          super.setVisible(true);
      }
  
      private JTable initDataSearchResultTable()
      {
          dataSearchResultTable = new JTable();
          // dataSearchResultTable.setAutoCreateColumnsFromModel(false);
          dataSearchResultTable.setSelectionBackground(new Color(0xaaaaff));
          dataSearchResultTable.setFillsViewportHeight(true);
          dataSearchResultTable.setRowSelectionAllowed(true);
          dataSearchResultTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
          dataSearchResultTable.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
  
          return dataSearchResultTable;
      }
  
      void updateMyTableModel()
      {
          TableModel tableModel = dataSearchResultTable.getModel();
          TableColumnModel columnModel = dataSearchResultTable.getColumnModel();
          if (tableModel instanceof MyTableModel) {
              ((MyTableModel) tableModel).updateModel();
              this.initColumnWidths(tableModel, columnModel);
          } else {
              tableModel = new MyTableModel();
              dataSearchResultTable.setModel(tableModel);
              this.makeColumnsNotResizable(columnModel);
              this.initColumnWidths(tableModel, columnModel);
          }
      }
  
      private void makeColumnsNotResizable(TableColumnModel columnModel)
      {
          for (int i = 0; i &lt; columnModel.getColumnCount(); i++) {
              if (i == 0 || i == 1) {
                  columnModel.getColumn(i).setResizable(false);
              }
          }
      }
  
      private void initColumnWidths(TableModel tableModel, TableColumnModel columnModel)
      {
          TableColumn column = null;
          Component comp = null;
          int cellWidth = 0;
          int headerWidth = 0;
          TableCellRenderer headerRenderer = dataSearchResultTable.getTableHeader().getDefaultRenderer();
  
          for (int i = 0; i &lt; columnModel.getColumnCount(); i++) {
              column = columnModel.getColumn(i);
              comp = headerRenderer.getTableCellRendererComponent(null, column.getHeaderValue(), false, false, -1, 0);
              headerWidth = comp.getPreferredSize().width;
              Class&lt;?&gt; columnClass = tableModel.getColumnClass(i);
              for (int j = 0; j &lt; tableModel.getRowCount(); j++) {
                  comp = dataSearchResultTable.getDefaultRenderer(columnClass).getTableCellRendererComponent(
                          dataSearchResultTable, tableModel.getValueAt(j, i), false, false, j, i);
                  int width = comp.getPreferredSize().width;
                  // we cache width of first row. And compare widths of next
                  // rows with width of first.
                  // If some row has greater width it becomes width of whole
                  // row(unless header has greater width)
                  if (cellWidth &lt; width || j == 0) {
                      cellWidth = width;
                  }
              }
              System.out
                      .println("columnClass=" + columnClass + ",headerWidth=" + headerWidth + ",cellWidth=" + cellWidth);
  
              if (headerWidth &gt; cellWidth) {
                  TableCellRenderer centeredRenderer = dataSearchResultTable.getDefaultRenderer(columnClass);
                  if (centeredRenderer instanceof DefaultTableCellRenderer) {
                      ((DefaultTableCellRenderer) centeredRenderer).setHorizontalAlignment(SwingConstants.CENTER);
                      column.setCellRenderer(centeredRenderer);
                      column.setPreferredWidth(headerWidth);
                  }
              } else {
                  column.setPreferredWidth(cellWidth + 5);
              }
          }
      }
  
      class MyTableModel extends AbstractTableModel
      {
          private String[] columnNames = { "First Name", "Last Name", "Timestamp", "Number", "Vegetarian" };
          private Object[][] data = new Object[5][];
  
          void updateModel()
          {
              data = new Object[][] {
                      { "Vova", "KipokKipokKipokKipok", "2013-04-12 11:20:41", new Integer(5), new Boolean(true) },
                      { "Olia", "Duo", "2010-01-11 11:11:41", new Integer(3), new Boolean(false) },
                      { "Oksana", "Stack", "2012-04-12 11:20:41", new Integer(2), new Boolean(false) },
                      { "Petro", "White", "2010-04-12 11:20:21", new Integer(20), new Boolean(true) },
                      { "Ivan", "Brown", "2011-04-11 11:20:41", new Integer(10), new Boolean(true) } };
              fireTableDataChanged();
          }
  
          public int getColumnCount()
          {
              return columnNames.length;
          }
  
          public int getRowCount()
          {
              return data.length;
          }
  
          public String getColumnName(int col)
          {
              return columnNames[col];
          }
  
          public Object getValueAt(int row, int col)
          {
              if (data.length &gt; 0 &amp;&amp; data[0] != null) {
                  return data[row][col];
              }
              return null;
          }
  
          /*
           * JTable uses this method to determine the default renderer/ editor for
           * each cell. If we didn't implement this method, then the last column
           * would contain text ("true"/"false"), rather than a check box.
           */
          public Class getColumnClass(int c)
          {
              Object valueAt = getValueAt(0, c);
              return valueAt == null ? Object.class : valueAt.getClass();
          }
  
          /*
           * Don't need to implement this method unless your table's editable.
           */
          public boolean isCellEditable(int row, int col)
          {
              // Note that the data/cell address is constant,
              // no matter where the cell appears onscreen.
              if (col &lt; 2) {
                  return false;
              } else {
                  return true;
              }
          }
  
          /*
           * Don't need to implement this method unless your table's data can
           * change.
           */
          public void setValueAt(Object value, int row, int col)
          {
              if (data.length &gt; 0 &amp;&amp; data[0] != null) {
                  data[row][col] = value;
                  fireTableCellUpdated(row, col);
              }
          }
  
      }
  
      public static void main(String[] args) throws ParseException
      {
          new DateFormatDemo();
      }
  }
  </code></pre>
  
  <p>Now please click twice on that big button called 'Update Table'. As you see column that should display checkbox as it holds boolean values do not do that but instead displays String true or false.</p>
  
  <p>This code emulates my real workflow.
  So, how to update tablemodel to have boolean columns with checkbozes.</p>
  
  <p>Thanks!</p>