Fichero de productos con registros de tamaño fijo y acceso directo

1import java.io.File;
2import java.io.IOException;
3import java.io.RandomAccessFile;
4import java.util.Locale;
5import java.util.Scanner;
6
7public class Main {
8    static final int NOMBRE = 30;                          // caracteres del nombre
9    static final int TAM = 4 + NOMBRE * 2 + 8 + 4 + 1;     // código + nombre + precio + stock + borrado = 77 bytes
10
11    static RandomAccessFile f;
12
13    /** Acceso directo: el registro del código N empieza en el byte (N - 1) × 77. */
14    static long posicion(int codigo) {
15        return (long) (codigo - 1) * TAM;
16    }
17
18    /** Un registro está activo si existe, guarda ese código y no tiene la marca de borrado. */
19    static boolean activo(int codigo) throws IOException {
20        if (posicion(codigo) + TAM > f.length()) return false;
21        f.seek(posicion(codigo));
22        int guardado = f.readInt();
23        f.seek(posicion(codigo) + TAM - 1);
24        return guardado == codigo && !f.readBoolean();
25    }
26
27    static void escribir(int codigo, String nombre, double precio, int stock) throws IOException {
28        f.seek(posicion(codigo));
29        f.writeInt(codigo);
30        StringBuilder sb = new StringBuilder(nombre);
31        sb.setLength(NOMBRE);                              // recorta o rellena con '\0' hasta 30 caracteres
32        f.writeChars(sb.toString());
33        f.writeDouble(precio);
34        f.writeInt(stock);
35        f.writeBoolean(false);
36    }
37
38    /** Lee el registro del código (que debe estar activo) como texto. */
39    static String leer(int codigo) throws IOException {
40        f.seek(posicion(codigo) + 4);
41        StringBuilder nombre = new StringBuilder();
42        for (int i = 0; i < NOMBRE; i++) {
43            char c = f.readChar();
44            if (c != '\0') nombre.append(c);
45        }
46        double precio = f.readDouble();
47        int stock = f.readInt();
48        return codigo + " · " + nombre + " · " + euros(precio) + " · " + stock + " uds";
49    }
50
51    static String euros(double x) {
52        return String.format(Locale.ROOT, "%.2f", x).replace('.', ',') + " €";
53    }
54
55    static void orden(String linea) throws IOException {
56        String[] p = linea.split("\\s+", 2);
57        String args = p.length > 1 ? p[1] : "";
58        switch (p[0].toUpperCase()) {
59            case "ALTA" -> {
60                String[] c = args.split(";", -1);
61                if (c.length != 4 || !c[0].matches("\\d{1,4}") || Integer.parseInt(c[0]) == 0 || c[1].isBlank()
62                        || !c[2].matches("\\d+(\\.\\d{1,2})?") || !c[3].matches("\\d+")) {
63                    System.out.println("Datos no válidos");
64                    return;
65                }
66                int codigo = Integer.parseInt(c[0]);
67                if (activo(codigo)) {
68                    System.out.println("Ya existe el producto " + codigo);
69                    return;
70                }
71                String nombre = c[1].trim();
72                escribir(codigo, nombre, Double.parseDouble(c[2]), Integer.parseInt(c[3]));
73                System.out.println("Alta del producto " + codigo + " en el byte " + posicion(codigo)
74                        + (nombre.length() > NOMBRE ? " (nombre recortado a " + NOMBRE + " caracteres)" : ""));
75            }
76            case "PRECIO" -> {
77                String[] c = args.split("\\s+");
78                if (c.length != 2 || !c[0].matches("\\d{1,4}") || !c[1].matches("\\d+(\\.\\d{1,2})?")) {
79                    System.out.println("Datos no válidos");
80                } else if (!activo(Integer.parseInt(c[0]))) {
81                    System.out.println("No existe el producto " + c[0]);
82                } else {
83                    // Solo se reescriben los 8 bytes del precio: no hace falta leer ni escribir el resto del registro
84                    long donde = posicion(Integer.parseInt(c[0])) + 4 + NOMBRE * 2;
85                    f.seek(donde);
86                    double antes = f.readDouble();
87                    f.seek(donde);
88                    f.writeDouble(Double.parseDouble(c[1]));
89                    System.out.println("Precio del producto " + c[0] + ": " + euros(antes) + " → " + euros(Double.parseDouble(c[1])));
90                }
91            }
92            case "BAJA" -> {
93                if (!args.matches("\\d{1,4}") || !activo(Integer.parseInt(args))) {
94                    System.out.println("No existe el producto " + args);
95                } else {
96                    f.seek(posicion(Integer.parseInt(args)) + TAM - 1);
97                    f.writeBoolean(true);                    // borrado lógico: el registro sigue ahí, marcado
98                    System.out.println("Baja lógica del producto " + args);
99                }
100            }
101            case "VER" -> System.out.println(args.matches("\\d{1,4}") && activo(Integer.parseInt(args)) ? leer(Integer.parseInt(args)) : "No existe el producto " + args);
102            case "LISTAR" -> {
103                int total = (int) (f.length() / TAM);
104                int activos = 0;
105                StringBuilder sb = new StringBuilder();
106                for (int codigo = 1; codigo <= total; codigo++) {
107                    if (activo(codigo)) {
108                        activos++;
109                        sb.append("  ").append(leer(codigo)).append('\n');
110                    }
111                }
112                System.out.print("Productos activos: " + activos + "\n" + sb);
113            }
114            case "INFORME" -> {
115                int total = (int) (f.length() / TAM);
116                int activos = 0;
117                double valor = 0;
118                for (int codigo = 1; codigo <= total; codigo++) {
119                    if (!activo(codigo)) continue;
120                    activos++;
121                    f.seek(posicion(codigo) + 4 + NOMBRE * 2);
122                    double precio = f.readDouble();
123                    valor += precio * f.readInt();
124                }
125                System.out.println("Fichero: " + f.length() + " bytes, " + total + " huecos de registro, " + activos
126                        + " activos, " + (total - activos) + " libres o borrados · valor del stock " + euros(valor));
127            }
128            default -> System.out.println("Orden desconocida");
129        }
130    }
131
132    public static void main(String[] args) throws IOException {
133        File fichero = File.createTempFile("productos", ".dat");
134        fichero.deleteOnExit();
135        try (RandomAccessFile raf = new RandomAccessFile(fichero, "rw")) {
136            f = raf;
137            Scanner sc = new Scanner(System.in);
138            while (sc.hasNextLine()) {
139                String linea = sc.nextLine().trim();
140                if (!linea.isEmpty()) orden(linea);
141            }
142        }
143    }
144}