Student marks database using HashMap and TreeMap

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 MarksDatabase {
        final HashMap<Integer,Double> records=new HashMap<>();
        void addRecord(int roll,double percentage){if(roll<=0||!Double.isFinite(percentage)||percentage<0||percentage>100)throw new IllegalArgumentException("Invalid record.");records.put(roll,percentage);}

HashMap associates Integer roll IDs with Double percentages. After validation, put creates a new mapping or replaces the old percentage for that roll. It does not create duplicate map keys.

        void displayAllSorted(){System.out.println("Sorted records:");for(Map.Entry<Integer,Double> entry:new TreeMap<>(records).entrySet())System.out.printf(Locale.ROOT,"%d: %.2f%%%n",entry.getKey(),entry.getValue());}
        Double searchByRoll(int roll){return records.get(roll);}

A new TreeMap orders the mappings by roll number for display; HashMap itself has no sorted iteration guarantee. searchByRoll returns a Double reference, which can be null for an absent key.

        void displayLists(){
            if(records.isEmpty()){System.out.println("No records.");return;}
            double top=Collections.max(records.values());System.out.println("Toppers:");
            for(Map.Entry<Integer,Double> entry:new TreeMap<>(records).entrySet())if(Double.compare(entry.getValue(),top)==0)System.out.printf(Locale.ROOT,"%d: %.2f%%%n",entry.getKey(),entry.getValue());

Handle an empty database before Collections.max. Find the maximum value, then scan a roll-sorted copy and print every equal top percentage, not only the first student.

            System.out.println("Fail list (<40):");for(Map.Entry<Integer,Double> entry:new TreeMap<>(records).entrySet())if(entry.getValue()<40)System.out.printf(Locale.ROOT,"%d: %.2f%%%n",entry.getKey(),entry.getValue());
        }
    }

The fail list uses percentage < 40, so exactly 40 is excluded. The braces end the list-report method and MarksDatabase.

    // 1 roll percentage=add/update, 2=sorted display, 3 roll=search, 4=topper/fail lists, 0=exit.
    public static void main(String[] args){
        try{
            MarksDatabase database=new MarksDatabase();
            while(true){int command=integer(0,4);if(command==0)break;

The comment lists add/update, sorted display, lookup and lists. Create one database object and loop until command 0.

                if(command==1){int roll=integer(1,1000000);double percentage=number(0,100);if(database.records.size()==100&&!database.records.containsKey(roll))throw new IllegalArgumentException("Database limit reached.");database.addRecord(roll,percentage);System.out.println("Saved.");}

Read and validate roll and percentage. At 100 records reject only a new roll; containsKey permits updates to existing entries. Then addRecord performs the map put and prints Saved.

                else if(command==2)database.displayAllSorted();
                else if(command==3){Double value=database.searchByRoll(integer(1,1000000));if(value==null)System.out.println("No such roll.");else money("Percentage",value);}
                else database.displayLists();
            }

For a lookup, test the nullable Double before numeric formatting to avoid unboxing null. Other branches reuse the database’s report methods. The final brace ends the command loop.

        }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.