Duvida com arquivo

public class Processo<P> implements Serializable{
    private P  dataAbertura, titulo, assunto;
    private  P identificador;
    public Processo next;
    
    /*
     * Contrutor sem parâmetros - todos os atributos são vazios
     */
    public Processo(){
        setIdentificador((P) new Integer(10000));
        setDataAbertura(null);
        setTitulo(null);
        setAssunto(null); 
    }

    /*
     * Contrutor com parâmetros - atribuindo novos valores a todos os tributos
     */
    public Processo(P identificador, P dataAbertura, P titulo, P assunto){
        setIdentificador(identificador);
        setDataAbertura(dataAbertura);
        setTitulo(titulo);
        setAssunto(assunto);
    }

    /*
     * Atualiza o identificador do processo
     * @param id novo valor do atributo identificador
     */
    public void setIdentificador(P identificador) { 
        if (identificador == null) identificador = (P) new Integer(0);
        this.identificador = identificador;
    }
    /*
     * Recupera o identificador do processo
     * @return valor do atributo identificador
     */
    public P getIdentificador() { 
        return this.identificador;
    }

    /*
     * Atualiza a data de abertura do processo
     * @param data novo valor do atributo dataAbertura
     */
    public void setDataAbertura(P dataAbertura) { 
        this.dataAbertura = dataAbertura;
    }
    /*
     * Recupera o identificador do processo
     * @return valor do atributo identificador
     */
    public P getDataAbertura() { 
        return this.dataAbertura;
    }

    /*
     * Atualiza o título do processo
     * @param title novo valor do atributo titulo
     */
    public void setTitulo(P titulo) { 
        this.titulo = titulo;
    }
    /*
     * Recupera o título do processo
     * @return valor do atributo titulo
     */
    public P getTitulo() { 
        return this.titulo;
    }

    /*
     * Atualiza o assunto envolvido no processo
     * @param ass novo valor do atributo assunto
     */
    public void setAssunto(P assunto) { 
        this.assunto = assunto; 
    }
    /*
     * Recupera o assunto envolvido no processo
     * @return valor do atributo assunto
     */
    public P getAssunto() { 
        return this.assunto; 
    }

    @Override
    /*
     * Recupera uma instância de String descrevendo o processo
     * O campo assunto só será descrito pelas subclasses
     * @return descrição do processo
     */
    public String toString() {
        String output;
        output = "Descrição do processo: \n Identificador: "+this.getIdentificador()+", Data de abertura: "+
                this.getDataAbertura()+" e Título: "+this.getTitulo()+".";
        return output;
    }
}

public class GravacaoDeObjetos {
    static List<Processo> process = new LinkedList<Processo>();
    public void gravaObj(Processo proce){
        try {
            FileOutputStream f = new FileOutputStream ("C:/Users/fujioka/Documents/NetBeansProjects/GujForunsTest/src/SolucoesETestes/arquivo.arq");
            ObjectOutputStream s = new ObjectOutputStream(f);

            process.add(proce);
            s.writeObject(GravacaoDeObjetos.process);
            s.flush();
            s.close();
            f.flush();
            f.close();
            System.out.println("Gravacao realizada com sucesso!");
        }catch (Exception e){
            System.out.println(e);
        }
    }
    public List<Processo> leObj(){
        List<Processo> lProcess = new LinkedList<Processo>();
        try {
            FileInputStream f = new FileInputStream("C:/Users/fujioka/Documents/NetBeansProjects/GujForunsTest/src/SolucoesETestes/arquivo.arq");
            ObjectInputStream s = new ObjectInputStream(f);
            lProcess = (List<Processo>) s.readObject();
            s.close();
            f.close();

        }catch (Exception e) {
            System.out.println(e);
        }
        return lProcess;
    }
}

// o segundo parâmetro indica o uso do append.
FileOutputStream f = new FileOutputStream ("computador.arq",true);

class FileObjectTools{
private static List<Processo> process = new LinkedList<Processo>();
private String arquivo;

    public FileObjectTools(String c){
        this.arquivo = c;
        for(int i = 0; i < leListObj().size(); i++){
            process.add(leListObj().get(i));
        }
    }

    public void gravaObj(Processo proce){
        try {
            FileOutputStream f = new FileOutputStream (arquivo);
            ObjectOutputStream s = new ObjectOutputStream(f);

            process.add(proce);
            s.writeObject(FileObjectTools.process);
            s.flush();
            s.close();
            f.flush();
            f.close();
            System.out.println("Gravacao realizada com sucesso!");
        }catch (Exception e){
            System.out.println(e);
        }
    }
    public List<Processo> leListObj(){
        List<Processo> lProcess = new LinkedList<Processo>();
        try {
            FileInputStream f = new FileInputStream(arquivo);
            ObjectInputStream s = new ObjectInputStream(f);
            lProcess = (List<Processo>) s.readObject();
            s.close();
            f.close();

        }catch (Exception e) {
            System.out.println(e);
        }
        return lProcess;
    }
    static private int cont;
    public Processo leObj(){
        return leListObj().get(cont++);
    }
    public void limpaArq(){
        try{
            FileOutputStream fo = new FileOutputStream(arquivo);
            ObjectOutputStream o = new ObjectOutputStream(fo);
            o.reset();
            process.clear();
        }catch(IOException e){
            System.err.println(e);
        }
    }

}

public static void main (String [] args){
        FileObjectTools f = new FileObjectTools("arquivo.arq");
        
        Processo p2 = new Processo();
        f.gravaObj(p2);

        System.out.printf("Tamanho da List: %02d", f.leObj().size());
        System.out.println( f.leObj.get(0).getIdentificador() );
        System.out.println(f.leObj().getIdentificador());
        System.out.println(f.leObj().getIdentificador());
        System.out.println(f.leObj().getIdentificador());

    }

O problema de usar texo é quando esse banco fabricado, for gravar objetos que foram modificados por várias classes e dependerem das referências.

 O banco que criei é para agir apenas dentro da aplicação, caso o caso fosse uma aplicação de grande porte, seria muito mais eficiênte utilizar de DB's prontos, que possuem lógica mais sofisticada e nesses casos muitas vezes trabalham em linguagem de baixo nível, para dar maior eficiência.

 Nas diversas aplicações comercializaveis de java os objetos são guardados em arquivos bin pois assim é de mais difícil a alteração das lógicas por externos, criandores de séries de bugs.