JTable不會更新fireXXXXX（）事件

在我的項目中發生了一些錯誤事件。對不起，但在這裏談到的代碼很大一部分：JTable不會更新fireXXXXX（）事件

public abstract class RowTableModel<T> extends AbstractTableModel { 
protected List<T> modelData; 
protected List<String> columnNames; 
@SuppressWarnings("rawtypes") 
protected Class[] columnClasses; 
protected Boolean[] isColumnEditable; 
@SuppressWarnings("rawtypes") 
private Class rowClass = Object.class; 
private boolean isModelEditable = true; 

@SuppressWarnings("rawtypes") 
protected RowTableModel(Class rowClass) { 
    setRowClass(rowClass); 
} 

protected RowTableModel(List<String> columnNames) { 
    this(new ArrayList<T>(), columnNames); 
} 

protected RowTableModel(List<T> modelData, List<String> columnNames) { 
    setDataAndColumnNames(modelData, columnNames); 
} 

@SuppressWarnings("rawtypes") 
protected RowTableModel(List<T> modelData, List<String> columnNames, Class rowClass) { 
    setDataAndColumnNames(modelData, columnNames); 
    setRowClass(rowClass); 
} 

protected void setDataAndColumnNames(List<T> modelData, List<String> columnNames) { 
    this.modelData = modelData; 
    this.columnNames = columnNames; 
    columnClasses = new Class[getColumnCount()]; 
    isColumnEditable = new Boolean[getColumnCount()]; 
    fireTableStructureChanged(); 
} 

@SuppressWarnings("rawtypes") 
protected void setRowClass(Class rowClass) { 
    this.rowClass = rowClass; 
} 

@SuppressWarnings({"rawtypes", "unchecked"}) 
public Class getColumnClass(int column) { 
    // Class columnClass = null; 
    // 
    // if (column < columnClasses.length) 
    // columnClass = columnClasses[column]; 
    // 
    // // Get the default class 
    // 
    // if (columnClass == null) 
    // columnClass = super.getColumnClass(column); 
    // 
    // return columnClass; 
    Class columnClass = getValueAt(0, column).getClass(); 
    if (columnClass != null) { 
     return columnClass; 
    } else { 
     return String.class; 
    } 

} 
public int getColumnCount() { 
    return columnNames.size(); 
} 

public String getColumnName(int column) { 
    Object columnName = null; 

    if (column < columnNames.size()) { 
     columnName = columnNames.get(column); 
    } 

    return (columnName == null) ? super.getColumnName(column) : columnName.toString(); 
} 

public int getRowCount() { 
    return modelData.size(); 
} 

public boolean isCellEditable(int row, int column) { 
    Boolean isEditable = null; 

    // Check is column editability has been set 

    if (column < isColumnEditable.length) 
     isEditable = isColumnEditable[column]; 

    return (isEditable == null) ? isModelEditable : isEditable.booleanValue(); 
} 

public void addRow(T rowData) { 
    insertRow(getRowCount(), rowData); 
} 

public T getRow(int row) { 
    return modelData.get(row); 
} 

@SuppressWarnings("unchecked") 
public T[] getRowsAsArray(int... rows) { 
    List<T> rowData = getRowsAsList(rows); 
    T[] array = (T[]) Array.newInstance(rowClass, rowData.size()); 
    return (T[]) rowData.toArray(array); 
} 

public List<T> getRowsAsList(int... rows) { 
    ArrayList<T> rowData = new ArrayList<T>(rows.length); 

    for (int i = 0; i < rows.length; i++) { 
     rowData.add(getRow(rows[i])); 
    } 

    return rowData; 
} 

public void insertRow(int row, T rowData) { 
    modelData.add(row, rowData); 
    fireTableRowsInserted(row, row); 
} 

public void insertRows(int row, List<T> rowList) { 
    modelData.addAll(row, rowList); 
    fireTableRowsInserted(row, row + rowList.size() - 1); 
} 

public void insertRows(int row, T[] rowArray) { 
    List<T> rowList = new ArrayList<T>(rowArray.length); 

    for (int i = 0; i < rowArray.length; i++) { 
     rowList.add(rowArray[i]); 
    } 

    insertRows(row, rowList); 
} 

public void moveRow(int start, int end, int to) { 
    if (start < 0) { 
     String message = "Start index must be positive: " + start; 
     throw new IllegalArgumentException(message); 
    } 

    if (end > getRowCount() - 1) { 
     String message = "End index must be less than total rows: " + end; 
     throw new IllegalArgumentException(message); 
    } 

    if (start > end) { 
     String message = "Start index cannot be greater than end index"; 
     throw new IllegalArgumentException(message); 
    } 

    int rowsMoved = end - start + 1; 

    if (to < 0 || to > getRowCount() - rowsMoved) { 
     String message = "New destination row (" + to + ") is invalid"; 
     throw new IllegalArgumentException(message); 
    } 

    // Save references to the rows that are about to be moved 

    ArrayList<T> temp = new ArrayList<T>(rowsMoved); 

    for (int i = start; i < end + 1; i++) { 
     temp.add(modelData.get(i)); 
    } 

    // Remove the rows from the current location and add them back 
    // at the specified new location 

    modelData.subList(start, end + 1).clear(); 
    modelData.addAll(to, temp); 

    // Determine the rows that need to be repainted to reflect the move 

    int first; 
    int last; 

    if (to < start) { 
     first = to; 
     last = end; 
    } else { 
     first = start; 
     last = to + end - start; 
    } 

    fireTableRowsUpdated(first, last); 
} 

public void removeRowRange(int start, int end) { 
    modelData.subList(start, end + 1).clear(); 
    fireTableRowsDeleted(start, end); 
} 

public void removeRows(int... rows) { 
    for (int i = rows.length - 1; i >= 0; i--) { 
     int row = rows[i]; 
     modelData.remove(row); 
     fireTableRowsDeleted(row, row); 
    } 
} 

public void replaceRow(int row, T rowData) { 
    modelData.set(row, rowData); 
    fireTableRowsUpdated(row, row); 
} 

@SuppressWarnings("rawtypes") 
public void setColumnClass(int column, Class columnClass) { 
    columnClasses[column] = columnClass; 
    fireTableRowsUpdated(0, getColumnCount() - 1); 
} 

public void setColumnEditable(int column, boolean isEditable) { 
    isColumnEditable[column] = isEditable ? Boolean.TRUE : Boolean.FALSE; 
} 

public void setModelEditable(boolean isModelEditable) { 
    this.isModelEditable = isModelEditable; 
} 

public static String formatColumnName(String columnName) { 
    if (columnName.length() < 3) 
     return columnName; 

    StringBuffer buffer = new StringBuffer(columnName); 
    boolean isPreviousLowerCase = false; 

    for (int i = 1; i < buffer.length(); i++) { 
     boolean isCurrentUpperCase = Character.isUpperCase(buffer.charAt(i)); 

     if (isCurrentUpperCase && isPreviousLowerCase) { 
      buffer.insert(i, " "); 
      i++; 
     } 

     isPreviousLowerCase = !isCurrentUpperCase; 
    } 

    return buffer.toString().replaceAll("_", " "); 
}

}

