In Java, Functional Interface and Lambda Expressions are features introduced in Java 8 that

support functional programming.

✅ Functional Interface

A Functional Interface is an interface that has only one abstract method (but it can have
multiple default or static methods).
It can be used as the target for a lambda expression or method reference.

🔹 Example of a Functional Interface:

@FunctionalInterface
interface MyFunctionalInterface {
void sayHello(); // only one abstract method
}

✅ Lambda Expression

A Lambda Expression provides a clear and concise way to implement the abstract method of a
functional interface.
Syntax:

(parameters) -> { body }

🔹 Example using Lambda Expression:

public class LambdaDemo {

public static void main(String[] args) {
// Lambda expression to implement sayHello()
MyFunctionalInterface greet = () -> {
System.out.println("Hello from Lambda!");
};

// Call the method

greet.sayHello();
}
}

✅ Output:
Hello from Lambda!

🔍 Another Example: Functional Interface with Parameters

@FunctionalInterface
interface Calculator {
int operation(int a, int b);
}

public class LambdaCalculator {

public static void main(String[] args) {
// Lambda for addition
Calculator add = (a, b) -> a + b;

// Lambda for multiplication

Calculator multiply = (a, b) -> a * b;

System.out.println("Addition: " + add.operation(5, 3));

System.out.println("Multiplication: " + multiply.operation(5, 3));
}
}

✅ Output:
Addition: 8
Multiplication: 15

Java provides several built-in functional interfaces in the java.util.function package. Let's look at
two common ones:

✅ 1. Function<T, R>

Represents a function that takes one argument of type T and returns a result of type R.

🔹 Example:
import java.util.function.Function;

public class FunctionExample {

public static void main(String[] args) {
// Convert a string to its length
Function<String, Integer> stringLength = str -> str.length();

System.out.println("Length of 'Hello': " +

stringLength.apply("Hello"));
System.out.println("Length of 'Java': " + stringLength.apply("Java"));
}
}

✅ Output:
Length of 'Hello': 5
Length of 'Java': 4

Step-by-Step Explanation:

✅ import java.util.function.Function;

 This line imports the Function interface from the java.util.function package.
 Function<T, R> is a generic functional interface which takes:
o T: Input type
o R: Return type
 It has one abstract method:

R apply(T t);

✅ public class FunctionExample { ... }

 This is the definition of a public class named FunctionExample.

 Java program execution starts from the main method of the class.

✅ Function<String, Integer> stringLength = str -> str.length();

This is the core of the program. Let's break it down:

Part Meaning

Function<String, You are creating a function that takes a String as input and returns an
Integer> Integer.

stringLength This is the name of the variable (a reference to the lambda function).

This is a lambda expression that implements the apply() method of the

str -> str.length() Function interface. It takes str as input and returns str.length() (the
number of characters in the string).

💡 This is the same as writing:

Function<String, Integer> stringLength = new Function<String, Integer>() {

public Integer apply(String str) {
return str.length();
 }
};

But with a lambda expression, it’s shorter and more readable.

✅ stringLength.apply("Hello")

 Calls the apply method of the Function interface.

 Input: "Hello" → Output: 5 (because "Hello" has 5 characters)

✅ System.out.println(...)

Prints the result to the console:

Length of 'Hello': 5
Length of 'Java': 4

✅ Final Output:
Length of 'Hello': 5
Length of 'Java': 4

🎯 Summary

 Function<T, R> is a built-in functional interface to transform data from one type to another.
 Lambda expressions simplify implementing functional interfaces.
 In this example, the string's length is calculated and printed using Function<String,
Integer>.

✅ 2. Predicate<T>

Represents a boolean-valued function of one argument (returns true or false).

🔹 Example:
import java.util.function.Predicate;

public class PredicateExample {

