Lambda Expressions In Java
A discussion of Java Lambda is presented in an attempt to satisfy the reader’s curiosity for knowledge.
Java Lambda Expressions
In terms of Java Lambda, Java 8 introduced Lambda Expressions.
Java Lambda expressions are short blocks of code that take parameters and return values. In contrast to methods, lambda expressions don’t require a name and can be included in a method’s body.
Syntax
In its simplest form, lambda expressions have one parameter and an expression:
parameter -> expression
You can use more than one parameter by wrapping them in parentheses:
(parameter1, parameter2) -> expression
There is a limit to expressions. In addition to returning a value immediately, they cannot contain variables, assignments, or if condition or for loop statements.
Code blocks can be enclosed in curly braces {} to carry out more complex operations. The code block should include a return statement if the lambda expression returns a value.
(parameter1, parameter2) -> { code block }
Lambda Expressions Examples
When it comes to Java Lambda, lambda expressions are mostly passed as parameters:
Use a Lambda expression in the LinkedList‘s forEach() method to print 5 prime numbers from the list:
import java.util.LinkedList;
public class Main {
public static void main(String[] args) {LinkedList prime_numbers=new LinkedList();prime_numbers.add(2);
prime_numbers.add(3);
prime_numbers.add(5);
prime_numbers.add(7);
prime_numbers.add(11);prime_numbers.forEach( (mrx) -> {
System.out.println(mrx);
});
}
}
Correspondingly, to examine the use of Lambda follow the example below:
import java.util.HashSet;
public class Main {
public static void main(String[] args) {HashSet identity_Documents=new HashSet();identity_Documents.add("State identification (ID) card");
identity_Documents.add("Driver license");
identity_Documents.add("US passport");
identity_Documents.add("Permanent Resident Card");System.out.println("Basic Verification documents in America: \n");
identity_Documents.forEach( (ample) -> {
System.out.println(ample);
});
}
}
If the variable’s type is an interface with only one method, lambda expressions can be stored in them.
There should be the same number of parameters and return type for the lambda expression as there is for the method.
In Java, many of these types of interfaces are built in, such as the Consumer interface in the java.util package.
You can store lambda expressions in variables using Java’s Consumer interface:
import java.util.LinkedList;
import java.util.function.Consumer;
public class Main {
public static void main(String[] args) {LinkedList coordinating_Conjunctions=new LinkedList<>();coordinating_Conjunctions.add("for");
coordinating_Conjunctions.add("and");
coordinating_Conjunctions.add("but");
coordinating_Conjunctions.add("yet");
coordinating_Conjunctions.add("or");System.out.println("The Conjunctions of the English Language is: \n");Consumer conjunctions=(ample) -> { System.out.println(ample); };
coordinating_Conjunctions.forEach(conjunctions);
}
}
Another Approach:
import java.util.LinkedList;
import java.util.function.Consumer;
public class Main {
public static void main(String[] args) {LinkedList bool_values=new LinkedList();bool_values.add(true);
bool_values.add(false);System.out.println("Following are the Boolean values: \n");Consumer booleans=(mrx) -> { System.out.println(mrx); };
bool_values.forEach(booleans);
}
}
It is necessary to have a parameter with a single-method interface as its type for a lambda expression to work in a method. The lambda expression will be executed if you call the interface’s method.
Make a method that accepts a lambda expression as a parameter:
interface StringFunction {
String run(String mrx);
}public class Main {
public static void main(String[] args) {
StringFunction exclaim = (string) -> string + "!";
StringFunction ask = (string2) -> string2 + "?";
mrx_Print("Welcome", exclaim);
mrx_Print("Are you enjoying learning Lambda Expressions", ask);
}
public static void mrx_Print(String mrx, StringFunction formatting) {
String ample_Result = formatting.run(mrx);
System.out.println(ample_Result);
}
}
interface English_Language_Punctuation {
String run(String ample);
}public class Main {
public static void main(String[] args) {
English_Language_Punctuation exclamation_mark = (mrx) -> mrx + "!";
English_Language_Punctuation question_mark = (mrx) -> mrx + "?";
English_Language_Punctuation full_stop = (mrx) -> mrx + ".";
English_Language_Punctuation comma = (mrx) -> mrx + ",";
English_Language_Punctuation hyphen = (mrx) -> mrx + "/";
English_Language_Punctuation quotation_mark = (mrx) -> mrx + "" "";mrx_Print("\nGreetings",exclamation_mark);
mrx_Print("\nHow are you",question_mark);
mrx_Print("\nI hope that after reading this article, you have gathered good concepts regarding Java Lambda",full_stop);
mrx_Print("\nWe have tried our level best to fulfill the Reader",comma);
System.out.println("\nThere are some: ");
mrx_Print("\n1)Examples",hyphen);
System.out.println("2)Theoretical Concepts for you on this page.");
mrx_Print("\nAs this line we have learnt how to Implement the quotation marks such as ",quotation_mark);}
public static void mrx_Print(String mrx, English_Language_Punctuation formatting_punctuation) {
String ample_Result = formatting_punctuation.run(mrx);
System.out.println(ample_Result);
}
}
