Functional Interface in Java: What You Need To Know

Hey there! If you‘re looking to level up your Java skills, you‘ve come to the right place. Today we‘re going to dive into the world of functional interfaces.

I know that sounds a bit intense, but stay with me! By the end, you‘ll have a solid grip on what functional interfaces are, why they matter, and how to use them.

Ready? Let‘s get started!

What is a Functional Interface?

First things first – what exactly is a functional interface?

Put simply, a functional interface is an interface in Java that contains only one abstract method.

For example:

@FunctionalInterface 
interface DoSomething {
    void doSomething(String text);
}

The DoSomething interface has a single method doSomething(). We can implement it using a lambda expression:

DoSomething printText = text -> System.out.println(text);

This lambda implements the functional interface, allowing us to treat it like any other interface instance. Pretty neat right?

Functional interfaces are annotated with @FunctionalInterface, although technically this isn‘t required. The annotation helps indicate intention and checks that the interface follows the rules.

Why Have Just One Abstract Method?

You might be wondering why having only one abstract method matters. The reason is it enables lambda expressions!

Lambda expressions (which we‘ll cover more in a bit) provide an easy way to implement a single method interface using concise, inline syntax.

So while typical Java interfaces contain multiple methods, functional interfaces are meant to represent just one specific action or function. This design consideration is central to their purpose.

Purpose of Functional Interfaces

Now you know what they are, but why do functional interfaces matter?

Functional interfaces and lambdas were added in Java 8. They allow us to incorporate some elements of functional programming into the language.

In particular, they enable writing:

• More concise code
• Code that focuses on "what" over "how"
• Reusable behavior that can be passed around

Let‘s compare some examples to see the benefits in action.

Concise Coding

Here is code to print each element of a list using an anonymous class:

List<String> names = Arrays.asList("Jim", "Kim");

names.forEach(new Consumer<String>() {
    @Override
    public void accept(String name) {
        System.out.println(name); 
    }
}); 

And here is the same logic implemented with a lambda expression:

List<String> names = Arrays.asList("Jim", "Kim");

names.forEach(name -> System.out.println(name)); 

The lambda syntax is much more compact! This makes code faster to implement and easier to read.

Separation of Behavior

Functional interfaces allow us to separate behavior from data:

List<String> names = Arrays.asList("Jim", "Kim");

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

// Data
names.forEach(printName);

We can define reusable behavior like printName independently from the data it operates on. This promotes loose coupling and modularity!

Passing Functions Around

Finally, treating functions as first-class values allows them to be passed freely:

void processNames(List<String> names, Consumer<String> action) {
    names.forEach(action);
}

We can call processNames, passing in any behavior we want!

processNames(names, name -> print("Name: " + name));
processNames(otherNames, name -> Database.save(name)); 

This makes it easy to reuse logic on new data sources.

So in summary:

✅ More concise, readable code
✅ Separation of behavior and data

✅ Reusable functions

Together this enables simple yet powerful coding practices!

Built-in Functional Interfaces

The java.util.function package contains many useful functional interfaces out of the box:

Interface	Function	Example
Predicate<T>	Evaluates a condition on T	Check if age > 18
Function<T, R>	Transforms T to R	Convert string to integer
Consumer<T>	Operates on T	Print, save to database
Supplier<T>	Generates T	Generate random number

These cover most common scenarios like filtering, mapping, performing actions, supplying data, etc. Let‘s walk through some examples.

Predicate for Evaluating

Predicates represent boolean functions that take in a generic type T:

Predicate<Integer> isPositive = num -> num > 0;

We can test values using .test():

System.out.println(isPositive.test(5)); // true
System.out.println(isPositive.test(-2)); // false

Predicates are often used for filtering:

List<Integer> nums = List.of(-5, 0, 5);
nums.stream().filter(isPositive).forEach(System.out::println); // 5

Which keeps only the positive numbers!

Function for Transforming

Functions take in one parameter and produce a result. For example:

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

int len = getLength.apply("Hello world"); // 11  

We pass the input string to apply(), which then returns its length.

Some common uses are mapping and formatting data:

List<String> words = List.of("Apple", "Banana");
List<Integer> lengths = words.stream()
                            .map(getLength)
                            .collect(Collectors.toList());

// [5, 6] 

The map() call transforms each string into its length.

Consumer for Operating