這是抽象的表模型，我伸出像這樣：

public class ProfessorTableModel extends RowTableModel<Professor> { 

public ProfessorTableModel(List<Professor> modelData, 
     List<String> columnNames) { 
    super(modelData, columnNames); 
} 

@Override 
public Object getValueAt(int rowIndex, int columnIndex) { 
    Professor professor = super.getRow(rowIndex); 
    switch (columnIndex) { 
    case 0: { 
     return professor.getId(); 
    } 
    case 1: { 
     return professor.getSurname(); 
    } 
    case 2:{ 
     return professor.getName(); 
    } 
    case 3:{ 
     return professor.getPatronymic(); 
    } 
    case 4:{ 
     return professor.getMail(); 
    } 
    case 5:{ 
     return professor.getPhone(); 
    } 
    case 6:{ 
     return professor.getDays(); 
    } 
    default: 
     return null; 
    } 
} 

@Override 
public boolean isCellEditable(int row, int column) { 
    return false; 
}

像這樣：

public class LessonTableModel extends RowTableModel<Lesson>{ 
    public LessonTableModel(List<Lesson> modelData, 
      List<String> columnNames) { 
     super(modelData, columnNames); 
    } 

    @Override 
    public Object getValueAt(int rowIndex, int columnIndex) { 
     Lesson lesson = super.getRow(rowIndex); 
     switch (columnIndex) { 
     case 0: { 
      return lesson.getId(); 
     } 
     case 1: { 
      return lesson.getProfessor(); 
     } 
     case 2:{ 
      return lesson.getCourse(); 
     } 
     case 3:{ 
      return lesson.getGroup(); 
     } 
     case 4:{ 
      return lesson.isLab(); 
     } 
     default: 
      return null; 
     } 
    } 

