https://medium.com/illumination/java-8-stream-api-commonly-asked-interview-questions-2a57081044ef

@Data
@ToString
public class Student {
    private int id;

    private String firstName;

    private String lastName;

    private int age;

    private String gender;

    private String departmentName;

    private int joinedYear;

    private String city;

    private int rank;

    public Student(int id, String firstName, String lastName, int age, String gender, String departmentName, int joinedYear, String city, int rank) {
        this.id = id;
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
        this.gender = gender;
        this.departmentName = departmentName;
        this.joinedYear = joinedYear;
        this.city = city;
        this.rank = rank;
    }
}

/**
 * The type Student stream helper.
 */
@Slf4j
public class StudentStreamHelper {

    private final List<Student> list = Collections.unmodifiableList(
            Arrays.asList(
                    new Student(1, "Rohit", "Mall", 30, "Male", "Mechanical Engineering", 2015, "Mumbai", 122),
                    new Student(2, "Pulkit", "Singh", 56, "Male", "Computer Engineering", 2018, "Delhi", 67),
                    new Student(3, "Ankit", "Patil", 25, "Female", "Mechanical Engineering", 2019, "Kerala", 164),
                    new Student(4, "Satish Ray", "Malaghan", 30, "Male", "Mechanical Engineering", 2014, "Kerala", 26),
                    new Student(5, "Roshan", "Mukd", 23, "Male", "Biotech Engineering", 2022, "Mumbai", 12),
                    new Student(6, "Chetan", "Star", 24, "Male", "Mechanical Engineering", 2023, "Karnataka", 90),
                    new Student(7, "Arun", "Vittal", 26, "Male", "Electronics Engineering", 2014, "Karnataka", 324),
                    new Student(8, "Nam", "Dev", 31, "Male", "Computer Engineering", 2014, "Karnataka", 433),
                    new Student(9, "Sonu", "Shankar", 27, "Female", "Computer Engineering", 2018, "Karnataka", 7),
                    new Student(10, "Shubham", "Pandey", 26, "Male", "Instrumentation Engineering", 2017, "Mumbai", 98)
            )
    );


    /**
     * Find by first name start with.
     *
     * @param startWith the start with
     */
    public void findByFirstNameStartWith(String startWith) {
        List<Student> resultList = list.stream()
                .filter(student -> student.getFirstName().startsWith(startWith))
                .toList();

        log.info(String.format("List of students whose name starts with letter %s : ", startWith));
        for (Student student : resultList) {
            log.info(student.toString());
        }
    }

    /**
     * Group by department.
     */
    public void groupByDepartment() {
        Map<String, List<Student>> mapData = list.stream()
                .collect(Collectors.groupingBy(Student::getDepartmentName));

        for (Map.Entry<String, List<Student>> data : mapData.entrySet()) {
            log.info(String.format("Department Name : %s", data.getKey()) + data.getValue());
        }
    }

    /**
     * Gets count.
     */
    public void getCount() {
        // list의 사이즈도 있지만 stream 연습중이니까 stream으로 count를 해보자
        long count = list.stream().count();
        log.info("Total number of students : " + count);
    }

    /**
     * Find by max age.
     */
    public void findByMaxAge() {
        OptionalInt maxAge = list.stream().mapToInt(Student::getAge).max();
        log.info("Max age of student : " + maxAge);
    }


    /**
     * Find all department.
     */
    public void findAllDepartment() {
        List<String> departmentList = list.stream()
                .map(Student::getDepartmentName)
                .distinct()
                .toList();

        log.info("All distinct department names : " + departmentList);
    }

    /**
     * Find each department count in list.
     * 리스트에서 department 별로 count를 구해보자
     */
    public void findEachDepartmentCount() {
        Map<String, Long> departmentCount = list.stream()
                .collect(Collectors.groupingBy(Student::getDepartmentName, Collectors.counting()));

        for (Map.Entry<String, Long> data : departmentCount.entrySet()) {
            log.info(String.format("Department Name : %s, Count : %d", data.getKey(), data.getValue()));
        }
    }

