# Currying Function in Java Explained [Practical Examples]

## Introduction to Currying Function in Java

In Java, currying function is the mechanism of breaking down a multi-argument function to form the multiple functions with single arguments such that the output remains same. In other words, when we don't want to pass all the arguments to the function, we use currying. So, currying decomposes higher order functions into cascaded functions with one argument that return a function, except for the last cascade that returns the result of computation.

Hence, it simplifies the function call. The other advantage is that the currying function allows us to create more specialized function so as to allow code re-usability.

### Syntax

The syntax of apply function is as shown below. The apply function applies to the given argument t and returns the result.

``````apply(T t)
``````

## Examples demonstrating currying in Java

### Example 1 : Currying function to multiply two numbers

In this example, we are designing the curried function with two integer parameters to compute multiplication of two numbers. Here, we will use apply method to pass two parameters 10 and 20 to the curried function.

``````// Program to demonstrate the currying in Java
import java.util.function.Function;

// Main class
public class Main {
public static void main(String args[])
{
// Curried Function for Multiplying u & v
Function<Integer, Function<Integer, Integer> >
c = u -> v -> u * v;

// Calling Curried Function for Multiplying u & v
System.out.println("Product of 10 and 20 is "+ c.apply(10).apply(20));
}
}
``````

Output

`Product of 10 and 20 is 200`

### Example 2 : Currying function to concatenate the strings

In this example, we are designing the curried function with two string parameters to compute concatenation of two Strings. We will use apply method to concatenate the strings using the curried function.

``````// Program to demonstrate the currying in Java
import java.util.function.Function;

// Main class
public class Main {
public static void main(String args[])
{
// Curried Function for concatenating the strings
Function<String, Function<String, String> >
c = u -> v -> u + v;

// Calling Curried Function for concatenating the strings
System.out.println("Concate two string : "+ c.apply("Hello").apply("World"));
}
}
``````

Output

`Concate two string : HelloWorld`

### Example 3 : Currying function to evaluate the expression

In this example, we are designing the curried function with three integer parameters toย  evaluate the expression. We will use apply method to pass three parameters using the apply method and thereby evaluating the expression 2x+3y+5z to get its result.

``````// Program to demonstrate the currying in Java
import java.util.function.Function;

public class Main {
public static void main(String args[])
{

// Curried Function for Multiplying u & v
Function<Integer, Function<Integer, Function<Integer, Integer> > >
c = x -> y -> z-> 2*x + 3*y + 5*z;

// Calling Curried Function for Multiplying u & v
System.out.println("Evaluating 2x+3y+5z with x=10, y=20 and z=5 : "+ c.apply(10).apply(20).apply(5));
}
}
``````

Output

`Evaluating 2x+3y+5z with x=10, y=20 and z=5 : 105`

### Example 4 : Currying function using the values from the function call

In this example, we will call a function fun1, fun2 and fun3 to get three values to compute the value of expression. Thereafter, we will evaluate the expression 2x+3y+5z to get its result.

``````// Program to demonstrate the currying in Java
import java.util.function.Function;

public class Main {

public static int fun1()
{
return 10;
}
public static int  fun2()
{
return 20;
}
public static int fun3()
{
return 5;
}
public static void main(String args[])
{

// Curried Function for Multiplying u & v
Function<Integer, Function<Integer, Function<Integer, Integer> > >
c = x -> y -> z-> 2*x + 3*y + 5*z;

// Calling Curried Function for Multiplying u & v
System.out.println("Evaluating 2x+3y+5z with x=10, y=20 and z=5 : "+ c.apply(fun1()).apply(fun2()).apply(fun3()));
}
}
``````

Output

`Evaluating 2x+3y+5z with x=10, y=20 and z=5 : 105`

### Example 5 : Currying function computing simple interest using Class

In this example, we are having a class SI that has a class variable rate which sets the rate depending on the type of account. Thereafter, we have a function `getrate()` that returns the value of class variable rate.

