DefaultTableModel or extend AbstractTableModel

Question

I find the DefaultTableModel very easy to use with lots of functionality. As data is stored in a Vector of Vectors any data can be suppported. You don't have to worry about firing any events when cell data is changed, this is handled by the model. There is great support for dynamic tables through the addRow, addColumn methods. When processing needs to be done on a table as a result of a change in cell contents it is easy to use a TableModelListener.
In many question on this forum I find that people create there own table model by extending AbstractTableModel. Not only is this extra work, but you loose much of the functionality of the DefaultTableModel. One poster even said they believe that the DefaultTableModel should never be used in a production system suggesting that storing the data as a Vector of Vectors is inefficient and that too much casting is done when you need to do any processing.
Anyway, lets take a simple table with columns containing: quantity, price and cost. When the quantity or price is changed the cost should be calculated.
How would you implement this in production?
Is the DefaultTableModel sufficient for your needs or would you create your own TableModel.
Can you make a general statement about when you would use the DefaultTableModel vs. creating your own TableModel?
Following are two implementations of this table.
Any comments on either approach or suggestions on a third approach.
Using the DefaultTableModel:
import java.awt.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.table.*;
public class TableProcessing extends JFrame implements TableModelListener
    JTable table;
    public TableProcessing()
        String[] columnNames = {"Item", "Quantity", "Price", "Cost"};
        Object[][] data =
            {"Bread", new Integer(1), new Double(1.11), new Double(1.11)},
            {"Milk", new Integer(1), new Double(2.22), new Double(2.22)},
            {"Tea", new Integer(1), new Double(3.33), new Double(3.33)},
            {"Cofee", new Integer(1), new Double(4.44), new Double(4.44)}
        DefaultTableModel model = new DefaultTableModel(data, columnNames);
        model.addTableModelListener( this );
        table = new JTable( model )
            //  Returning the Class of each column will allow different
            //  renderers to be used based on Class
            public Class getColumnClass(int column)
                return getValueAt(0, column).getClass();
            //  The Cost is not editable
            public boolean isCellEditable(int row, int column)
                if (column == 3)
                    return false;
                else
                    return true;
        table.setPreferredScrollableViewportSize(table.getPreferredSize());
        JScrollPane scrollPane = new JScrollPane( table );
        getContentPane().add( scrollPane );
     *  The cost is recalculated whenever the quantity or price is changed
    public void tableChanged(TableModelEvent e)
        if (e.getType() == TableModelEvent.UPDATE)
            int row = e.getFirstRow();
            int column = e.getColumn();
            if (column == 1 || column == 2)
                int    quantity = ((Integer)table.getValueAt(row, 1)).intValue();
                double price = ((Double)table.getValueAt(row, 2)).doubleValue();
                Double value = new Double(quantity * price);
                table.setValueAt(value, row, 3);
    public static void main(String[] args)
        TableProcessing frame = new TableProcessing();
        frame.setDefaultCloseOperation( EXIT_ON_CLOSE );
        frame.pack();
        frame.setLocationRelativeTo( null );
        frame.setVisible(true);
}Extending AbstractTableModel:
import java.awt.*;
import java.util.ArrayList;
import java.util.List;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.table.*;
public class TableProcessing2 extends JFrame
    JTable table;
    public TableProcessing2()
        ArrayList columnNames = new ArrayList(4);
        columnNames.add("Item");
        columnNames.add("Quantity");
        columnNames.add("Price");
        columnNames.add("Cost");
        ArrayList data = new ArrayList();
        data.add( new Item("Bread", 1, 1.11) );
        data.add( new Item("Milk", 1, 2.22) );
        data.add( new Item("Tea", 1, 3.33) );
        data.add( new Item("Cofee", 1, 4.44) );
        TableModel model = new ItemTableModel(data, columnNames);
        table = new JTable( model );
        table.setPreferredScrollableViewportSize(table.getPreferredSize());
        JScrollPane scrollPane = new JScrollPane( table );
        getContentPane().add( scrollPane );
    class Item
        String name;
        int quantity;
        double price;
        double cost;
        public Item(String name, int quantity, double price)
            this.name = name;
            this.quantity = quantity;
            this.price = price;
            cost = quantity * price;
    class ItemTableModel extends AbstractTableModel
        List data;
        List columnNames;
        public ItemTableModel(List data, List columnNames)
            this.data = data;
            this.columnNames = columnNames;
        public String getColumnName(int col) { return columnNames.get(col).toString(); }
        public int getRowCount() { return data.size(); }
        public int getColumnCount() { return columnNames.size(); }
        public Class getColumnClass(int column) { return getValueAt(0, column).getClass(); }
        public boolean isCellEditable(int row, int column)
            if (column == 3)
                return false;
            else
                return true;
        public Object getValueAt(int row, int column)
            Item item = (Item)data.get( row );
            switch ( column )
                case 0: return item.name;
                case 1: return new Integer(item.quantity);
                case 2: return new Double(item.price);
                case 3: return new Double(item.cost);
            return null;
        public void setValueAt(Object value, int row, int column)
            Item item = (Item)data.get( row );
            switch ( column )
                case 0:
                    item.name = (String)value;
                    break;
                case 1:
                    item.quantity = ((Integer)value).intValue();
                    break;
                case 2:
                    item.price = ((Double)value).doubleValue();
                    break;
                case 3:
                    item.cost = ((Double)value).doubleValue();
                    break;
            fireTableCellUpdated(row, column);
            //  Update dependent cells
            if (column == 1 || column == 2)
                Double cost = new Double(item.quantity * item.price);
                table.setValueAt(cost, row, 3);
    public static void main(String[] args)
        TableProcessing2 frame = new TableProcessing2();
        frame.setDefaultCloseOperation( EXIT_ON_CLOSE );
        frame.pack();
        frame.setLocationRelativeTo( null );
        frame.setVisible(true);
}

