Logical problems causing multiple instances of a note to be created

Question

Here is the (without most of the functions) definition of a class called note.

   public class Note
    {
        private String text;
        String fileName = "";
        NoteManager noteManager = null;
        List<String> hyperlinks = new ArrayList<String>();

        public static final int BUFFER_SIZE = 512;

        public Note(NoteManager noteManager) {
            this.noteManager = noteManager;
            this.text = "";
        }

        public Note(NoteManager noteManager, String content) {
            this(noteManager);
            if (content == null)
                setText("");
            else
                setText(content);
        }

        public Note(NoteManager noteManager, CharSequence content) {
            this(noteManager, content.toString());
        }

        ....some functions....

        public static Note newFromFile(NoteManager noteManager, Context context,
            String filename) throws IOException
        {

        FileInputStream inputFileStream = context.openFileInput(filename);
        StringBuilder stringBuilder = new StringBuilder();
        byte[] buffer = new byte[BUFFER_SIZE];
        int len;
        while ((len = inputFileStream.read(buffer)) > 0)

         {
            String line = new String(buffer, 0, len);
            stringBuilder.append(line);

            buffer = new byte[Note.BUFFER_SIZE];
        }

        Note n = new Note(noteManager, stringBuilder.toString().trim());
        n.fileName = filename;

        inputFileStream.close();

        return n;
    }

       .... some functions attributed to this class

}

These notes are managed by a class called NoteManager.java, which I have abbreviated below:

public class NoteManager
{
    Context context=null;
    ArrayList<Note> notes = new ArrayList<Note>();

    ..... some functions...

    public void addNote(Note note)
    {
        if (note == null || note.noteManager != this ||   notes.contains(note)) return;
        note.noteManager = this;
        notes.add(note);    
        try
        {
            note.saveToFile(context);
        } catch (IOException e)
        {
            e.printStackTrace();
        }
    }


    ....some functions....

    public void loadNotes()
    {
        String[] files = context.fileList();
        notes.clear();
        for (String fname:files)
        {
            try
            {
                notes.add(Note.newFromFile(this, context, fname));
            } catch (IOException e)
            {
                e.printStackTrace();
            }
        }

    }
}

public void addNote(Note note)
    {
        if (note == null || notes.contains(note)) return;
        note.noteManager = this;
        notes.add(note);    
        try
        {
            note.saveToFile(context);
        } catch (IOException e)
        {
            e.printStackTrace();
        }
    }

I am trying to work out why this notepad app creates random new notes when the app is fully shutdown and then reopened, however I just cannot see what the problem is. I have cut out all the functions which didnt seem to relate to the problem, so the logical error must be here somewhere.

How does one go about finding what I am guessing to be some kind of circular reference or lack of checks?

Answer 1

Android typically uses UTF-8, with multi-byte characters. Creating a new String on a arbitrary byte sub-array can have issues at begin and end, if you deviate from ASCII.

public static Note newFromFile(NoteManager noteManager, Context context,
        String filename) throws IOException
{
    Path path = Paths.get(filename);
    byte[] bytes = Files.readAllBytes(path);
    String content = new String(bytes,  "UTF-8");

    Note n = new Note(noteManager, content.trim());
    n.fileName = filename;
    noteManager.add(n); // One registration?
    return n;
}

The problem of having multiple instances of a node might need the addition within newFromFile or maybe an extra check:

public void addNote(Note note)
{
    if (note == null || note.noteManager != this || notes.contains(note)) {
        return;
    }
    note.noteManager = this;
    notes.add(note);    

And finally a Note must be well defined.

public class Note extends Comparable<Note> {

    private NoteManager noteManager:
    private final String content; // Immutable.

    public NoteManager(NoteManager noteManager, String content) {
        this.noteManager = noteManager;
        this.content = content;
    }
    ... compare on the immutable content
    ... hashCode on content

Not being to be able to change the content, and comparing on the string content, means notes cannot be doubled, change in the set, mixing up the set ordering.