Android readObject exception, cannot cast String to ObjectStreamClass

Question

I am working on an android project that loads data remotely, saves it into an array (if the data is new), writes it to disk as a serializeable, then reads it from disk to load an ArrayList.

Sometimes the ArrayList populates with the data, sometimes it doesn't and the program crashes.

I receive a runtime exception stating: java.land.ClassCastException: java.lang.String cannot be cast to java.io.ObjectStreamClass.

Sometimes I also receive a java.io.StreamCorruptedException, and sometimes I receive and EOFException.

Going through the exception tree, it seems to be originating from this call:

personsArray = (ArrayList<Person>) in.readObject();

Now, sometimes the data loads fine without issues, most of the time the program crashes.

Here is the code that saves the data to disk:

public static boolean saveFromRemoteSource(Context c, ArrayList<?> source){
    //Save context
    context = c;

    //Save source to local file
    File file = context.getFileStreamPath(PERSONS_FILE);

    //Status if successful in saving
    boolean savedStatus = false;

    try {
        if(!file.exists()){
            file.createNewFile();
        }else{
            //file already exists so don't do anything
        }
        //now load the data into the file

        FileOutputStream fos = context.openFileOutput(PERSONS_FILE, Context.MODE_PRIVATE);
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(source);
        oos.close();
        savedStatus = true; 
    } catch(IOException e){
        e.printStackTrace();
        savedStatus = false; 
    }
    return savedStatus;
}

Here is the code that reads the data from disk:

    public static boolean loadPersonsArray(Context c){
    context = c;

    boolean loadStatus = false;

    File file = context.getFileStreamPath(PERSONS_FILE);

    try{
            if(!file.exists()){
                file.createNewFile();
            }else {
                //File is already created, do nothing
            }

            BufferedReader br = new BufferedReader(new FileReader(file));     
                if (br.readLine() != null) {
                    FileInputStream fis = context.openFileInput(PERSONS_FILE);
                    ObjectInputStream in = new ObjectInputStream(fis);  
                    personsArray = (ArrayList<Person>) in.readObject();
                    in.close();
                    fis.close();
                    loadStatus = true;
                }
            br.close();
        } catch(IOException e){
            e.printStackTrace();
            Log.d("TAG", "IOException PERSONS_FILE file: " + e);
            loadStatus = false;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            Log.d("TAG", "ClassNotFoundException PERSONS_FILE file classnotfound: " + e);
        }

return loadStatus;
}

This is the Person class:

    import java.io.Serializable;

     public class Person implements Serializable, Comparable<Person>{
 //Person class

private static final long serialVersionUID = 1L;

private String personID;
private String personName;
private boolean displayPerson;


//default constructor
public Person(){
    super();
}

public Person(String personID,
         String personName,
         boolean displayPerson){

    super();
    this.personID = personID;
    this.personName = personName;
    this.displayPerson = displayPerson; 
}

//Accessor Methods
public String getPersonID(){
    return personID;
}
public String getPersonName(){
    return personName;
}
public boolean getDisplayPerson(){
    return displayPerson;
}

//setter methods

public void setPersonID(String personID){
    this.personID = personID;
}
public void setPersonName(String personName){
    this.personName = personName;
}
public void setDisplayPerson(boolean displayPerson){
    this.displayPerson = displayPerson;
}

@Override
public String toString(){
    return this.getPersonName().replaceAll("[^A-Za-z0-9]", "") + this.getDisplayPerson();
}

public int compareTo(Person otherPerson) {

    if(!(otherPerson instanceof Person)){
        throw new ClassCastException("Not a valid Person object!");
    }

    Person tempPerson = (Person)otherPerson;

    if(this.getPersonName().compareToIgnoreCase(tempPerson.getPersonName()) > 0){
        return 1;
        }else if(this.getPersonName().compareToIgnoreCase(tempPerson.getPersonName()) < 0){
            return -1;
        }else{
            return 0;
        }
     }
}

Where the data comes from to be written to the file

    private void downloadPersons(){     
    HashMap<String, String> params = new HashMap<String, String>();

    Kumulos.call("selectAllPersons", params, new ResponseHandler() {

    @Override
    public void didCompleteWithResult(Object result) {
        ArrayList<Object> personsList = new ArrayList<Object>();

        for(Object o : (ArrayList<?>)result){
            Person person = new Person();                       
            person.setPersonID(replaceNandT((String) ((HashMap<?,?>) o).get("personID")));
            person.setLawName(replaceNandT((String) ((HashMap<?,?>) o).get("personName")));
            person.setDisplayLaw(stringToBool((String)((HashMap<?,?>) o).get("displayPerson")));

            if(person.getDisplayPerson()==true){
                personsList.add(person);
                }
            } 

            //Save personsList to a file
            if(PersonsLoader.saveFromRemoteSource(context, personsList)){
                updateVersionNumber();
                isFinished=true;
                Log.d("TAG", "PersonsLoader.saveFromRemoteSource(context, personsList) success");
                }
        }
    });
}

So what do you think is happening at this call?

Answer 1

Get rid of both the blocks that test File.exists(), and the File.createNewFile() calls.

• Opening the file for output will create it if necessary.
• When opening the file for reading, if the file doesn't exist a FileNotFoundException will be thrown. There's no point in creating an empty file to avert this: it just leads to other problems.

And get rid of the BufferedReader and readLine() calls too. They serve no useful purpose. There are no lines in an object output stream.