Ayuda con ObjectOutputStream!

public class MiObjectOutputStream extends ObjectOutputStream{ //clase q hereda de objectoutputstream para no sobreescribir la cabecera
public void writeStreamHeader() {
//nada
}
public MiObjectOutputStream() throws IOException {
super();
}
public MiObjectOutputStream (FileOutputStream fileOutputStream) throws IOException {
// TODO Auto-generated constructor stub
super(fileOutputStream);
}
}
//Los metodos guardar y recuperar estan en otra clase
public void guardar (Jugador j) throws IOException {
File f= new File("jugador.objeto");
if( f.exists()){
MiObjectOutputStream salida= new MiObjectOutputStream(new FileOutputStream(f));
salida.writeObject(j);
salida.close();
} else {
ObjectOutputStream salida= new ObjectOutputStream(new FileOutputStream(f,true));
salida.writeObject(j);
salida.close();
}
}
public void recuperar() throws FileNotFoundException, IOException, EOFException, ClassNotFoundException {
ObjectInputStream entrada=null;
try{ entrada = new ObjectInputStream(new FileInputStream("jugador.objeto"));
while (true) {
Jugador j = ( Jugador) entrada.readObject();
System.out.println(j.getNombre());
}
} catch(IOException io){
} finally {
try {
entrada.close();
} catch (Exception exp) {
}
}

Usa GeShI

Para escribir objetos de manera binaria con ObjectInput/Output Stream, esta diseñada para escribir solo una vez socio, sino tendrias que reimplemantar una clase tu mismo.

Código

/**
 * @implSpec THREAD-SAFE
 *  @autor rub'n 
 */
@Value
@Builder
public class Persona implements Serializable {
    String nombre;
    String apellido;
    String correo;
}

Código

/**
 * @autor rub'n
 */
@Slf4j
public class ConObjectIOStream {
 
    private static final String RUTA_FICHERO = "./temporal.tmp";
 
    private ConObjectIOStream() {
        throw new IllegalAccessError("Constructor privado");
    }
 
    /**
     * Para leer desde el fichero
     *
     * @return List<Persona>
     */
    private static List<Persona> readFromFile() {
        final List<Persona> listaPersona = new CopyOnWriteArrayList<>();
        final Path pathAlimento = Paths.get(RUTA_FICHERO);
        if(pathAlimento.toFile().exists()) {
            try (final BufferedInputStream bin = new BufferedInputStream(Files.newInputStream(pathAlimento));
                 final ObjectInputStream ob = new ObjectInputStream(bin)) {
 
                while (Boolean.TRUE) {
                    synchronized (ConObjectIOStream.class) { //en caso de que readFrom se invoque desde un Thread()
                        final Object object = ob.readObject();
                        if (object instanceof Persona) {
                            listaPersona.add((Persona) object);
                        }
                    }
                }
                ob.reset();
            } catch (IOException | ClassNotFoundException e) {
                //no hacer nada EOFException
                log.error("Error al leer {}", e);
            }
        } else {
            log.error("Error al leer del fichero {}", pathAlimento.toFile());
        }
 
        return List.copyOf(listaPersona)
                .stream()
                .sorted(Comparator.comparing(Persona::getNombre))
                .collect(Collectors.toList());
    }
 
    /**
     * Para escribir en el fichero
     */
    private static void writePersonToTempFile(final Persona ...persona) {
        final Path pathTem = Paths.get(RUTA_FICHERO);
        try (final OutputStream out = Files.newOutputStream(pathTem, StandardOpenOption.CREATE);
             final BufferedOutputStream bos = new BufferedOutputStream(out);
             final ObjectOutputStream ob = new ObjectOutputStream(bos)) {
 
            synchronized (ConObjectIOStream.class) {
                Arrays.stream(persona)
                        .forEach((Persona p) -> writeObject(ob, p));
            }
            ob.reset();
        } catch (IOException e) {
            log.error("Error al escribir en archivo {} ", e);
        }
    }
 
    private static void writeObject(final ObjectOutputStream ob, final Persona persona) {
        try {
            ob.writeObject(persona);
        } catch (IOException e) {
            log.error("Error al escribir objecto {} ", e);
        }
    }
 
    public static void main(String[] args) {
 
        final Persona persona1 = Persona.builder()
                .nombre("ruben")
                .apellido("La muerte")
                .correo("rrara@gmail.com")
                .build();
 
        final Persona persona2 = Persona.builder()
                .nombre("El loco")
                .apellido("La locura")
                .correo("crazyGuy@gmail.com")
                .build();
 
        /*
         * Para escribir
         */
        ConObjectIOStream.writePersonToTempFile(persona1, persona2);
 
        /*
         * Leer
         */
        ConObjectIOStream.readFromFile()
                .forEach((Persona persona) -> log.info("Persona {}", persona));
 
    }
 
}