Hola. Estoy haciendo un programa y tengo


Estoy estudiando I/O streams en la parte de ObjectInputStream y ObjectOutputStream. Los métodos de readFile() y writeFile() los tengo y no tengo problemas.
El problema lo tengo en el método de update(), donde tengo que introducir el id del cliente para modificarlo. Si fuese un array normal no habría problema pero el código lo tengo que hacer por medio de la Clase Lista la cual no debo cambiar y de la que he insertado dos métodos. Repito obtenerlo de un array normal no es problema, pero me estoy armando un listo al obtenerlo de listado. En el main tengo un menu que no he insertado ya que creo qeu no hace falta.
Me haría falta un método que recibiese el id y devolviese la posición. Y este método debería estar en la clase Principal.
Espero haberme explicado. Gracias a todos.
Saludos y feliz año.

Socio, tu tienes un objeto que ira al fichero, veo que eso no lo estas haciendo ahora mismo

De todas maneras coloca lo que llevas ya, estas escribiendo bien en el fichero?

Tu objeto es Cliente y lo puedes escribir con ObjectOutputStream y su metodo writeObject

- Use la jdk 17 para usar records, mejor, para inmutabilidad, la clase una vez compilada es final( para que no se extienda), sin setters y variables de instancia final.
- Use la dependencia lombok, que me permite muchas cosas, una de ellas es la anotación, @Log4j2 ( usada de pekin hasta la china y mas allá)
- Para updatear con ObjectOutputStream, se necesita leer el fichero completo, procesarlo y escribirlo nuevamente. nada eficiente, por eso rara ves se usa.

import java.io.Serializable;
 
public record Customer(int id, String nombre, String telefono) implements Serializable {}

package foro;
 
import lombok.extern.log4j.Log4j2;
 
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
 
/**
 * @autor rub'n
 */
@Log4j2
public class ConObjectIOStream {
 
    private static final String RUTA_FICHERO = "./temporal.tmp";
 
    /**
     * Para leer desde el fichero
     *
     * @return List<Customer>
     */
    private List<Customer> findAll() {
        final List<Customer> listaCustomer = new CopyOnWriteArrayList<>();
        final Path pathInput = Paths.get(RUTA_FICHERO);
        if (pathInput.toFile().exists()) {
            try (final BufferedInputStream bin = new BufferedInputStream(Files.newInputStream(pathInput));
                 final ObjectInputStream ob = new ObjectInputStream(bin)) {
 
                while (Boolean.TRUE) {
                    synchronized (ConObjectIOStream.class) { //en caso de que findAll se invoque desde un Thread()
                        final Object object = ob.readObject();
                        if (object instanceof Customer) {
                            listaCustomer.add((Customer) object);
                        }
                    }
                }
                ob.reset();
            } catch (IOException | ClassNotFoundException e) {
            }
        } else {
            log.error("{} - El fichero no existe", pathInput.toFile());
        }
        //Sorted
        return List.copyOf(listaCustomer)
                .stream()
                .distinct() //No repeat Customers
                .sorted(Comparator.comparing(Customer::id))
                .toList();
    }
 
    /**
     * Para escribir en el fichero
     */
    private void save(final Customer... customer) {
        final Path pathTem = Paths.get(RUTA_FICHERO);
        if (!Files.exists(pathTem)) {
            try {
                Files.createFile(pathTem);
            } catch (IOException e) {
                log.error("Error al crear el fichero {}", e);
            }
        }
        try (final OutputStream out = Files.newOutputStream(pathTem);
             final BufferedOutputStream bos = new BufferedOutputStream(out);
             final ObjectOutputStream ob = new ObjectOutputStream(bos)) {
 
            synchronized (ConObjectIOStream.class) {
                Arrays.stream(customer)
                        .forEach((Customer p) -> writeObject(ob, p));
            }
            ob.reset();
        } catch (IOException e) {
            log.error("Error al escribir en fichero {} ", e);
        }
 
        this.showAll();
    }
 
    private void writeObject(final ObjectOutputStream ob, final Customer customer) {
        try {
            ob.writeObject(customer);
        } catch (IOException e) {
            log.error("Error al escribir objecto {} ", e);
        }
    }
 
    private void updateById(final int id, final Customer newCustomer) {
        this.showAll();
 
        final var isCustomerFound = this.findAll()
                .stream()
                .filter(customer -> customer.id() == id)
                .count();
 
        if (isCustomerFound > 0) {
            final var customerList = this.findAll()
                    .stream()
                    .map(customer -> {
                        if (customer.id() == id) {
                            return newCustomer;
                        }
                        return customer;
                    })
                    .toArray(Customer[]::new);
            log.debug("New Customer {}", newCustomer);
            //Save new Customer items
            this.save(customerList);
        } else {
            log.info("Customer id not found! {}", id);
        }
 
    }
 
    /**
     * Show all Customers
     */
    private void showAll() {
        this.findAll()
                .forEach((Customer customer) -> log.info("Customer {}", customer));
    }
 
    public static void main(String[] args) {
 
        final ConObjectIOStream conObjectIOStream = new ConObjectIOStream();
        final Customer customer1 = new Customer(1, "Ana", "001-135452");
        final Customer customer2 = new Customer(2, "Anita", "002-413315");
        final Customer customer3 = new Customer(3, "Bruce Lee", "003-32453");
        final Customer customer4 = new Customer(4, "Carlitos Way", "004-13151");
        final Customer customer5 = new Customer(5, "Zamuray-X", "005-214343");
        final Customer customer6 = new Customer(6, "Inuyasha", "006-014343");
 
        /**
         * Save
         */
        conObjectIOStream.save(customer1, customer2, customer3, customer4, customer5, customer6);
 
        /**
         * show all
         */
//        conObjectIOStream.showAll();
 
        /**
         * updateById
         */
//        final Customer newCustomer = new Customer(5, "Zamuray-X", "005-12345-678");
//        conObjectIOStream.updateById(5, newCustomer);
 
    }
 
}
 
}

Existen 3 métodos ahí

- save(), para guardar los Objetos de tipo cliente en un fichero llamado temporal.tmp
- findAll(), que lee todos los objetos contenidos en el fichero .tmp
- updateById(), que actualiza un Cliente por medio de su id mira la linea 155, donde se le pasa el Objeto cliente nuevo como parametro y su id, si el id existe se actualiza, sino existe no actualiza nada, además
- Estabas usando la clase Scanner usala y creas el objeto con los datos introducidos por teclado.