> ## Content Index
> Fetch the complete content index at: https://www.javahandbook.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# A Detailed Guide On Java Built-In Functional Interfaces
- URL: https://www.javahandbook.com/java-streams-api/a-detailed-guide-on-java-built-in-functional-interfaces/
- Published: 2026-02-15T09:00:51.000Z
- Updated: 2026-02-15T09:00:51.000Z
- Description: This lesson details about the various functional interfaces that fall under major 4 categories.
- Author: Gopi Gorantala
- Tags: #docs, #java-streams-api, Functional Interfaces

## Introduction

Java provides a lot of predefined functional interfaces for us to use.

The new [Function](https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html?ref=javahandbook.com) API introduced in Java SE 8 defines several built-in functional interfaces, providing target types for lambda expressions and method references.

So if we break down all the interfaces we were given in the functions package, they are packed into 4 types, and all of them are either of the four interfaces we are discussing.

1. Consumer
2. Supplier
3. Function
4. Predicate

## Sketch

![](https://storage.ghost.io/c/00/01/0001b1c8-8c52-4cdb-b3c7-c0746bea790e/content/images/2026/02/image-5.png)

## Types of Functional Interfaces

As per the sketch above, let us talk in detail about these functional interfaces.

### 1\. Consumer interface

The `Consumer` interface in Java is a functional interface that takes a single argument of a specified type and returns no result. Its functional method is called `accept()`. Here is the syntax for the Consumer interface:

```java
@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}
```

In this example, `T` a type parameter represents the type of argument that the `Consumer` will accept. The `@FunctionalInterface` annotation is optional but often indicates that the interface is intended to be a functional interface.

To use the `Consumer` interface, you can create an instance of it and pass it as an argument to a method that expects a `Consumer`.

An example is shown below:

```java
List<String> names = Arrays.asList("John", "Jane", "Bob");

Consumer<String> printName = name -> System.out.println(name);

names.forEach(printName);

```

In this example, a `Consumer` instance called `printName` is created using a lambda expression that takes a `String` argument and prints it to the console. The `forEach()` method of the `List` class is called with `printName` as an argument, causing it to be executed for each element in the list. As a result, the names "John", "Jane", and "Bob" are printed to the console.

The `Consumer` interface is commonly used in scenarios where you must act on each collection element, such as printing, logging, or processing the elements.

### 2\. Supplier Interface

The `Supplier` interface in Java is a functional interface that takes no arguments and returns a specified type value. Its functional method is called `get()`. This is opposite to `Consumer` Interface.

Here is the syntax for the `Supplier` interface:

```java
@FunctionalInterface
public interface Supplier<T> {
    T get();
}
```

In this example, `T` is a type parameter that represents the type of value that the `Supplier` will return. The `@FunctionalInterface` annotation is optional but is often used to indicate that the interface is intended to be a functional interface.

To use the `Supplier` interface, you can create an instance of it and call its `get()` method to obtain a value. Here is an example:

```java
Supplier<Integer> randomNumberSupplier = () -> (int) (Math.random() * 100);

int randomNumber = randomNumberSupplier.get();

System.out.println("Random number: " + randomNumber);
```

In this example, a `Supplier` instance called `randomNumberSupplier` is created using a lambda expression that generates a random integer between `0` and `100`. The `get()` method of `Supplier` is then called to obtain a random number printed to the console.

The `Supplier` interface is commonly used when generating or supplying values on demand, such as when initializing objects or populating collections.

### 3\. Function Interface

The `Function` interface in Java is a functional interface that takes a single argument of a specified type and returns a value of a different type. Its functional method is called `apply()`.

Here is an example of using the `Function` interface:

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

int length = stringLength.apply("hello");

System.out.println("Length of string: " + length);
```

In this example, a `Function` instance called `stringLength` is created using a lambda expression that takes a `String` argument and returns its length as an `Integer`. The `apply()` method of the Function is then called with the string "hello" as an argument, which returns the length of the string (which is 5). The length is then printed to the console.

The `Function` interface is commonly used in scenarios where you need to transform or convert values, such as when processing data or performing calculations. Another example of using the `Function` interface is to convert a string to an integer, like this:

```java
Function<String, Integer> stringToInt = str -> Integer.parseInt(str);

int num = stringToInt.apply("42");

System.out.println("Number: " + num);
```

In this example, a `Function` instance called `stringToInt` is created using a lambda expression that takes a `String` argument and converts it to an `Integer`. The `apply()` method of the `Function` is then called with the string "42" as an argument, which returns the integer value 42\. The integer is then printed to the console.

### 4\. Predicate Interface

The `Predicate` interface in Java is a functional interface that takes a single argument of a specified type and returns a boolean value. Its functional method is called `test()`. Here is an example of using the `Predicate` interface:

> `Predicate` takes an object/variable and checks to see if that satisfies some criteria. Most of the time we use this in filtering data.

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

boolean result1 = isEven.test(4); // returns true
boolean result2 = isEven.test(7); // returns false

System.out.println("Result1: " + result1);
System.out.println("Result2: " + result2);

```

In this example, a `Predicate` instance called `isEven` is created using a lambda expression that takes an `Integer` argument and checks whether it is even (by checking whether the remainder after division by 2 is 0). The `test()` method of the `Predicate` is then called with the integers 4 and 7 as arguments, which return `true` and `false` respectively. The results are then printed to the console.

The `Predicate` interface is commonly used in scenarios where you must test or filter values based on some condition, such as when searching or sorting data. Another example of using the `Predicate` interface is to check if a string is longer than a certain length, like this:

```java
Predicate<String> isLongerThan5 = str -> str.length() > 5;

boolean result3 = isLongerThan5.test("hello"); // returns false
boolean result4 = isLongerThan5.test("goodbye"); // returns true

System.out.println("Result3: " + result3);
System.out.println("Result4: " + result4);
```

In this example, a `Predicate` instance called `isLongerThan5` is created using a lambda expression that takes a `String` argument and checks whether its length is greater than 5\. The `test()` method of the `Predicate` is then called with the strings "hello" and "goodbye" as arguments, which return `false` and `true` respectively. The results are then printed to the console.

## Next Up?

You will learn each in detail in the next lessons with examples and explanations.