Demo: saving and loading contacts as CSV

Written Explanation

The plan

The design has four small parts, each from an earlier lesson:

1. A Contact with toCsv() and fromCsv(line), which rejects wrong lines with IllegalArgumentException.
2. save(List<Contact>, Path): build the lines, make sure the folder exists, write as UTF-8.
3. load(Path): if the file is missing, return an empty list. Otherwise read line by line, parse each line inside its own try/catch, count the bad ones, print their numbers and reasons.
4. A main that loads at the start, applies a change, and saves at the end.

Step 1: save

static void save(List<Contact> contacts, Path file) throws IOException {
    List<String> lines = new ArrayList<>();
    for (Contact c : contacts) {
        lines.add(c.toCsv());
    }
    Files.createDirectories(file.toAbsolutePath().getParent());
    Files.write(file, lines, StandardCharsets.UTF_8);
}

We build the list of lines, create the folder if needed, and write. Files.write replaces the file, which is correct here: the list in memory is the complete truth, so the file should become an exact copy of it. The call file.toAbsolutePath().getParent() avoids the null problem from the first lesson: an absolute path always has a parent, even if the relative path was just contacts.csv.

Step 2: load

static LoadResult load(Path file) {
    List<Contact> contacts = new ArrayList<>();
    if (!Files.exists(file)) {
        return new LoadResult(contacts, 0);
    }
    int bad = 0;
    try (BufferedReader reader = Files.newBufferedReader(file, StandardCharsets.UTF_8)) {
        String line;
        int number = 0;
        while ((line = reader.readLine()) != null) {
            number++;
            if (line.isBlank()) continue;
            try {
                contacts.add(Contact.fromCsv(line));
            } catch (IllegalArgumentException e) {
                bad++;
                System.out.println("Line " + number + " skipped: " + e.getMessage());
            }
        }
    } catch (IOException e) {
        System.out.println("Could not read " + file + ": " + e.getMessage());
    }
    return new LoadResult(contacts, bad);
}

Study the structure: there are two nested levels of error handling, for two different kinds of failure. The inner catch (IllegalArgumentException) handles one bad line and lets the loop continue. The outer catch (IOException) handles trouble with the file itself (it exists but cannot be read, or contains bytes that are not valid UTF-8) and returns whatever was loaded so far. A missing file is not an error at all: it is the normal first run. The method returns both the list and the count of bad lines, using a small LoadResult record, so that the caller can tell the user.

Step 3: the planned mistake, absolute paths

Suppose we first wrote the file location like this:

static final Path FILE = Path.of("C:\\data\\contacts.csv");   // wrong

On the author's machine it may work. On another computer it fails in one of several ways: on Linux or macOS the string is not a sensible path at all (it would be treated as a single odd file name), and on a Windows machine without that folder or drive the save throws an exception. To show a failure safely, we pointed the save at a drive that does not exist on this machine, Z:/data/contacts.csv, and got:

FileSystemException: Z:\data: Unable to determine if root directory exists

The exact message depends on the operating system, so do not expect to see this same text. The point is that the program only works where the author's folder layout happens to exist. The fix is the relative path:

static final Path FILE = Path.of("data", "contacts.csv");   // right

Now the file lives in a data folder inside the working directory, and save creates the folder if it is missing.

Step 4: run it twice

The main method loads, optionally adds a contact given on the command line, saves, and prints. Running it several times (for example java Contacts add Ana 0501112222 ana@example.com, adapted to how you launch programs) shows the data growing between runs.