Lambdas & Functional Interfaces

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

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

    public static void main(String[] args) {
        List<Student> list = new ArrayList<>(List.of(
            new Student("Meera", "Kochi", 88),
            new Student("Aarav", "Jaipur", 95),
            new Student("Rohan", "Kochi", 72),
            new Student("Isha", "Jaipur", 88)));

        // Old style: an anonymous class
        list.sort(new Comparator<Student>() {
            @Override
            public int compare(Student a, Student b) {
                return a.name().compareTo(b.name());
            }
        });
        System.out.println(list.get(0).name());

        // Lambda: the same comparator in one line
        list.sort((a, b) -> Integer.compare(b.marks(), a.marks()));
        list.forEach(s -> System.out.println(s.name() + " " + s.marks()));

        // Comparator helpers with method references
        list.sort(Comparator.comparing(Student::city)
                            .thenComparing(Student::marks, Comparator.reverseOrder()));
        System.out.println(list);
    }
}

import java.util.List;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.function.UnaryOperator;

public class Builtins {
    public static void main(String[] args) {
        Predicate<Integer> isAdult = age -> age >= 18;
        Function<String, Integer> length = s -> s.length();
        Consumer<String> greet = name -> System.out.println("Namaste, " + name);
        Supplier<String> greeting = () -> "Good morning";
        UnaryOperator<String> shout = s -> s.toUpperCase() + "!";
        BinaryOperator<Integer> add = (a, b) -> a + b;
        BiFunction<Integer, Double, Double> gst = (price, rate) -> price * rate;

        System.out.println(isAdult.test(17));
        System.out.println(length.apply("Lucknow"));
        greet.accept("Farhan");
        System.out.println(greeting.get());
        System.out.println(shout.apply("jai ho"));
        System.out.println(add.apply(250, 120));
        System.out.println(gst.apply(1000, 0.18));

        Predicate<String> longName = s -> s.length() > 5;
        Predicate<String> startsWithA = s -> s.startsWith("A");
        Predicate<String> both = longName.and(startsWithA);
        for (String n : List.of("Ananya", "Aarav", "Kabir")) {
            System.out.println(n + ": " + both.test(n) + " / " + both.negate().test(n));
        }

        Function<Integer, Integer> doubleIt = x -> x * 2;
        Function<Integer, Integer> plusTen = x -> x + 10;
        System.out.println(doubleIt.andThen(plusTen).apply(5));
        System.out.println(doubleIt.compose(plusTen).apply(5));
    }
}

public class Own {
    @FunctionalInterface
    interface DiscountRule {
        double apply(double amount);
    }

    static double checkout(double amount, DiscountRule rule) {
        double after = rule.apply(amount);
        return Math.max(after, 0);
    }

    public static void main(String[] args) {
        DiscountRule festive = amt -> amt * 0.80;
        DiscountRule flat100 = amt -> amt - 100;
        DiscountRule bigSpender = amt -> {
            if (amt >= 5000) {
                return amt - 750;
            }
            return amt;
        };

        System.out.println(checkout(2000, festive));
        System.out.println(checkout(2000, flat100));
        System.out.println(checkout(6000, bigSpender));
        System.out.println(checkout(80, flat100));
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.function.Supplier;

public class Refs {
    static boolean isValidPin(String pin) {
        return pin.length() == 6 && pin.chars().allMatch(Character::isDigit);
    }

    public static void main(String[] args) {
        List<String> pins = new ArrayList<>(List.of("124001", "30200", "682001", "11OO01"));

        pins.removeIf(p -> !isValidPin(p));                 // lambda
        System.out.println(pins);

        pins.replaceAll(String::strip);                     // instance method of the element
        pins.forEach(System.out::println);                  // method of a particular object

        Function<String, Integer> parse = Integer::parseInt;  // static method
        System.out.println(parse.apply("411001") + 1);

        Supplier<List<String>> maker = ArrayList::new;      // constructor
        List<String> fresh = maker.get();
        fresh.add("new list");
        System.out.println(fresh);
    }
}