Function currying is a concept that decomposes a function with multiple parameters into multiple functions with a single parameter, so that the output is the same. In other words, it is a technique that simplifies a multi-value parameter function into a single-value parameter multi-function function.

Currying is a functional programming technique that transforms a function that takes multiple arguments into a series of functions that each take a single argument. Currying is a way to simplify complex functions and create more flexible code. In Java, currying can be achieved through the use of lambda expressions.

Here's an example of a curried function in Java: 

Function<Integer, Function<Integer, Integer>> add = x -> y -> x + y;

This function takes an integer argument x and returns another function that takes an integer argument y and returns the sum of x and y. This function can be called in two ways: 

add.apply(2).apply(3); // returns 5

or 

Function<Integer, Integer> add2 = add.apply(2);
add2.apply(3); // returns 5

In the first example, we call add with the argument 2, which returns a new function that takes an integer argument y. We then call that function with the argument 3, which returns the result 5.

In the second example, we use partial application to create a new function add2 that takes a single argument y and adds it to 2. We then call add2 with the argument 3, which also returns the result 5.

Currying allows for more flexible code, as functions can be partially applied and composed to create new functions. It is a powerful technique for simplifying complex functions and creating more reusable code.