Functional programming is a programming paradigm that is based on the principles of mathematical functions and the evaluation of expressions. In functional programming, programs are composed of pure functions that take input values and return output values, without mutating state or causing side effects.

Java is a popular programming language that supports functional programming, providing a number of features and libraries that allow developers to write functional code. Some of the key features of functional programming in Java include:

Lambda expression

Lambda expressions - Lambda expressions are a way of defining anonymous functions that can be passed as arguments to other functions, or stored in variables. They are defined using the (args) -> { body } syntax, and can be used to implement functional interfaces, such as java.util.function.Function or java.util.function.Consumer. For example:

1
2
3
4
5
6
7
8

// Define a lambda expression that takes a string and returns its length
Function<String, Integer> lengthFunc = (s) -> s.length();

// Use the lambda expression to calculate the length of a string
int length = lengthFunc.apply("Hello, world!");

// Outputs: 13
System.out.println(length);

Method reference

Method references - Method references are a way of referring to existing methods by name, without having to define a lambda expression for them. They are defined using the Class::method syntax, and can be used to implement functional interfaces, such as java.util.function.Function or java.util.function.Consumer. For example:

1
2
3
4
5
6
7
8

// Define a method reference that refers to the length() method of the String class
Function<String, Integer> lengthFunc = String::length;

// Use the method reference to calculate the length of a string
int length = lengthFunc.apply("Hello, world!");

// Outputs: 13
System.out.println(length);

Functional interface

Functional interfaces are a core concept in Java functional programming. A functional interface is an interface that has exactly one abstract method, which is known as the functional method of the interface. Functional interfaces can be implemented using lambda expressions, method references, or anonymous classes.

Here is an example of how to define and use a functional interface:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// Define a functional interface that has a single abstract method called apply()
@FunctionalInterface
interface Function<T, R> {
    R apply(T t);
}

// Implement the functional interface using a lambda expression
Function<String, Integer> lengthFunc = (s) -> s.length();

// Use the functional interface to calculate the length of a string
int length = lengthFunc.apply("Hello, world!");

// Outputs: 13
System.out.println(length);

In this example, the Function interface is defined using the @FunctionalInterface annotation, which indicates that the interface has exactly one abstract method. The Function interface has two type parameters, T and R, which represent the type of the input and output of the apply method, respectively.

The Function interface is then implemented using a lambda expression, which is defined as (s) -> s.length(). This lambda expression takes a string s as an argument and returns its length s.length().

Finally, the Function interface is used to calculate the length of a string by calling its apply method with the string as an argument. The result of the apply method is then stored in the length variable, and printed to the console.

Overall, functional interfaces are a powerful and flexible way of defining and implementing abstractions in Java functional programming. They allow developers to define single-method interfaces that can be implemented using lambda expressions, method references, or anonymous classes, and to use those interfaces to define and manipulate data in a functional style.

Stream API

The Java Stream API is a powerful and flexible way of representing and manipulating collections of data in a functional style. It allows developers to apply a wide range of transformations and aggregations to streams of data, using a concise and expressive syntax.

Here is an example of how to use the Stream API in Java using lambda expressions, method references, and functional interfaces:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// Define a list of strings
List<String> words = Arrays.asList("hello", "world", "!");

// Use the stream API to convert the strings to uppercase,
// filter out the ones that are not alphabetic,
// and concatenate the remaining words into a single string

// Implement the Predicate functional interface using a lambda expression
Predicate<String> isAlphabetic = (s) -> s.chars().allMatch(Character::isAlphabetic);

// Use the lambda expression to filter the words
String result = words.stream()
    .filter(isAlphabetic)
    .map(String::toUpperCase)
    .reduce("", (x, y) -> x + " " + y);

// Outputs: "HELLO WORLD"
System.out.println(result);

In this example, the words list is first converted into a stream using the words.stream() method. The filter operation is then applied to the stream, using a lambda expression that implements the Predicate functional interface. The lambda expression is defined as (s) -> s.chars().allMatch(Character::isAlphabetic), which takes a string s as an argument and returns true if all of the characters in s are alphabetic, and false otherwise.

The map operation is then applied to the stream, using a method reference that refers to the toUpperCase() method of the String class. This operation converts all of the strings in the stream to uppercase.

Finally, the reduce operation is applied to the stream, using a lambda expression that concatenates the strings into a single string. The result of the reduce operation is then stored in the result variable, and printed to the console.

Overall, this example shows how the Java Stream API can be used with lambda expressions, method references, and functional interfaces to manipulate collections of data in a functional style. It demonstrates how these features can be combined to define and apply complex transformations and aggregations to streams of data in a concise and expressive way.