Need help serializing an AbstractTableModel for a JTable with cell editing.

Question

Fun times are ahead. Here we go!
I have a JTable that contains data I'd like to serialize out to a file to be restored and viewed later.
So I tried saving the AbstractTableModel subclass out to a file. Whenever I do this, I get the following error message:
java.io.NotSerializableException: javax.swing.JTable$CellEditorRemover
Now I know for fact that serializing an AbstractTableModel that was installed in a JTable without cell editing works just fine (my old code did exactly that). As a result, I think that the code that handles events in the AbstractTableModel contains references back out to the JTable, which causes the JTable to be saved no matter what (even though I'm just interested in saving the TableModel only). It causes a bigger file than normal, but file size is not an issue. The only issue I have is that CellEditorRemover (an undocumented inner class of JTable), which is automatically installed for JTables with editable cells, is not serializable.
This leads to the following questions:
1. Is there a way to avoid serialization/deserialization of the CellEditorRemover inner class of JTable?
2. Is there a way to save an AbstractTableModel without saving all of the event listeners associated with it?
I think an answer to either of these questions would go a long way towards solving my problem. Otherwise, I'll resign myself to weeping silently in the corner of my office.
Thanks!

Answer 1

I would suggest that if you can you only save the
data... but i would do this by using the
externalizable interface.
What you will need to do is have the
writeExternal(ObjectOutputStream out) and
readExternal(ObjectOutputStream out) methods in your
class. These will be responsiable for saving the
data.
Here's an example of what you can do in these
methods... this is just a little tidbit from a program
i've written.public void writeExternal(ObjectOutput out) throws
IOException {
          out.writeInt(size);
          out.writeObject(drawName);
          out.writeInt(playersLength);
for(int i = 0; i < playersLength; i++)
) out.writeObject(players);
          out.writeInt(seedsLength);
for(int i = 0; i < seedsLength; i++)
) out.writeObject(seeds[i]);
          out.writeInt(drawLength);
for(int i = 0; i < drawLength; i++)
) out.writeObject(draw[i]);
public void readExternal(ObjectInput in) throws
IOException, ClassNotFoundException {
          size = in.readInt();
          drawName = (String)in.readObject();
          playersLength = in.readInt();
for(int i = 0; i < playersLength; i++) players[i] =
= (String)in.readObject();
          seedsLength = in.readInt();
for(int i = 0; i < seedsLength; i++) seeds[i] =
= (String)in.readObject();
          drawLength = in.readInt();
for(int i = 0; i < drawLength; i++) draw[i] =
= (String)in.readObject();
You can now use your class as you would a Serializable
class, but it will only save the data
Hope this helped
webaf409java
I forgot to add some critical information in my original post. My apologies. :(
I've thought about using Externalizable, but am hesitant to use it because the application would no longer be able to read in files using the old save format (ie, AbstractTableModels for JTables without CellEditorRemovers ).  I want to preserve the ability to read the old saved AbstractTableModel formats if possible. 
Do you know of a way to revert to the default deserialization mechanism from readExternal?  This way, during deserialization, I could do a quick test on the object being read and have the ability to default to the regular deserialization mechanism if the object is of the old type or continue with the new Externalizable stuff if the object is one of the new type.  Maintaining file compatibility is key.