28. Functional Programming in Java

28. Functional Programming in Java

Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids mutable states or data. With the introduction of Java 8 in 2014, the Java language began to incorporate aspects of this paradigm, which represented a significant change in the way developers could write code in Java.

Basic Concepts of Functional Programming

Before diving into how functional programming was integrated into Java, it is important to understand some basic concepts of this paradigm:

• Immutability: In functional programming, data is immutable. Once created, they cannot be changed. This helps avoid side effects and makes the program's behavior more predictable.
• First-Class Functions: Functions are treated as "first-class citizens", meaning they can be assigned to variables, passed as arguments, and returned by other functions.
• Pure Functions: These are functions that, for the same input arguments, will always return the same result and have no side effects (do not change external states).
• Lambda Expressions: A concise way to represent anonymous functions, which are functions without a name.
• High-Level Operations: Functional programming favors operations that work with high-level data structures, such as map, filter and reduce.

Java and Functional Programming

With the introduction of Java 8, several features were added to enable functional programming:

• Functional Interfaces: These are interfaces that contain only one abstract method. Examples include Runnable, Callable, Comparator and those introduced in the java.util.function package like Function , Predicate, Consumer and Supplier.
• Lambda Expressions: Allows you to write anonymous functions in a more concise and direct way, making it easier to pass behavior as an argument.
• Streams: An abstraction that allows processing sequences of elements in a declarative and often parallel way. Streams support operations such as map, filter, reduce, collect, among others.
• Method References: An even more concise way to express certain lambda expressions, directly referencing existing methods.
• Optional: A container that may or may not contain a value, used to represent optional values ​​without resorting to null.

Applying Functional Programming Concepts in Java

Let's explore how to apply some of these concepts in Java:

Immutability

To guarantee immutability, you can use classes that do not allow modification after the object has been created, such as the classes from the java.util.Collections package that are immutable or the String< class /code>. Additionally, you can create your own immutable classes where all fields are final and there are no setters.

new Thread(() -> System.out.println("Running in a thread")).start();

List myList = Arrays.asList("apple", "banana", "cherry", "date");
List filteredList = myList.stream()
                                  .filter(s -> s.startsWith("b"))
                                  .collect(Collectors.toList());

myList.forEach(System.out::println);

myList.forEach(s -> System.out.println(s));

Optional optionalValue = Optional.ofNullable(getStringValue());
optionalValue.ifPresent(System.out::println);