Functional Programming in Java

Introduction to Functional Programming in Java

Java functional programming comes into existence after Java 8^th version onwards. Functional programming means a fundamental change in the approach to problem-solving. Functional programming allows programming with expressions (declaring functions), passing functions as arguments, and using functions as statements.

Types of Functional Programming

• Streams Functional Programming
• Lambda Expressions Functional Programming
• Method Reference Functional Programming

How does Functional programming work in Java?

Before we get into the functional programming concept, let’s see the difference between Functional and structured programming. Structured programming emphasizes logical structure or process, whereas Functional programming mainly focuses on data. Structured programming follows a top-down approach, whereas Functional programming follows from bottom to top.

Functional programming is separated into tiny run-time entities called objects, whereas structured programming separates small units or functions. Structured programming is less secure, whereas Functional programming is highly secure. Structured programming can’t handle complex problems, whereas Functional programming handles any level of a complex problem.

Examples of Functional Programming in Java

Given below are the examples mentioned:

Example #1: Streams Functional Programming

Syntax:

objectName.stream();

Code:

Animal.java

package com.streams;
public class Animal {
String name;
String color;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public Animal(String name, String color) {
super();
this.name = name;
this.color = color;
}
}

AnimalNames.java

package com.streams;//creating package
//importing required packages to the code
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class AnimalNames {
public static void main(String[] args) {
getMyDogNames();//calling the method
}
private static void getMyDogNames() {
Animal a1=new Animal("Puppy","black"); //creating a object for animal class
Animal a2=new Animal("Tommy","brown");//creating a object for animal class
Animal a3=new Animal("Zimmy","white");//creating a object for animal class
List<Animal> persons = Arrays.asList(a1,a2,a3); //passing object references to list
String dogName = persons.stream() //covert all elements into stream
.filter(name -> "Puppy".equals(name.getName()))//filtering given elements from persons class
.map(Animal::getName)     //persons elements iterate over map
.findAny()//find out the given element passed from filter
.orElse("");//
System.out.println("Dog Name :" + dogName); //print the dog name
List<String> collect = persons.stream()
.map(Animal::getName)
.collect(Collectors.toList());//collecting all names from list
System.out.println("All Dog names");
collect.forEach(System.out::println);//iterating collection with for each loop
}
}

Output:

Explanation:

• In the Java class, we are generating setters and getters.
• We write the main code for printing dog names in the Java class.
• In the code itself, mention each line’s purpose in the comment.
• If we write the same code in structured programming, we need to write more lines for each method like filter(), collector(), findAny(), map(), etc. So, most functional programming development is preferred over structured programming.

Example #2: Lambda Expressions

• A lambda expression is used to represent a method interface with an expression.
• It helps to iterate, filter and extract data from collections.
• Lambda expression interface implementation is a functional interface.
• It reduces a lot of code.
• A lambda expression is treated as a function, so the java compiler can’t create .class

Syntax:

(arguments) ->
{
//code for implementation
}
Arguments:  argument-list can be have values or no values
Example: arguments1, arguments2, arguments3,……
->: Joins code implementation and arguments.

a. Lambda expression with a single argument

Syntax:

(argument1) ->
{
//code for implementation
}

Example – AreaOfSquare.java

Code:

package com.lambda;//creating a package
interface Square{  //creating interface for quare
public int getArea(int side);  //create a method for get area
}
public class AreaOfSquare{  //As we are working with Lambda expression so no need to implement interface of square
public static void main(String[] args) {
Square area=(side)->{  // Lambda expression with only one argument.
Return side*side;  //returning area
};
System.out.println(“Area of Square=>”+area.getArea(10));   //printing area by calling interface getArea method
}
}

Output:

Explanation:

• The above created an interface Square and inside AreaOfSquare class written lambda expression.
• Within lambda expression, written logic for the area of a square.
• In the last line printed, the area of the square of 100 by calling the interface method getArea().

b.  Lambda expression without argument

Syntax:

() ->
{
//code for implementation
}

Example – MyNameString.java

Code:

package com.lambda;//creating a package
interface Name{  //creating interface for Name
public String getMyName();  //create a method for get name
}
public class MyNameString{  //As we are working with Lambda expression so no need to implement interface of Name
public static void main(String[] args) {
Name name=()->{  // Lambda expression with out argument.
return "Hi, Amardeep!"; //returning name
};
System.out.println(name.getMyName());   //printing name by calling interface getMyName method
}
}

Output:

Explanation:

• The above created an interface Name and inside MyNameString class written lambda expression without argument.
• Within lambda expression, written logic for return string.
• In the last line printed, the string is Hi, Amardeep! By calling the interface method getMyName().

Example #3: Method Reference

• Method reference is used to refer to a method of functional interface.
• It is one more easy form of a lambda expression.
• If you use lambda expression every time to point a method, we can use method reference in place of method reference.

Syntax:

Class-Name:: static method name

Example – StaticMethodReference.java

Code:

package method.reference;//creating package
interface RectangleArea{  //creating RectangleArea interface
public int getArea(int l,int b);  //creating method getArea in interface
}
public class StaticMethodReference {  //creating a classs
public static int showRectangleArea(int length, int breadth){  //creating method for getting rectangle area
return length*breadth;
}
public static void main(String[] args) {
// Referring static method
RectangleArea area = StaticMethodReference::showRectangleArea;  //calling class name with method name
// Calling interface method
int outArea=area.getArea(10,20);
System.out.println("Area of rectangle :"+outArea);//printing area
}
}

Output:

Explanation:

• The above created an interface Rectangle and inside StaticMethodReference class written static method reference code.
• Within the showRectangleArea() method, written logic for the area of a rectangle.
• The next line passed the static method reference to the RectangleArea interface reference.
• Next, line printing rectangle area by calling the getArea(10,20) method.
• Gives an output of 200.

Conclusion

Functional programming is achieved with streams, lambda expressions, and method references. It reduces lines of code and improves performance.

This is a guide to Functional Programming in Java. Here we discuss how does functional programming works in Java and appropriate examples. You may also have a look at the following articles to learn more –

1. Java Adapter Classes
2. Java Package
3. Functional Programming vs OOP
4. Java Stream Filter