If you‘ve used forEach() on lists, you‘ve already seen Consumers in action! They represent functions that take in one argument and produce no return value.

Their focus is side effects – printing, logging, persisting data, etc.

Consumer<String> print = word -> System.out.println(word);
print.accept("Hello"); // Prints Hello

List<String> fruits = List.of("Apple", "Banana"); 
fruits.forEach(print); // Prints each fruit

A common use case is iterating over collections and performing batch operations: saving data to a database, writing to files, etc.

Supplier for Generating

Finally, Suppliers produce or generate values. Since they don‘t take in any parameters, they‘re useful for:

• Random number generation
• Reading data from configurations
• Initializing databases

For example:

Supplier<Double> rand = () Math.random();
System.out.println(rand.get()); // Prints random value

The .get() method retrieves the generated value.

We could use a supplier to populate test data:

Database db = DatabaseFactory.newInstance();
Supplier<String> uuid = () -> UUID.randomUUID().toString(); 

for (int i = 0; i < 100; i++) {
  db.save("Key " + i, uuid.get());  
}

This auto-generates unique IDs to store keys in the database.

Alright, hopefully you‘ve got a solid grip on built-in functional interfaces now! Let‘s recap the key takeaways so far:

Recap

We‘ve covered a lot of ground, so before proceeding let‘s recap what we‘ve learned:

✅ Functional interfaces have exactly one abstract method
✅ They enable lambda expressions in Java

✅ Functional interfaces help us write more concise, modular code by separating behavior from data
✅ Built-in interfaces cover common use cases like filter, map, consume data etc.
✅ Combined with lambdas and streams they enable a functional style of coding!

Next up, let‘s go deeper into lambda expressions and method references!

Lambda Expressions

Lambda expressions are a huge part of why functional interfaces matter. They provide compact syntax for writing functions on-the-fly, rather than having to define entire classes every time.

Here is the simplest syntax:

(params) -> expression

For example to multiply two numbers:

(x, y) -> x * y

And to check if a string is empty:

str -> str.isEmpty()  

We can assign these to functional interface variables:

MathOperation mult = (x, y) -> x * y; 
Predicate<String> isEmpty = str -> str.isEmpty();  

And then call them like regular methods!

mult.operation(4, 5); // 20

isEmpty.test(""); // true

The syntax also supports more complex logic with curly braces and multiple statements:

(str, caseSensitive) -> {
    if(caseSensitive) {
        // implementation
    } else {
        // implementation 
    }
};

Let‘s see a real example for formatting names:

Function<String, String> format = name -> {
    String formatted = name.toLowerCase().replace(" ", "_");  
    return formatted;
};

String formatted = format.apply("John Smith"); 
// john_smith

By treating functions as values that can be stored and passed around, lambdas enable reusable, modular code!

Method References

Method references are another neat language feature that pairs nicely with functional interfaces.

You use :: to reference existing methods directly instead of writing lambda bodies:

String::length; // Same as str -> str.length()  

Math::random; // Same as () -> Math.random()

This simplifies calling existing methods that match functional interface signatures:

Supplier<Double> rand = Math::random;
System.out.println(rand.get());  

Function<String, Integer> getLength = String::length;
int len = getLength.apply("Hello"); // 5

Method references help cut down repetitive lambda code. They form a natural pairing with functional interfaces!

Going Further

We‘ve covered the fundamentals, but there is much more we could explore!

Topics like composing multiple interfaces, default methods, and creating custom functional interfaces.

And using techniques like currying and memoization to take functionality even further.

But rather than overwhelm with too much information, I‘ll wrap up here for now. Let me know if you have any other questions!

I hope you‘ve enjoyed this introduction to functional interfaces. Thanks for sticking with me!

Talk soon,
[Your Name]

FAQs

Here are some common questions about functional interfaces:

Q: Is @FunctionalInterface mandatory?

A: Nope! It‘s optional. It‘s used to indicate intention that an interface should be a functional interface. It also checks that only one abstract method is declared.

Q: Can default methods be used?

A: Yes, functional interfaces can contain default methods as well as the single abstract method. Default methods enable interfaces to add functionality without breaking implementations.

Q: What methods can functional interfaces have?

A: Apart from the single abstract method, they can have default, static and object method (like toString()) declarations. However interfaces meant to act as functional interfaces should focus on only defining the core functional method.

I hope these FAQs cleared up some common questions! Let me know if you have any others.