Hospital patient records and this

import java.util.*;

public class Main {
    private static final Scanner IN = new Scanner(System.in).useLocale(Locale.ROOT);

java.util.* imports utility type names such as Scanner, Locale and collections. Main is the public class matching Main.java. The private static final IN field holds one shared Scanner for System.in; final prevents replacing that reference. The scanner uses Locale.ROOT.

    static String text() {
        if (!IN.hasNextLine()) throw new IllegalArgumentException("Incomplete input.");
        String value = IN.nextLine().trim();
        if (value.isEmpty() || value.length() > 200) throw new IllegalArgumentException("Text must have 1–200 characters.");
        return value;
    }

text checks whether a line exists, reads it and removes leading/trailing whitespace. Reject empty text and lengths above 200 by throwing IllegalArgumentException. Otherwise return the string. One field is read per line, so these helpers do not mix nextInt with leftover newlines.

    static int integer(int low, int high) {
        int value = Integer.parseInt(text());
        if (value < low || value > high) throw new IllegalArgumentException("Integer out of range.");
        return value;
    }

Integer.parseInt converts the returned string to int or throws NumberFormatException, a subtype of IllegalArgumentException. Reject values outside the caller’s inclusive low/high limits, then return the accepted integer.

    static double number(double low, double high) {
        double value = Double.parseDouble(text());
        if (!Double.isFinite(value) || value < low || value > high) throw new IllegalArgumentException("Number out of range.");
        return value;
    }

Double.parseDouble reads the string as a double. Double.isFinite rejects NaN and infinities as well as the explicit low/high range check. Return only a finite accepted value; exceptions transfer control to a matching catch block.

    static void money(String label, double value) { System.out.printf(Locale.ROOT, "%s: %.2f%n", label, value); }

money is a formatting helper: %s prints the label, %.2f prints two decimal places, and %n ends the line. Locale.ROOT fixes locale-sensitive formatting. The helper can also display non-currency quantities; it does not change the stored value.

static class Patient {
        private final int patientId, age;
        private final String name, problem;
        private String doctorAssigned;
        private double feePaid;

Patient stores final ID, age, name and problem, plus editable doctorAssigned and feePaid. Each object holds its own current record.

        Patient(int patientId, String name, int age, String problem, String doctorAssigned, double feePaid) {
            this.patientId = patientId; this.name = name; this.age = age; this.problem = problem;
            this.doctorAssigned = doctorAssigned; this.feePaid = feePaid;
        }

The constructor copies its supplied values into instance fields. The command driver validates ID, age and opening fee before calling it.

        void updateDoctor(String doctor) { if (doctor.trim().isEmpty()) throw new IllegalArgumentException("Doctor required."); doctorAssigned = doctor; }
        void addFee(double amount) {
            if (!Double.isFinite(amount) || amount <= 0 || feePaid + amount > 1000000000) throw new IllegalArgumentException("Invalid fee."); feePaid += amount;
        }

updateDoctor rejects blank trimmed text. addFee requires a positive finite amount and checks the resulting fee total before increasing it. A rejected fee leaves the old total unchanged.

        void displayReport() { System.out.printf(Locale.ROOT,"%d | %s | age %d | %s | %s | fee %.2f%n", patientId, name, age, problem, doctorAssigned, feePaid); }
    }

Format the record fields and fee on one line. The closing brace ends Patient.

    static Patient find(List<Patient> patients, int id) {
        for (Patient p : patients) if (p.patientId == id) return p;
        throw new IllegalArgumentException("Patient not found.");
    }

Scan the list and return the matching Patient reference. The surrounding Main class can access this nested class’s private fields. Throw an error if no ID matches rather than returning an unrelated record.

    // Commands: 1=register (id/name/age/problem/doctor/fee), 2=id then new doctor,
    // 3=id then additional fee, 4=display all, 0=exit. One field per line.
    public static void main(String[] args) {
        List<Patient> patients = new ArrayList<>();
        System.out.println("1 Register | 2 Update doctor | 3 Add fee | 4 Display | 0 Exit");
        try {

Use an ArrayList of Patient references and print the available operations. The try block encloses the command-reading session.

            while (true) {
                int command = integer(0, 4); if (command == 0) break;
                if (command == 1) {
                    int id = integer(1, 1000000); String name = text(); int age = integer(0, 130);
                    String problem = text(), doctor = text(); double fee = number(0, 1000000);

Exit on 0. For registration, validate ID, age and fee and read each text field. Reading a field does not yet add a Patient to the registry.

                    boolean duplicate = patients.stream().anyMatch(p -> p.patientId == id);
                    if (duplicate) System.out.println("Duplicate patient ID ignored.");
                    else if (patients.size() == 100) System.out.println("Registry is full.");
                    else { patients.add(new Patient(id,name,age,problem,doctor,fee)); System.out.println("Registered."); }

anyMatch uses a lambda predicate to test whether an existing patient has the same ID. Only a new ID within the 100-record limit creates and adds a Patient.

                } else if (command == 2) { Patient p = find(patients,integer(1,1000000)); p.updateDoctor(text()); System.out.println("Doctor updated."); }
                else if (command == 3) { Patient p = find(patients,integer(1,1000000)); p.addFee(number(0,1000000)); System.out.println("Fee added."); }
                else { System.out.println("Patients:"); for (Patient p : patients) p.displayReport(); }
            }

find returns the actual object stored in the list, so changing its doctor or fee changes the registry record. Display loops through the stored objects. The brace ends command processing.

        } catch (IllegalArgumentException e) { System.out.println("Invalid input: " + e.getMessage()); }
    }
}

The catch handles IllegalArgumentException, including invalid numeric strings from the helpers, and prints its message. The final braces close main and Main. Java objects become eligible for garbage collection when no live reference needs them; this program does not manually free them.