Functional Interfaces in Java

@FunctionalInterface  
interface Sayable {  
    void say(String msg);  // abstract method
}  
public class Main implements Sayable {  
    public void say(String msg) {  
        System.out.println(msg);  
    }  
    // main method
    public static void main(String[] args) {  
        Main fie = new Main(); // object created 
        fie.say("Hello there");  
    }  
}  

@FunctionalInterface  
interface Sayable {  
    void say(String msg);   // only one abstract method  
    // It can contain any number of Object class methods.  
    int hashCode();  
    String toString();  
    boolean equals(Object obj);  
}  
public class Main implements interface Sayable {  {  
    public void say(String msg) {  
        System.out.println(msg);  
    }  
    // main method
    public static void main(String[] args) {  
        Main fie = new Main();  // object created
        fie.say("Hello there");  
    }  
}  

interface Sayable {  
    void say(String msg);   // abstract method  
}  
@FunctionalInterface  
interface Doable extends Sayable {  
    // Invalid '@FunctionalInterface' annotation; Doable is not a functional interface  
    void doIt();  // an abstract method
    // It has another abstract method, which is the say () method
    // present in the interface Sayable
}  
public class Main implements Doable {  
    public void say(String msg) {  
        System.out.println(msg);  
    } 
    
    public void doIt() {  
        System.out.println("In the doIt() method.");  
    } 
    // main method
    public static void main(String[] args) {  
        Main fie = new Main();  // object created
        fie.say("Hello there");  
        fie.doIt();  
    }  
}  

interface Doable {  
    default void doIt() {  
        System.out.println("Do it now");  
    }  
}  
@FunctionalInterface  
interface Sayable extends Doable {  
    void say(String msg);   // only one abstract method  
    // It will also have the doIt() method, but it is a default method. Hence, it works.
}  
public class Main implements Sayable {  
    public void say(String msg) {  
        System.out.println(msg);  
    }  
    public static void main(String[] args) {  
        Main fie = new Main();  // object created 
        fie.say("Hello there");  
        fie.doIt();  
    }  
}  

import java.util.function.Supplier; 
public class Main { 
    // main method
    public static void main(String[] args) 
    { 
        // Defining a Supplier that will take no arguments and will return a String 
        Supplier var = () -> "Good Morning from Supplier!"; 
        // Executing the supplier with the help of the get() method
        // This statement executes the lambda expression.
        System.out.println(var.get()); 
    } 
}

import java.util.function.Consumer;
public class Main {
    // main method
    public static void main(String[] args) {
        // Defining the Consumer for printing string
        Consumer cnsmr = c -> System.out.println(c);
        // Invoking the accept() method
        cnsmr.accept("Good Morning, Consumer!");
        // Defining a Consumer with a Method Reference
        Consumer mthdRefPrinter = System.out::println;
        mthdRefPrinter.accept("Good Morning Consumer method reference! ");
    }
}

import java.util.function.Predicate;
import java.util.ArrayList;
public class PredicateExample {
    public static void main(String[] args) {
        // creating an array list
        ArrayList al = new ArrayList();
        // adding elements to the array list
        al.add("India");
        al.add("America");
        al.add("Australia");
        al.add("Russia");
        al.add("Finland");
        // Defining a predicate that processes a string. 
        // checks if the string has more than 5 characters or not
        Predicate isLongerThan6 = s -> s.length() > 6;
        for(String str : al)     {
            // invoking the test() method, which in turn executes the
            // lambda expression written above
            System.out.println("Does the string '" + str + "' have more than six characters? " + isLongerThan6.test(str));    
        }
    }
}

import java.util.function.Function;
import java.util.ArrayList;
public class Main {
    // main method
    public static void main(String[] args) {
        // creating an array list
        ArrayList al = new ArrayList();
        // adding elements to the array list
        al.add("India");
        al.add("America");
        al.add("Australia");
        al.add("Russia");
        al.add("Finland");
        // Defining a Function that argument type is String, and return type is Integer 
        Function strLen = s -> s.length();
        // Invoking the apply() method
        for(String str : al)    {
            // invoking the apply() method, which in turn executes the
            // lambda expression written above
            System.out.println("The string '" + str + "' has " + strLen.apply(str) + " characters.");    
        }
    }
}

import java.util.function.UnaryOperator;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.List;
public class Main {
    // main method
    public static void main(String[] args) {
        List numberList = Arrays.asList(11, 12, 13, 14, 15, 16, 17, 18, 19, 20);
        // Inovking the method mathFun(). 
        List res = mathFun(numberList, y -> y * 3);
        System.out.println("The result is: ");
        for( int num : res)
            System.out.print(num + " "); 
    }
    // mathFun() is a static and generic method. It can handle data type of
    // type T. It will return a list of type T. The method takes two arguments
    // is the list and another is UnaryOperator.
    public static  List mathFun(List list, UnaryOperator unryOp) {
        List res = new ArrayList<>();
        for (T l : list) {
            // invokes the method apply(), which excutes the lambda expresssion
            // mentioned above.
            res.add(unryOp.apply(l));
        }
        return res;
    }
}

import java.util.function.BiFunction;
public class Main {
    // main method
    public static void main(String[] args) {
        // Here, BiFunction takes two integers and returns a String
        // After multiplication of x and y, it gets converted into a string 
        // as we are concatenating the result with ""
        BiFunction mul = (x, y) -> "" + (x * y);
        int no1 = 15;
        int no2 = 40;
        // invoking the method apply(), which in turn executes 
        // the lambda expression
        String res = mul.apply(no1, no2); 
        System.out.println("Multiplying numbers '" + no1 + "' and '" + no2 + "', result is: "+ res); 
        // BiFunction for adding two integers. 
        // Here, the first and the second argument both 
        // have type Integer, and the return type is also Integer
        BiFunction sum = (a, b) -> a + b;
        // Invoking the apply method to add two numbers by executing 
        // the lambda expression
        int output = sum.apply(no1, no2);
        System.out.println("Adding numbers '" + no1 + "' and '" + no2 + "', result is: "+ output);
    }
}

import java.util.function.BinaryOperator;
import java.util.List;
import java.util.Arrays;
public class Main {
    public static void main(String[] args) {        
        // array of integers
        Integer[] numArr = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
        // Invoking the method mathSum(). It has three arguments.
        // The lambda expression adds the two integers x and y
        Integer sum = mathSum(Arrays.asList(numArr), 0, (x, y) -> x + y);
        System.out.print("For the numbers: ");
        for( var k : numArr)      {
            System.out.print(k + " ");
        }
        System.out.println();
        System.out.println("The total is: " + sum); 
    }
    // mathSum() is a generic method. It has type T. 
    // Its first argument is a list of type T.
    // The second argument is a value init of type T.
    // The third argument is a BinaryOperator
    // In this program, T is of type Integer
    public static  T mathSum(List list, T init, BinaryOperator bo) {
        T res = init; //res is initialized with the value init
        // looping through the list
        for (T k : list) {
           // invoking the method apply(), which in turn executes the 
           // lambda expression to add two numbers res and k
           res = bo.apply(res, k);
        }
        return res;
    }
}