Modelo base para un JTable java swing

BaseTableModel.java

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.Vector;
import javax.swing.table.*;

public abstract class BaseTableModel<T> extends AbstractTableModel 
        implements Iterable<T> {

  private static final long serialVersionUID = -3559749545223591549L;

   /** Columnas del JTable. */
  private final Vector<String> columns;
  /** Filas o items del JTable. */
  private final Vector<T> items = new Vector<T>();

  /** Construye la clase con los nombres de las columnas de la tabla. */
  public BaseTableModel(String... columns) {
    this.columns = convertVector(columns);
  }
  
  /** Convierte un arreglo en un vector. */
  public static <V> Vector<V> convertVector(V... array) {
    if (array == null) return new Vector<V>();
    Vector<V> v = new Vector<V>(array.length);
    for (V o : array) v.addElement(o);
    return v;
  }
  
  /** Obtiene el numero de columnas que contiene la tabla. */
  @Override public int getColumnCount() {
    return columns.size();
  }
  /** Obtiene el nombre de la columna segun el indice. */
  @Override public String getColumnName(int columnIndex) {
    return columns.get(columnIndex);
  }
  /** Agrega un nuevo columna a la tabla. */
  public void addColumn(String columnName) {
    columns.addElement(columnName);
    fireTableStructureChanged();
  }
  /** Agrega un nuevo columna a la tabla. */
  public void clearColumns() {
    columns.clear();
  }
  /** Obtiene todas las columnas de la tabla. */
  public ArrayList<String> getColumns() {
    return new ArrayList<String>(columns);
  }
  
  /** Devuelve el número de filas de la tabla. */
  @Override public int getRowCount() {
    return items.size();
  }
  /** Obtiene una fila segun el indice. */
  public T getItem(int rowIndex) {
    return items.get(rowIndex);
  }
  /** Asigna un item a la fila, segun el indice. */
  public void setItem(int rowIndex, T item) {
    items.set(rowIndex, item);
    items.setSize(getRowCount());
    //items.add(item);
    // Notifica el cambio a la vista.
    fireTableRowsUpdated(rowIndex, rowIndex); 
  }
  /** Agrega un nuevo item a la fila. */
  public void addItem(T item) {
    addItem(getRowCount(), item);
  }
  /** Agrega un nuevo item a la fila. segun el indice. */
  public void addItem(int rowIndex, T item) {
    items.insertElementAt(item, rowIndex);
    items.setSize(getRowCount());
    //items.add(item);
    // Notifica el cambio a la vista.
    fireTableRowsInserted(rowIndex, rowIndex); 
  }
  /** Valida si existe un item en la tabla. */
  public boolean containsItem(T item) {
    return items.contains(item);
  }
  /** Elimina un item de la tabla segun el indice. */
  public T removeItem(int rowIndex) {
    try {
      return items.remove(rowIndex);
    } finally {
      // Notifica el cambio a la vista.
      fireTableRowsDeleted(rowIndex, rowIndex); 
    }
  }
  /** Elimina un item de la tabla. */
  public T removeItem(T item) {
    int index = items.indexOf(item);
    if (index != -1) return removeItem(index);
    return null;
  }
  /** Elimina una lista de items de la tabla. */
  public boolean removeAllItems(Collection<T> toRemove) {
    try {
      return items.removeAll(toRemove);
    } finally {
      // Notifica el cambio a la vista.
      fireTableDataChanged();
    }
  }
  /** Elimina todas las filas de la tabla. */
  public void clearItems() {
    items.clear();
    // Notifica el cambio a la vista.
    fireTableDataChanged(); 
  }
  /** Obtiene todos los items de la tabla. */
  public ArrayList<T> getItems() {
    return new ArrayList<T>(items);
  }
  /** Limpia y asigna una nueva colecion a la tabla. */
  public void setItems(Collection<T> vector) {
    items.clear();
    items.addAll(vector);
    // Notifica el cambio a la vista.
    this.fireTableDataChanged();
  }
  
  /** Devuelve la superclase más específica para todos los valores de celda en la columna. */
  @Override public Class<?> getColumnClass(int col) {
    if (getRowCount() > 0) {
      Object cell = getValueAt(0, col);
      if (cell != null) return cell.getClass();
    }
    return super.getColumnClass(col);
  }

  /** Convierte los items de la tabla en una arreglo. */
  public T[] toArray(Class<T> clazz) {
    T[] genericArray = (T[]) Array.newInstance(clazz, items.size());
    return items.toArray(genericArray);
  }

  @Override public Iterator<T> iterator() {
    return new ArrayList<T>(items).iterator();
  }
  
  public void notifyDataSetChanged() {
    if (getRowCount() > 0) {
      fireTableRowsUpdated(0, getRowCount()-1);
    }
  }
}