Answer 1

mzarra, I think I have enough information to make an informed decision, thanks.
virivan,
I took a look at your link. Cool. It looks like you've played with tables more than me. Like mzarra said above, you are probably creating your TableModel in the event thread which doesn't give the GUI a chance to repaint itself. When the table was loading I clicked on a different window and when I clicked back on you application I got a 'black' rectangle on the screen.
Reply 3 of this thread shows a simple example of moving the logic from the event thread to a separate thread:
http://forum.java.sun.com/thread.jsp?forum=57&thread=435487
Also, for fun I created a simple TableModel to store sparse data. It loads instantly. Here's the code I used:
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import javax.swing.*;
import javax.swing.table.*;
public class TableSparse extends JFrame
    private final static String[] LETTERS =
        "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
        "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"
    public TableSparse(int row, int column)
        TableModel model = new LargeTableModel(row, column);
        JTable table = new JTable(model);
        table.setAutoResizeMode( JTable.AUTO_RESIZE_OFF );
        JScrollPane scrollPane = new JScrollPane( table );
        getContentPane().add( scrollPane );
//        JTable lineTable = new LineNumberTable( table );
//        scrollPane.setRowHeaderView( lineTable );
    class LargeTableModel extends AbstractTableModel
        HashMap data = new HashMap();
        int rows;
        int columns;
        public LargeTableModel(int rows, int columns)
            this.rows = rows;
            this.columns = columns;
        public String getColumnName(int column)
            if (column < 26)
                return LETTERS[column];
            int first = (column / 26) - 1;
            int second = (column % 26);
            return LETTERS[first] + LETTERS[second];
        public int getRowCount() { return rows; }
        public int getColumnCount() { return columns; }
        public boolean isCellEditable(int row, int column) { return true; }
        public Object getValueAt(int row, int column)
            //  Check for row
            Integer key = new Integer(row);
            Object o = data.get(key);
            if (o == null) return null;
            //  Now check for column
            HashMap rows = (HashMap)o;
            key = new Integer(column);
            return rows.get(key);
        public void setValueAt(Object value, int row, int column)
            //  Remove cell data
            if (value.toString().equals(""))
                removeCellData(row, column);
                return;
            //  Save cell data
            Integer key = new Integer(row);
            HashMap rows = (HashMap)data.get(key);
            if (rows == null)
                rows = new HashMap();
                data.put(key, rows);
            key = new Integer(column);
            rows.put(key, value);
        private void removeCellData(int row, int column)
            Integer rowKey = new Integer(row);
            HashMap rows = (HashMap)data.get(rowKey);
            Integer columnKey = new Integer(column);
            rows.remove(columnKey);
            if (rows.isEmpty())
                data.remove(rowKey);
    public static void main(String[] args)
        TableSparse frame = new TableSparse(64000, 256);
        frame.setDefaultCloseOperation( EXIT_ON_CLOSE );
        frame.pack();
        frame.setVisible(true);
}