Solved exercise: Java serialization with transient fields

The solution separates three responsibilities: the model (Product and Warehouse), persistence (save and load) and the command interpreter in main. The key point of the exercise is that totalValue is marked transient: it never travels to the file, and when the object is read back, readObject rebuilds it from the list.

import java.io.*;
import java.nio.file.*;
import java.util.*;

public class Main {

    static class Product implements Serializable {
        private static final long serialVersionUID = 1L;
        final String name;
        long quantity;
        long price;

        Product(String name, long quantity, long price) {
            this.name = name;
            this.quantity = quantity;
            this.price = price;
        }
    }

    static class Warehouse implements Serializable {
        private static final long serialVersionUID = 1L;
        private final List<Product> products = new ArrayList<>();
        private transient long totalValue = 0;

        private Product find(String name) {
            for (Product p : products) {
                if (p.name.equals(name)) return p;
            }
            return null;
        }

        void add(String name, long quantity, long price) {
            Product p = find(name);
            if (p == null) {
                p = new Product(name, quantity, price);
                products.add(p);
                totalValue += quantity * price;
            } else {
                totalValue -= p.quantity * p.price;
                p.quantity += quantity;
                p.price = price;
                totalValue += p.quantity * p.price;
            }
        }

        String sell(String name, long quantity) {
            Product p = find(name);
            if (p == null) return "ERROR unknown product";
            if (p.quantity < quantity) return "ERROR insufficient stock";
            p.quantity -= quantity;
            totalValue -= quantity * p.price;
            return "SOLD " + name + " " + p.quantity;
        }

        long value() {
            return totalValue;
        }

        int size() {
            return products.size();
        }

        List<Product> list() {
            return products;
        }

        private void readObject(ObjectInputStream in)
                throws IOException, ClassNotFoundException {
            in.defaultReadObject();
            totalValue = 0;
            for (Product p : products) {
                totalValue += p.quantity * p.price;
            }
        }
    }

    static final Path FILE = Paths.get("warehouse.dat");

    static void save(Warehouse w) throws IOException {
        try (ObjectOutputStream out = new ObjectOutputStream(
                new BufferedOutputStream(Files.newOutputStream(FILE)))) {
            out.writeObject(w);
        }
    }

    static Warehouse load() throws IOException, ClassNotFoundException {
        try (ObjectInputStream in = new ObjectInputStream(
                new BufferedInputStream(Files.newInputStream(FILE)))) {
            return (Warehouse) in.readObject();
        }
    }

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        Warehouse warehouse = new Warehouse();
        StringBuilder sb = new StringBuilder();
        String line;
        while ((line = br.readLine()) != null) {
            line = line.trim();
            if (line.isEmpty()) continue;
            String[] t = line.split("\\s+");
            switch (t[0]) {
                case "ADD" -> {
                    warehouse.add(t[1], Long.parseLong(t[2]), Long.parseLong(t[3]));
                    sb.append("ADDED ").append(t[1]).append('\n');
                }
                case "SELL" -> sb.append(warehouse.sell(t[1], Long.parseLong(t[2]))).append('\n');
                case "VALUE" -> sb.append("VALUE ").append(warehouse.value()).append('\n');
                case "SAVE" -> {
                    save(warehouse);
                    sb.append("SAVED ").append(warehouse.size()).append('\n');
                }
                case "LOAD" -> {
                    if (!Files.exists(FILE)) {
                        sb.append("ERROR no file\n");
                    } else {
                        warehouse = load();
                        sb.append("LOADED ").append(warehouse.size()).append('\n');
                    }
                }
                case "LIST" -> {
                    for (Product p : warehouse.list()) {
                        sb.append(p.name).append(' ').append(p.quantity)
                          .append(' ').append(p.price).append('\n');
                    }
                }
                default -> { }
            }
        }
        System.out.print(sb);
        Files.deleteIfExists(FILE);
    }
}

Product and Warehouse implement Serializable and declare serialVersionUID, so version compatibility is explicit instead of depending on a hash computed by the JVM. In Warehouse, the field products is serialized while totalValue, being transient, is left out of the byte stream.

add and sell maintain totalValue incrementally. In add on an existing product the old contribution is subtracted first and the new one added, because the price is replaced: in the test "Repeated add" (nail 10 at 5, then 5 more at 8) the total goes from 50 to 15·8 = 120, not to 50 + 40.

The heart of the exercise is readObject. The JVM invokes it on deserialization; we call defaultReadObject() to restore products and then walk the list to recompute totalValue. Without that method the field would be 0 after LOAD. The test "Statement example" checks it: after SAVE the value is 650, after selling 4 nuts it drops to 550, and after LOAD it is 650 again, because the saved state is recovered and the transient field is rebuilt from it.

The method save uses try-with-resources with an ObjectOutputStream over a buffered stream, so the file is flushed and closed even if an exception occurs; Files.newOutputStream truncates an existing file, which is why SAVE overwrites it. load does the same with ObjectInputStream and casts the result to Warehouse; the list is read back in the order it was written. Before loading, main checks Files.exists; the test "Load without save" prints ERROR no file and the warehouse stays empty (VALUE 0).

The test "Save empty and reload" shows that loading replaces the in-memory warehouse: it is saved empty, a product is added (value 1), and LOAD returns 0 products and value 0. The errors of SELL (test "Failed sales") do not alter the state: the value stays at 1500. Finally, main accumulates the output in a StringBuilder and deletes the working file at the end so that successive runs are independent.