Java had one big issue with anonymous classes: if the implementation of your anonymous class is very simple, such as an interface that contains only one method, then the syntax of anonymous classes may seem unwieldy and unclear.

In these cases, you're usually trying to pass functionality as an argument to another method, such as what action should be taken when someone clicks a button. Lambda expressions enable you to do this, to treat functionality as method argument, or code as data.

Let’s check the structure of lambda expressions.

• A lambda expression can have zero, one or more parameters.
• The type of the parameters can be explicitly declared or it can be inferred from the context. e.g. (int a) is same as just (a)
• Parameters are enclosed in parentheses and separated by commas. e.g. (a, b) or (int a, int b) or (String a, int b, float c)
• Empty parentheses are used to represent an empty set of parameters. e.g. () -> 42
  When there is a single parameter, if its type is inferred, it is not mandatory to use parentheses. e.g. a -> return a*a
• The body of the lambda expressions can contain zero, one or more statements.
• If body of lambda expression has single statement curly brackets are not mandatory and the return type of the anonymous function is the same as that of the body expression.
• When there is more than one statement in body than these must be enclosed in curly brackets (a code block) and the return type of the anonymous function is the same as the type of the value returned within the code block, or void if nothing is returned.