performance issue with writing serializable objects to disk - performance

Question

I have an app that works with lists of data. The data is held in three classes as shown below. My problem is reading and writing the data to disk takes too long for the app to be useful past about 1,000 entries. An example would be 1,000 flashcards. File on disk is about 200K and takes about six seconds to load. An impressive 35k a second. I was hoping to be able to support ten's of thousands of entries but clearly users'attention span would time out with a minute long wait. A surprisingly long part of the time is spent after the data has been read and loaded into a linerlayout, which is in a scrollview, and the time the screen refreshes. This is about 3 of the six seconds. I've been looking at different alternatives such as parcelable (can't write to disk) Kyro and others but the benchmarks are not that impressive. If anyone can offer me advice or guidance I would really appreciate it. Code works great - just really slow. Here are the data structures of the classes and the code I use to write and read.
Thanks,
Chris
public class iList extends Activity implements Serializable {
String listName;
int lastPosition;
long dateSaved;
String listPath;
List<iSet> listLayout=new ArrayList<iSet>();
List<String> operationsHistory = new ArrayList<String>();
List<iSet>setList= new ArrayList<iSet>();
public class iSet extends Activity implements Serializable {
private static final long serialVersionUID = 2L;
String setName;
List<Objecti> setObjectis = new ArrayList<Objecti>();
List<iList> setLists = new ArrayList<iList>();
boolean hasList=false;
int listCount=0;
public class Objecti extends Activity implements Serializable {
private static final long serialVersionUID = 2L;
private String objectName;
private int objectType;
private String stringValue;
private Date dateValue;
private float floatValue;
private int integerValue;
private ImageView image;
public iList readList(String pathName) {
File f = new File(pathName);
iList list = new iList();
ObjectInputStream objectinputstream = null;
try {
FileInputStream fis = new FileInputStream(pathName);
if (fis.available() > 0) {
ObjectInputStream ois = new ObjectInputStream(fis);
list = (iList) ois.readObject();
ois.close();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (objectinputstream != null) {
}
}
return list;
}
public void save(String filePath){
try {
File f = new File(filePath);
FileOutputStream fout = new FileOutputStream(filePath);
ObjectOutputStream oos = new ObjectOutputStream(fout);
oos.writeObject(this);
oos.flush();
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}

Answer 1

Looking at the class structure. You may think of following
1. Reduce the no of data members being serialized. This you can do by providing a good design for this.
2. Below are the association relations I could infer
iSet = { *objectI, *iList}
iList= {*iSet }
I could not make out the context why would this type of association is required. This looks like a cycle which may result in duplicate data being serialzed. By providing a design you can serialize only minimum data required. Remaining you can re-compute after de-serialization is done. This will shorten each IO operation.

Answer 2

After much research the answer I've come up with is you can't make objectinput/output any faster without doing it yourself. Because of the structure of my data one iList will have many of one type of iSet which has multiple objects with the data residing in the object. So I write all of my objects to a .txt file and when I need to restore the object I read them from the .txt and put the list back together again. The results are extreme - ranging from 15 - 20 times faster which more than meets my requirements.