Practice Questions — Lambda Expressions and Streams API

import java.util.List;
import java.util.stream.Collectors;

public class FilterAndTransform {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        List<Integer> result = nums.stream()
            .filter(n -> n % 2 == 0)
            .map(n -> n * 2)
            .collect(Collectors.toList());
        System.out.println(result);
    }
}

import java.util.*;
import java.util.stream.Collectors;

public class GradeReport {
    record Student(String name, int marks) {}

    public static void main(String[] args) {
        List<Student> students = List.of(
            new Student("Arjun", 85),
            new Student("Priya", 92),
            new Student("Vikram", 35),
            new Student("Sneha", 78),
            new Student("Rohan", 42)
        );

        List<String> above80 = students.stream()
            .filter(s -> s.marks() > 80)
            .sorted(Comparator.comparingInt(Student::marks).reversed())
            .map(s -> s.name() + "(" + s.marks() + ")")
            .collect(Collectors.toList());
        System.out.println("Above 80: " + above80);

        double avg = students.stream()
            .mapToInt(Student::marks)
            .average().orElse(0);
        System.out.printf("Average: %.1f%n", avg);

        Map<Boolean, List<String>> passFailMap = students.stream()
            .collect(Collectors.partitioningBy(
                s -> s.marks() >= 40,
                Collectors.mapping(Student::name, Collectors.toList())
            ));
        System.out.println("PASS: " + passFailMap.get(true));
        System.out.println("FAIL: " + passFailMap.get(false));
    }
}

import java.util.*;
import java.util.stream.Collectors;

public class WordFrequency {
    public static void main(String[] args) {
        List<String> sentences = List.of(
            "Java is great",
            "Java is powerful",
            "Java and Python are great"
        );

        Map<String, Long> frequency = sentences.stream()
            .flatMap(s -> Arrays.stream(s.toLowerCase().split("\\s+")))
            .collect(Collectors.groupingBy(w -> w, Collectors.counting()));

        frequency.entrySet().stream()
            .sorted(Map.Entry.<String, Long>comparingByValue().reversed())
            .limit(5)
            .forEach(e -> System.out.println(e.getKey() + ": " + e.getValue()));
    }
}

import java.util.*;
import java.util.stream.Collectors;

public class EmployeeAnalytics {
    record Employee(String name, String dept, int salary) {}

    public static void main(String[] args) {
        List<Employee> employees = List.of(
            new Employee("Arjun", "Engineering", 85000),
            new Employee("Priya", "Engineering", 92000),
            new Employee("Vikram", "Marketing", 78000),
            new Employee("Sneha", "Engineering", 95000),
            new Employee("Rohan", "Marketing", 72000),
            new Employee("Kavya", "HR", 68000)
        );

        // Highest paid per department
        Map<String, Optional<Employee>> topPerDept = employees.stream()
            .collect(Collectors.groupingBy(
                Employee::dept,
                Collectors.maxBy(Comparator.comparingInt(Employee::salary))
            ));
        topPerDept.forEach((dept, emp) ->
            emp.ifPresent(e -> System.out.println(dept + ": " + e.name() + "(" + e.salary() + ")")));

        // Total salary per dept
        Map<String, Integer> totalPerDept = employees.stream()
            .collect(Collectors.groupingBy(Employee::dept, Collectors.summingInt(Employee::salary)));
        System.out.println("Total per dept: " + totalPerDept);

        // Above company average
        double avg = employees.stream().mapToInt(Employee::salary).average().orElse(0);
        List<String> aboveAvg = employees.stream()
            .filter(e -> e.salary() > avg)
            .map(Employee::name)
            .collect(Collectors.toList());
        System.out.printf("Company avg: %.0f, Above: %s%n", avg, aboveAvg);

        // Sorted names
        String allNames = employees.stream()
            .map(Employee::name)
            .sorted()
            .collect(Collectors.joining(", "));
        System.out.println("All names: " + allNames);
    }
}

import java.util.*;

public class OptionalChain {
    record Address(String city, String state) {}
    record User(int id, String name, Address address) {}

    static Map<Integer, User> database = Map.of(
        1, new User(1, "Arjun", new Address("Delhi", "Delhi")),
        2, new User(2, "Priya", new Address("Mumbai", "Maharashtra")),
        3, new User(3, "Vikram", null) // no address
    );

    static Optional<User> findUser(int id) {
        return Optional.ofNullable(database.get(id));
    }

    static String getCityUpperCase(int userId) {
        return findUser(userId)
            .map(User::address)
            .map(Address::city)
            .map(String::toUpperCase)
            .orElse("UNKNOWN");
    }

    public static void main(String[] args) {
        System.out.println("User 1 city: " + getCityUpperCase(1));
        System.out.println("User 2 city: " + getCityUpperCase(2));
        System.out.println("User 3 city: " + getCityUpperCase(3));
        System.out.println("User 99 city: " + getCityUpperCase(99));
    }
}