• If we a class has 20 fields like id,location,exits etc etc then instead of writing all fields to a file one by one better write the entire object to the file.
• For that first of all we have to make the class serialisable. i.e the class whos objects we are going to read and write.
• To write an object to a file we have to translate the object into a format that can be written to a file and can be constructed back to object later on
• The process to convert a data structures like objects into formats that can be written to a file is called Serialisation
• For that we have to implement an interface called Serializable
• This interface has no methods and it is just to tell JVM that class objects can beserialised.
• We have to also set the serial Version UID field. this is like a version number for the class and it has to be private so that no other class can use it.
• If we don't set this value the compiler will throw a warning and create it based on class details such as no of fields ,methods etc. If we change a class like change no of fields etc we have to change the serial version UID field as well.
• When we read an object from a Stream the run time checks the serial version UID with the one contained in the compiled class file and if they don't match runtime will throw invalid class exception
• we don't have to worry about declaring the serial version UID unless we are using serialisation

 import java.io.Serializable;
 import java.util.LinkedHashMap;
 import java.util.Map;

  /* In this example our class location4 has 3 fields int,string and Map
   where int and String are primitive types but Map is an object
   And the map we are using is Hashmap which implements Serializable interface so map  will also we serialised .
   If there is a field in classes that is not serializable its or responsibility to make it serialized as well*/
 
  public class location implements Serializable {
    private final int locationId;
    private final String description;
    private final Map<String,Integer> exits;
    private Long serialVersionUID = 1L;

Then we read and write from this class like below

• Please note that ObjectInputStream and ObjectOutputStream implement DataInputStream and DataOutputStream interfaces and these interfaces define all the methods like writeInt,readInt ,writeUtf and readUtf .So ObjectInputStream and ObjectOutputStream can read/write primitive types and Strings as well along with serializable objects
• Another thing to note is that if in location4 class we comment out this line of code

  //    private Long serialVersionUID = 1L;
  

Then an invalid class exception will be thrown in this block of code for our class

 catch (InvalidClassException e){
       System.out.println("InvalidClass exception "+e.getMessage());
     }

    public static void main(String[] args) throws IOException {
        try (ObjectOutputStream locfile = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("locations2.dat")));) {
            for (location location : locations.values()) {
                locfile.writeObject(location);
            }
        }

    }

Reading objects from a file in a static block

 static {
        try (ObjectInputStream locfile = new ObjectInputStream(new BufferedInputStream(new FileInputStream("locations1.dat")))) {
            boolean endOfFile = false;
            while(!endOfFile) {
                try {
                    //Please note that here are readingObject using reaObject and we have to cast it type Location
                    location location = (location) locfile.readObject();
                    //And once object is created we can access the methods of this class
                    System.out.println("Read location---> " + location.getLocationId() + " , " + location.getDescription());
                }

                catch (InvalidClassException e){
                    System.out.println("InvalidClass exception "+e.getMessage());
                }

                catch (EOFException e){
                    endOfFile = true;
                }
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
        catch (ClassNotFoundException e){
            //Please note we are throwing this exception because if we are reading an object from a location.dat file
            //but can't find corresponding class in class path
            //For example if another class tries to read location.dat file but if that class doesn't contain location class.
            System.out.println("ClassNotFoundException "+e.getMessage());
        }
    }