[NP] Student Records

public class StudentRecords {
    List<Record> records;

    public StudentRecords() {
        this.records = new ArrayList<>();
    }

    public int readRecords(InputStream in) {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(in));
        records= bufferedReader.lines().map(Record::createRecord).collect(Collectors.toList());
        return records.size();
    }

    public void writeTable(PrintStream out) {
        PrintWriter printWriter = new PrintWriter(out);
        Map<String, Set<Record>> recordsByMajor = records.stream().collect(Collectors.groupingBy(
           Record::getMajor,
                TreeMap::new,
                Collectors.toSet()
        ));
        for(String s : recordsByMajor.keySet()){
            printWriter.println(s);
            recordsByMajor.get(s).stream().sorted().forEach(printWriter::println);
        }
        printWriter.flush();
    }

    public void writeDistribution(PrintStream out) {
        PrintWriter printWriter = new PrintWriter(out);

        Map<String, Map<Integer, Long>> recordsByMajorAndDistributedByGrade = records.stream()
                .collect(Collectors.groupingBy(
                        Record::getMajor,
                        TreeMap::new,
                        Collectors.flatMapping(
                                record -> record.getScores().stream(), // flatten all scores in each major
                                Collectors.groupingBy(
                                        grade -> grade,
                                        HashMap::new,
                                        Collectors.counting()
                                )
                        )
                ));
        Map<String, Map<Integer, Long>> recordsByMajorAndDistributedByGradeSorted = recordsByMajorAndDistributedByGrade.entrySet()
                .stream().sorted(Comparator.<Map.Entry<String, Map<Integer, Long>>>comparingLong(entry -> entry.getValue().getOrDefault(10,0L))
                        .reversed())
                        .collect(Collectors.toMap(
                        Map.Entry::getKey,
                        Map.Entry::getValue,
                        (a, b) -> a,
                        LinkedHashMap::new

                ));
        for(String major : recordsByMajorAndDistributedByGradeSorted.keySet()){
            printWriter.println(major);

            for(Integer grade : recordsByMajorAndDistributedByGradeSorted.get(major).keySet()){
                String stars = getStars(Math.round(recordsByMajorAndDistributedByGradeSorted.get(major).get(grade).intValue()/10));
                printWriter.println(String.format("%2d | %s(%d)",grade,stars,recordsByMajorAndDistributedByGradeSorted.get(major).get(grade)));
            }
        }


        printWriter.flush();
    }

    public String getStars(double numberOfStars){
        StringBuilder sb= new StringBuilder();
        for(int i=0;i<=numberOfStars;i++){
            sb.append("*");
        }
        return sb.toString();
    }
}
public class Record implements Comparable<Record>{

    String code;
    String major;
    List<Integer> scores;

    public Record(String code, String major, List<Integer> scores) {
        this.code = code;
        this.major = major;
        this.scores = scores;
    }

    public String getCode() {
        return code;
    }

    public String getMajor() {
        return major;
    }

    public List<Integer> getScores() {
        return scores;
    }

    public static Record createRecord(String line){
        String[] parts = line.split(" ");
        String code = parts[0];
        String major = parts[1];
        List<Integer> scores = Arrays.stream(parts).skip(2).map(i->Integer.parseInt(i)).collect(Collectors.toList());
        return new Record(code,major,scores);
    }

    public double getAverageScore(){
        return scores.stream().mapToDouble(i->i).average().orElse(5.0);
    }


    @Override
    public String toString() {
        return String.format("%s %.2f",code,getAverageScore());
    }

    @Override
    public int compareTo(Record o) {
        return Comparator.comparing(Record::getAverageScore)
                .reversed()
                .thenComparing(Record::getCode)
                .compare(this,o);
    }
}
public class StudentRecordsTest {
    public static void main(String[] args) {
        System.out.println("=== READING RECORDS ===");
        StudentRecords studentRecords = new StudentRecords();
        int total = studentRecords.readRecords(System.in);
        System.out.printf("Total records: %d\n", total);
        System.out.println("=== WRITING TABLE ===");
        studentRecords.writeTable(System.out);
        System.out.println("=== WRITING DISTRIBUTION ===");
        studentRecords.writeDistribution(System.out);
    }
}