In Main class we are scanning the principal amount and duration from the user. Thereafter, we will compute the simple interest using curried function and obtaining value from the `getrate()` method of the SI class. Hence, it shows the simple interest computed taking principal, rate and duration.

``````// Program to demonstrate the currying in Java
import java.util.function.Function;
import java.util.Scanner;
class SI{
double rate;
SI(String t)
{
if(t=="Savings")
this.rate=7.5f;
else
this.rate=3.5f;
}
public double getrate()
{
return this.rate;
}
}
public class Main {

public static void main(String args[])
{
// Creating object of SI class to get the rate of interest
// Here we will get the rate for savings account
SI o=new SI("Savings");

// Curried Function for computing simple interest
Function<Double, Function<Double, Function<Double, Double> > >
c = x -> y -> z-> (x*y*z)/100.0;

// Getting principal and number of years from the user
Scanner sc=new Scanner(System.in);
double p=sc.nextFloat();
System.out.println("Enter the duration of deposit in Years");
double n=sc.nextFloat();

// Calling Curried Function for computing simple interest
System.out.println("Simple Interest on principal "+p+" with rate "+o.getrate()+" for "+n+" years will be "+ c.apply(p).apply(o.getrate()).apply(n));
}
}
``````

Output

```Enter your principal amount
1000
Enter the duration of deposit in Years
2.5
Simple Interest on principal 1000.0 with rate 7.5 for 2.5 years will be 187.5```

### Example 6 : Currying function computing student score using class

In this example, We will take a class Student that sets the sport marks of student based on the total marks of the student. Thereafter it computes the final score using currying function in a Main class. The equation used to compute the score is `score=total+sport*25`.

``````// Program to demonstrate the currying in Java
import java.util.function.Function;
import java.util.Scanner;
class Student{
int sport;
Student(int total)
{
if(total >210)
this.sport=5;
else if(total > 180)
this.sport=3;
else
this.sport=0;
}
public int getsport()
{
return this.sport;
}
}
public class Main {

public static void main(String args[])
{
// Getting marks of 3 subjects for a student
Scanner sc=new Scanner(System.in);
System.out.println("Enter marks of three subjects ");
int a=sc.nextInt();
int b=sc.nextInt();
int c=sc.nextInt();
int t=a+b+c;

// Creating object of Student class to get the sport marks on the basis of total marks
// Here we will get the rate for savings account
Student o=new Student(t);

// Curried Function for computing score
Function<Integer, Function<Integer, Integer> >
s = x -> y -> x + y * 25;

// Calling Curried Function for computing score
System.out.println("Total of 3 subjects will be "+t+". Sports marks will be "+o.getsport()+". So final result will be "+ s.apply(t).apply(o.getsport()));
}
}
``````

Output

```Enter marks of three subjects
60
70
65
Total of 3 subjects will be 195. Sports marks will be 3. So final result will be 270```

## Summary

The knowledge of currying functions in Java is very useful while working on real time applications. In this tutorial, we covered the different scenario to use function currying in java with an example. As per the requirement of an application, we can choose an appropriate approach for currying. We learned in detail about currying with an example.

All in all, this tutorial, covers everything that you need to know in order to have a clear view on currying function in Java.

## References

Function Interface

Views: 27

He is the founder of GoLinuxCloud and brings over a decade of expertise in Linux, Python, Go, Laravel, DevOps, Kubernetes, Git, Shell scripting, OpenShift, AWS, Networking, and Security. With extensive experience, he excels in various domains, from development to DevOps, Networking, and Security, ensuring robust and efficient solutions for diverse projects. You can connect with him on his LinkedIn profile.

Can't find what you're searching for? Let us assist you.

Enter your query below, and we'll provide instant results tailored to your needs.

If my articles on GoLinuxCloud has helped you, kindly consider buying me a coffee as a token of appreciation.

For any other feedbacks or questions you can send mail to admin@golinuxcloud.com