 public static void main(String[] args) {
// Check if a number is even
Predicate<Integer> isEven = num -> num % 2 == 0;

System.out.println("Is 4 even? " + isEven.test(4));

System.out.println("Is 7 even? " + isEven.test(7));
}
}

✅ Output:
Is 4 even? true
Is 7 even? False

This Java program demonstrates the use of the Predicate functional interface from the
java.util.function package. Let's break it down:

🔹 What is a Predicate?

A Predicate<T> is a functional interface that represents a boolean-valued function of one

argument of type T.

 It has a single method: boolean test(T t);

 It is typically used for evaluating conditions.

🔹 Code Explanation
import java.util.function.Predicate;

 This imports the Predicate interface.

public class PredicateExample {

public static void main(String[] args) {

 A standard Java class with the main method (entry point).

// Check if a number is even

Predicate<Integer> isEven = num -> num % 2 == 0;

 A Predicate<Integer> is defined using a lambda expression.

 num -> num % 2 == 0 means: for a given number, return true if it is divisible by 2 (i.e.,
even), otherwise return false.

System.out.println("Is 4 even? " + isEven.test(4));

 System.out.println("Is 7 even? " + isEven.test(7));

 isEven.test(4) checks if 4 is even → prints true.

 isEven.test(7) checks if 7 is even → prints false.

🔹 Output
Is 4 even? true
Is 7 even? false

NOTE:----These built-in interfaces save you from having to define your own interfaces for common
tasks.

quick summary of the most commonly used built-in functional interfaces in Java (from
java.util.function package):

✅ Core Functional Interfaces in Java 8+

Interface Parameters Returns Description

Function<T, R> T R Takes one argument and returns a result.
Predicate<T> T boolean Returns true or false for the given input.
Consumer<T> T void Performs an action (side-effect), no return.
Supplier<T> none T Supplies a result, no input parameter.
UnaryOperator<T> T T A Function where input and output are same type.
BinaryOperator<T> T, T T Takes two inputs of the same type and returns one.

🔹 Examples:

1. Consumer<T> – Print a string

import java.util.function.Consumer;

public class ConsumerExample {

public static void main(String[] args) {
Consumer<String> print = str -> System.out.println("Hello, " + str);
print.accept("World");
}
}

Output:
Hello, World

This Java program demonstrates the use of the Consumer<T> functional interface from the
java.util.function package. Let's break it down:

🔹 What is Consumer<T>?

 Consumer<T> is a functional interface that takes a single input argument and returns
no result.
 It's typically used to perform an action (like printing, logging, modifying) on an input.
 It has a single method:

void accept(T t);

🔹 Code Breakdown
import java.util.function.Consumer;

 Imports the Consumer interface.

public class ConsumerExample {

public static void main(String[] args) {

 Standard Java class and the main() method (program entry point).

Consumer<String> print = str -> System.out.println("Hello, " + str);

 This creates a Consumer<String> using a lambda expression.

 The lambda str -> System.out.println("Hello, " + str) means:
o Take a String input called str
o Print "Hello, " followed by that string

print.accept("World");

 Calls the accept() method with "World" as the argument.

 The lambda gets executed, printing:

Hello, World

🔹 Output
Hello, World
2. Supplier<T> – Provide a value

import java.util.function.Supplier;

public class SupplierExample {

public static void main(String[] args) {
Supplier<Double> randomSupplier = () -> Math.random();
System.out.println("Random number: " + randomSupplier.get());
}
}

Output (example):

Random number: 0.837152682

This program demonstrates the use of the Supplier<T> functional interface from the
java.util.function package.

🔹 What is Supplier<T>?

 Supplier<T> is a functional interface that supplies (provides) a result without taking

any input.
 It’s commonly used for generating values like IDs, timestamps, random numbers, etc.
 It has one method:

T get();

 T: The type of value returned by the supplier.

🔹 Code Explanation
import java.util.function.Supplier;

 Imports the Supplier interface.

public class SupplierExample {

public static void main(String[] args) {

 Main class and method.

Supplier<Double> randomSupplier = () -> Math.random();

  Creates a Supplier<Double> using a lambda expression.
 () -> Math.random() is the implementation of get(), which returns a random double
between 0.0 and 1.0.

System.out.println("Random number: " + randomSupplier.get());

 Calls the get() method to get the random value.

 Prints the random number.

🔹 Output (Example)
Random number: 0.7312538249035913

(The actual number will vary each time you run the program.)

🔚 Summary

Interface Method Purpose

Supplier<T> get() Supplies a value, no input needed

✅ In this program:

 Supplier<Double> supplies a random number using Math.random().

 get() is called to retrieve and print that number.

3. UnaryOperator<T> – Square a number

import java.util.function.UnaryOperator;

public class UnaryOperatorExample {

public static void main(String[] args) {
UnaryOperator<Integer> square = x -> x * x;
System.out.println("Square of 5: " + square.apply(5));
}
}

Output:

Square of 5: 25
This program demonstrates how to use the UnaryOperator<T> functional interface in Java to
square a number.

🔹 What is UnaryOperator<T>?

 UnaryOperator<T> is a specialized form of Function<T, R>, where:

o The input and output types are the same (T → T).
 It represents an operation on a single operand that returns a result of the same type.

✅ Method:

T apply(T t);

🔹 Code Explanation
import java.util.function.UnaryOperator;

 Imports the UnaryOperator interface from java.util.function.

public class UnaryOperatorExample {

public static void main(String[] args) {

 Defines the main class and method.

UnaryOperator<Integer> square = x -> x * x;

 A lambda expression that implements UnaryOperator<Integer>.

 It takes an Integer x and returns x * x.

System.out.println("Square of 5: " + square.apply(5));

 Calls the apply() method with input 5.

 The lambda calculates 5 * 5 = 25 and prints:

Square of 5: 25

🔹 Output
Square of 5: 25

🔚 Summary
 Interface Method Description
UnaryOperator<T> apply(T t) Takes one argument of type T, returns T

🔧 Use case:

 You use UnaryOperator when the input and output types are the same, like:
o Squaring a number
o Negating a value
o Converting strings to lowercase

In this example, it squares the number 5 using apply(5).

4. BinaryOperator<T> – Multiply two numbers

import java.util.function.BinaryOperator;

public class BinaryOperatorExample {

public static void main(String[] args) {
BinaryOperator<Integer> multiply = (a, b) -> a * b;
System.out.println("5 * 3 = " + multiply.apply(5, 3));
}
}

Output:

5 * 3 = 15

This program demonstrates how to use the BinaryOperator<T> functional interface in Java to
multiply two numbers.

🔹 What is BinaryOperator<T>?

 BinaryOperator<T> is a special form of BiFunction<T, T, T>, where:

o Both input arguments and the return type are of the same type.
 It's used for operations on two operands of the same type, producing a result of the
same type.

✅ Method:

T apply(T t1, T t2);

🔹 Code Explanation
import java.util.function.BinaryOperator;

 Imports the BinaryOperator interface.

public class BinaryOperatorExample {

public static void main(String[] args) {

 Starts the main class and method.

BinaryOperator<Integer> multiply = (a, b) -> a * b;

 A lambda expression implementing BinaryOperator<Integer>.

 Takes two integers a and b, returns their product a * b.

System.out.println("5 * 3 = " + multiply.apply(5, 3));

 Calls apply(5, 3), which evaluates 5 * 3 = 15.

 Prints: 5 * 3 = 15

🔹 Output
5 * 3 = 15

🔚 Summary

Interface Method Description

BinaryOperator<T> apply(T t1, T t2) Takes two inputs of type T, returns a result of T

✅ Use cases:

 Arithmetic operations: addition, multiplication, etc.

 String concatenation
 Combining values of the same type

In this example, it multiplies 5 and 3 using apply(5, 3).

4o