    /**
     * Find by age under.
     *
     * @param age the age
     */
    public void findByUnderAge(int age) {
        List<Student> resultList = list.stream()
                .filter(student -> student.getAge() < age)
                .toList();

        log.info(String.format("List of students whose age is under %d : ", age));
        for (Student student : resultList) {
            log.info(student.toString());
        }
    }

    /**
     * Find by rank between.
     *
     * @param start the start
     * @param end   the end
     */
    public void findByRankBetween(int start, int end) {
        List<Student> resultList = list.stream()
                .filter(student -> student.getRank() >= start && student.getRank() <= end)
                .toList();

        log.info(String.format("List of students whose rank is between %d and %d : ", start, end));
        for (Student student : resultList) {
            log.info(student.toString());
        }
    }

    /**
     * Find average age each gender.
     * 성별 평균 나이
     */
    public void findAverageAgeEachGender() {
        Map<String, Double> averageAge = list.stream()
                .collect(Collectors.groupingBy(Student::getGender, Collectors.averagingInt(Student::getAge)));

        for (Map.Entry<String, Double> data : averageAge.entrySet()) {
            log.info(String.format("Gender : %s, Average Age : %.2f", data.getKey(), data.getValue()));
        }
    }

    /**
     * Find Department by maximum students.
     */
    public void findDepartmentByMaximumStudents() {
        Map.Entry<String, Long> entry = list.stream()
                .collect(Collectors.groupingBy(Student::getDepartmentName, Collectors.counting()))
                .entrySet().stream()
                .max(Map.Entry.comparingByValue()).orElseThrow();

        log.info("Department having maximum number of students : " + entry);
    }

    /**
     * Find by city sort by first name.
     *
     * @param city the city
     */
    public void findByCitySortByFirstName(String city) {
        List<Student> resultList = list.stream()
                .filter(student -> student.getCity().equals(city))
                .sorted(Comparator.comparing(Student::getFirstName))
                .toList();

        log.info(String.format("List of students from %s city sorted by name : ", city));
        for (Student student : resultList) {
            log.info(student.toString());
        }
    }

    /**
     * Find by average rank each department.
     */
    public void findByAverageRankEachDepartment() {
        Map<String, Double> averageRank = list.stream()
                .collect(Collectors.groupingBy(Student::getDepartmentName, Collectors.averagingInt(Student::getRank)));

        for (Map.Entry<String, Double> data : averageRank.entrySet()) {
            log.info(String.format("Department Name : %s, Average Rank : %.2f", data.getKey(), data.getValue()));
        }
    }

    /**
     * Find by highest rank each department.
     */
    public void findByHighestRankEachDepartment() {
        Map<String, Optional<Student>> highestRank = list.stream()
                .collect(Collectors.groupingBy(Student::getDepartmentName, Collectors.minBy(Comparator.comparingInt(Student::getRank))));

        for (Map.Entry<String, Optional<Student>> data : highestRank.entrySet()) {
            log.info(String.format("Department Name : %s, Highest Rank : %s", data.getKey(), data.getValue().orElse(null)));
        }
    }

    /**
     * Sort by rank.
     */
    public void sortByRank() {
        List<Student> resultList = list.stream()
                .sorted(Comparator.comparingInt(Student::getRank))
                .toList();

        log.info("List of students sorted by rank : ");
        for (Student student : resultList) {
            log.info(student.toString());
        }
    }

    /**
     * Find by second rank.
     */
    public void findBySecondRank() {
        Optional<Student> student = list.stream()
                .sorted(Comparator.comparingInt(Student::getRank))
                .skip(1)
                .findFirst();

        log.info("Second rank student : " + student.orElse(null));
    }

}

[Java] stream API 사용 예제