    @Override 
    public boolean isCellEditable(int row, int column) { 
     return false; 
    } 
}

所以在模型的第一種情況下，我做了以下編輯：

int[] selectedIndexes = professorTable.getSelectedRows(); 
      if (selectedIndexes.length == 1) { 
       int selectedIndex = professorTable.convertRowIndexToModel(professorTable.getSelectedRow()); 
       Professor professor = professorTableModel.getRow(selectedIndex); 
       ProfessorFrame professorFrame = ProfessorFrame.show(professor); 
       if (professorFrame.getDialogResult() == DialogResult.OK) { 
        professorTableModel.replaceRow(selectedIndex, professorFrame.getProfessor()); 
       } 
      }

在第二種情況下我做幾乎一樣：

int[] selectedIndexes = lessonTable.getSelectedRows(); 
        if (selectedIndexes.length == 1) { 
         int selectedIndex = lessonTable.convertRowIndexToModel(lessonTable.getSelectedRow()); 
         Lesson lesson = lessonTableModel.getRow(selectedIndex); 
         LessonFrame lessonFrame = LessonFrame.show(lesson); 
         if (lessonFrame.getDialogResult() == DialogResult.OK) { 
          lessonTableModel.replaceRow(selectedIndex, lessonFrame.getLesson()); 
         } 
        }

但在第一種情況下的表中獲取正確地更新，而在第二種情況下我單擊表格後應用了更新。我知道有大量的代碼字符串，但我真的希望有人能夠提供幫助。（嘗試更換fireTableRow插入fireTableDataChanged，但沒有任何更改）

謝謝大家提前，我非常感謝您的幫助！

來源

2012-05-13 mr.nothing

如果您很快就沒有得到體面的解決方案，請考慮通過不斷削減代碼來調試，從程序中逐步消除代碼，直到您將問題隔離或消失爲止。如果它消失了，可能剛剛刪除的代碼被涉及。如果是孤立的，那麼您可以重新發佈一個我們可以運行的簡單易懂的程序，重現您的問題，測試代碼，修改代碼並幫助您解決問題。 –

我不得不想知道你的'lessonFrame.getDialogResult（）'方法在做什麼。這就是你發佈的最後兩段代碼之間最大的區別。 –

lessonFrame.getDialogResult（）返回對話框的結果。換句話說，它說如果用戶點擊確定或取消。我會盡量削減這些代碼，使其更加清潔。 –

問題在於幀的形式。 ProfessorFrame是模態的而LessonFrame不是。這就是爲什麼第一種情況下的修改正確的導致編輯後的值被鉤住，第二種情況下代碼沒有暫停（模態暫停）而被執行，並且沒有新的值被鉤住。感謝@HovercraftFullOfEels的幫助和建議。

來源

2012-05-14 06:32:47

JTable不會更新fireXXXXX（）事件

回答

相關問題