0

Let's say we want to store some lists inside another list. We process our list according to the users requirements. Some lists are sorted some are not. To sort a list we use sorting algorithms. Now when a user closes the program, the sorted work is lost. We want to save this work by serializing. Some objects are serializable some are not.

run:
Draft1 java.io.NotSerializableException: drafts.Drafts
..\executor-snippets\run.xml:53: Java returned: 1
BUILD FAILED (total time: 6 seconds)

run:
Draft02 java.io.WriteAbortedException: writing aborted; java.io.NotSerializableException: drafts.Fiction
Draft01 java.io.NotSerializableException: drafts.Fiction
..\executor-snippets\run.xml:53: Java returned: 1
BUILD FAILED (total time: 0 seconds)

run:
////////draft...
Original: drafts.Drafts@6d03e736
Original: 100
Original: 3
//////////draftD... 
Deserialize: drafts.Drafts@17a7cec2
Deserialize: 100
Deserialize: 0
3
Virtual space.
Functional programming
Object OP
/////////////List Des
S1: 4
S2a: [Virtual space.]
S2b: [1569099619496#1 Searching for an answer on the web is like searching a needle on a haystack. Probably there is an answer for everything. If there is non or we can't find one, then we can create one. The old saying was, if it is not broken don't fix it! The brand new one is, if it is not perfect keep on trying!]
//.....................................................................//
TS4a: 1569099166372#3 1234567890...
TS5: {0=[Virtual space.], 1=[1569099166091#1 Searching for an answer on the web is like searching a needle on a haystack. Probably there is an answer for everything. If there is non or we can't find one, then we can create one. The old saying was, if it is not broken don't fix it! The brand new one is, if it is not perfect keep on trying!], 2=[1569099166372#2 Some array types containing other array types might not deserialize correctly, as all elements of the child type will point to the same memory. This limitation may be addressed in the future.]}
TS6: [1569099166091#1 Searching for an answer on the web is like searching a needle on a haystack. Probably there is an answer for everything. If there is non or we can't find one, then we can create one. The old saying was, if it is not broken don't fix it! The brand new one is, if it is not perfect keep on trying!]
TS7: [Virtual space.]
TS8: Sat Sep 21 22:52:46 CAT 2019
BUILD SUCCESSFUL (total time: 1 second)

What's happening here?

  • We started with class Drafts.
  • We changed it to class Drafts implements Serializable.
  • We want to use an external class Fiction lastFiction.
  • We don't have any control over class Fiction, and we can't serialize it or it gives us errors when we try.
  • So we changed it to private transient Fiction lastFiction.

How can one tell if an object is serializable or not serializable? Without using destructive testing.

/*
 * Drafts.java
 */
package drafts;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 *
 * @Drafts
 */
public class Drafts implements Serializable{
    private int id;
    private String title;
    private boolean hardCopy;
    private String author; 
    private String discription; 
    private int year;
    private List<String> unsortedList;
    private List<String> sortedList;
    private List<List<String>> myList;
    private List<Drafts> draftList;
    private List<Object> objList;
    private List<Fiction> fictionList;
    private Map<Integer, List<String>> recentFiles;
    private transient int last;
    private Drafts lastDrafts;
    //private Fiction lastFiction;
    private transient Fiction lastFiction;
    private boolean lastb;
    private Date timeb;

    public Drafts(int i, String tl, boolean hc, String au, String dis, int yr) {
        id = i;
        title = tl;
        hardCopy = hc;
        author = au; 
        discription = dis; 
        year = yr;
        unsortedList = new ArrayList<>();
        sortedList = new ArrayList<>();
        myList = new ArrayList<>();
        draftList = new ArrayList<>();
        recentFiles = new HashMap<>();
        objList = new ArrayList<>();
        fictionList = new ArrayList<>();
        last = 0;
        lastb = true;
        timeb = new Date();
        objList.add(id);
        objList.add(timeb);
        objList.add(author);
        objList.add(title);
    }

    public Drafts(){
        lastDrafts = newDrafts();
        objList = new ArrayList<>();
        fictionList = new ArrayList<>();
    }

    private Drafts newDrafts(){
        // deserialize the Drafts
        Drafts lastBooks = null;
        lastb = true;
        try {
            FileInputStream fi = new FileInputStream("tmp");
            ObjectInputStream si = new ObjectInputStream(fi);
            lastBooks = (Drafts) si.readObject();
        }catch (Exception e) {
            System.out.println("Draft02 "+e);
            lastb = false;
            //System.exit(1);
        }

        return lastBooks;
    }

    private void saveDrafts(Drafts book){
        // serialize the Drafts
        try {
            FileOutputStream fo = new FileOutputStream("tmp");
            ObjectOutputStream so = new ObjectOutputStream(fo);
            so.writeObject(book);
            so.flush();
        } catch (Exception e) {
            System.out.println("Draft01 "+e);
            System.exit(1);
        }
    }

    public void update(String d) {
        unsortedList.add(d);
        objList.add(d);
        sortBlist(d);
        recentFiles.put(last, myList.get(myList.size() - 1));
        last++;
    }

    private void saveFiction(Fiction lastf){
        lastFiction = lastf;
        //objList.add(lastFiction);
        //fictionList.add(lastf);
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////
        //Draft02 java.io.WriteAbortedException: writing aborted; java.io.NotSerializableException: drafts.Fiction
        //Draft01 java.io.NotSerializableException: drafts.Fiction
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////
    }

    private void sortBlist(String d){
        //Sort and add to sorted.
        sortedList.add(d);
        myList.add(sortedList);
        objList.add(sortedList);
        sortedList = new ArrayList<>();
    }

    private int searchBlist(String xText, String yText, List<String> sList, int beg, int end){
        //Search x in sList and replace it with y.
        //boolean found = false;
        //int n = -1;
        return 0;
    }

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        long t0 = System.currentTimeMillis();
        // create a Drafts object
        Drafts Test = new Drafts();
        Drafts book = new Drafts(100, "Functional programming", true, "S.P", "Programming", 2016);
        Drafts book1 = new Drafts(200, "Object OP", true, "O.S", "Data Structures", 2017);
        Drafts book2 = new Drafts(300, "How to deserialize", true, "D.D", "Deserialization", 2018);
        Drafts bookD = null;
        //
        Fiction book3 = new Fiction(100, "Virtual space.", "R.P", 2000);
        book.saveFiction(book3);
        book.update(book.lastFiction.getTitle());
        //
        String bookN0 = t0+"#1 Searching for an answer on the web is like searching a "
                + "needle on a haystack. Probably there is an answer for "
                + "everything. If there is non or we can't find one, then "
                + "we can create one. The old saying was, if it is not broken "
                + "don't fix it! The brand new one is, if it is not perfect "
                + "keep on trying!";

        book.update(bookN0);
        book1.update(bookN0);
        book2.update(bookN0);
        t0 = System.currentTimeMillis();

        String bookN1 = t0+"#2 Some array types containing other array types might not "
                + "deserialize correctly, as all elements of the child type "
                + "will point to the same memory. This limitation may be "
                + "addressed in the future.";

        book.update(bookN1);
        book1.update(bookN1);
        t0 = System.currentTimeMillis();
        String bookN2 = t0+"#3 1234567890...";
        book2.update(bookN2);

        book.draftList.add(book);
        book.draftList.add(book1);
        book.draftList.add(book2);
        book.myList.add(book2.unsortedList);

        // serialize the Drafts
        book.saveDrafts(book);

        // deserialize the Drafts
        bookD = book.newDrafts();

        System.out.println();
        System.out.println("////////draft...");
        System.out.println("Original: "+book);
        System.out.println("Original: "+book.id);
        System.out.println("Original: "+book.last);
        System.out.println("//////////draftD... ");
        System.out.println("Deserialize: "+bookD);
        System.out.println("Deserialize: "+bookD.id);
        System.out.println("Deserialize: "+bookD.last);
        System.out.println(bookD.unsortedList.size());
        System.out.println(bookD.unsortedList.get(0));
        System.out.println(bookD.draftList.get(0).title);
        System.out.println(bookD.draftList.get(1).title);
        System.out.println("/////////////List Des");
        System.out.println("objList size: "+bookD.objList.size());
        System.out.println("objList: "+bookD.objList);
        System.out.println("S1: "+bookD.myList.size());
        System.out.println("S2a: "+bookD.myList.get(0));
        System.out.println("S2b: "+bookD.myList.get(1));
        System.out.println("S2c: "+bookD.myList.get(2));
        System.out.println("S2d: "+bookD.myList.get(3));
        System.out.println("S3: "+bookD.myList.get(0).get(0));
        System.out.println("S4: "+bookD.myList.get(1).get(0));
        System.out.println("S4a: "+bookD.myList.get(2).get(0));
        System.out.println("S4b: "+bookD.myList.get(3).get(0));
        System.out.println("S4c: "+bookD.myList.get(3).get(1));
        System.out.println("S4d: "+bookD.myList);
        System.out.println("S5: "+bookD.recentFiles.toString());
        System.out.println("S6: "+bookD.recentFiles.get(1));
        System.out.println("S7: "+bookD.recentFiles.get(0));
        System.out.println("S8: "+bookD.timeb);
        System.out.println("//////////TestD... ");
        if(Test.lastb){
            System.out.println("TS1: "+Test.lastDrafts.myList.size());
            System.out.println("TS2a: "+Test.lastDrafts.myList.get(0));
            System.out.println("TS2b: "+Test.lastDrafts.myList.get(1));
            System.out.println("TS2c: "+Test.lastDrafts.myList.get(2));
            System.out.println("TS3: "+Test.lastDrafts.myList.get(0).get(0));
            System.out.println("TS4: "+Test.lastDrafts.myList.get(1).get(0));
            System.out.println("TS4a: "+Test.lastDrafts.myList.get(3).get(1));
            System.out.println("TS5: "+Test.lastDrafts.recentFiles.toString());
            System.out.println("TS6: "+Test.lastDrafts.recentFiles.get(1));
            System.out.println("TS7: "+Test.lastDrafts.recentFiles.get(0));
            System.out.println("TS8: "+Test.lastDrafts.timeb);
        }
        else{
            System.out.println("//////////TestD... "+Test.lastb);
        }
        System.out.println();
    }   
}
BM3
  • 119
  • 5
  • 1
    See [this answer](https://stackoverflow.com/a/19223875/5699679) and [this answer](https://stackoverflow.com/a/3840409/5699679). – Avi Sep 23 '19 at 21:41
  • 1
    Possible duplicate of [When Java class is instance of Serializable](https://stackoverflow.com/questions/19223688/when-java-class-is-instance-of-serializable) – Avi Sep 23 '19 at 21:43
  • I don't recommend serializing via `Serializable` unless you *need* to store the object along with any meta-information about the class, as any changes to the class may cause deserialization to fail (see [this answer](https://stackoverflow.com/questions/39079928/what-is-the-penalty-for-unnecessarily-implementing-serializable/39088501#39088501)). Unless you want to dig into custom serialization, you should find a way to output only the data you want to store through some other form of data storage, such as simply storing the sorted values in a file to be read later. – Vince Sep 24 '19 at 01:19
  • Just use `if (myObject instanceof Serializable) ...` – Chloe Sep 24 '19 at 04:34
  • It's amazing. Each and every new version comes up with a new solution. Other things that were impossible ten years ago, are now possible. Some other things that are currently impossible or time consuming, will be trivial in a near future. – BM3 Sep 26 '19 at 09:15

1 Answers1

2

It's really hard to find nested classes and see if it is implementing serializable. A better way for this issue would be using ObjectMapper which would convert your bean class to json file and you can convert them back to java object.

private void saveDrafts(Drafts book){
    // serialize the Drafts
    try {
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.writeValue(new File("tmp/draft.json"), book);
    } catch (Exception e) {
        System.out.println("Draft01 "+e);
        System.exit(1);
    }
}

Convert json to object

private Drafts readDrafts(){
    // serialize the Drafts
    try {
        ObjectMapper objectMapper = new ObjectMapper();
        return objectMapper.readValue(new File("tmp/draft.json"), Drafts.class);
    } catch (Exception e) {
        System.out.println("Draft01 "+e);
        System.exit(1);
    }
}
Pasupathi Rajamanickam
  • 1,982
  • 1
  • 24
  • 48