Functional Interface

@FunctionalInterfaceinterface GreetingService {    void sayHello(String msg);}public class Main {    public static void main(String[] args) {        GreetingService greetService = (message) -> {System.out.println("Hello " + message)};        greetService.sayHello("Efterklang");    }}

@FunctionalInterfaceinterface Message {    void send(String name);}// λ Expressionspublic class Main() {    public static void main(String[] args) {        Message message = (name) -> {            System.out.println("Sending email" + name);        };        message.send("Efterklang");    }}// Method References/** * In this example, System.out::println is a method reference that refers to the println method of the System.out object. * The method reference is equivalent to the lambda expression x -> System.out.println(x). * Here this reference acts as Consumer functional interface instance. * void java.lang.Iterable.forEach(Consumer<? super String> action)*/public class Main() {    public static void main(String[] args) {        List<String> list = Arrays.asList("Apple", "Banana", "Cherry");        list.forEach(System.out::println);    }}// Constructor Referencesclass Person {    private String name;    Person(String name) {        this.name = name;    }    String getName() {        return name;    }}@FunctionalInterfaceinterface PersonFactory {    Person create(String name);}PersonFactory factory = Person::new;Person person = factory.create("John");System.out.println(person.getName());  // Outputs: John

@FunctionalInterfacepublic interface Runnable {    /**     * Runs this operation.     */    void run();}@FunctionalInterfacepublic interface Callable<V> {    /**     * Computes a result, or throws an exception if unable to do so.     *     * @return computed result     * @throws Exception if unable to compute a result     */    V call() throws Exception;}@FunctionalInterfacepublic interface Comparable<T> {    public int compareTo(T o);}@FunctionalInterfacepublic interface Consumer<T> {    /**     * Performs this operation on the given argument.     *     * @param t the input argument     */    void accept(T t);    default Consumer<T> andThen(Consumer<? super T> after) {        Objects.requireNonNull(after);        return (T t) -> { accept(t); after.accept(t); };    }}

import java.util.Arrays;import java.util.Comparator;import java.util.List;class Student {    private String name;    private int age;    public Student(String name, int age) {        this.name = name;        this.age = age;    }    public String getName() {        return name;    }    public int getAge() {        return age;    }}public class Main {    public static void main(String[] args) {         List<Student> students = Arrays.asList(            new Student("John", 20),            new Student("Alice", 22),            new Student("Bob", 18)         );        //Here comparator is a functional interface(Comparator<Student>) instance        Comparator<Student> comparator = Comparator.comparing(Student::getAge);        students.stream().sorted(comparator);        students.forEach(student -> {            System.out.println(student.getName()+  "," + student.getAge());        });    }}