Java lambda expression detailed and instance _java

Brief introduction

Lambda expressions are an important new feature in Java SE 8. Lambda expressions allow you to use expressions instead of functional interfaces. A lambda expression, like a method, provides a normal list of arguments and a body that uses those arguments (the bodies, which can be an expression or a block of code).

Lambda expressions also enhance the collection library. Java SE 8 adds 2 packages for bulk operations on collection data: Java.util.function packages and Java.util.stream packages. Flow (stream) is like an iterator (iterator), but many additional features are attached. In general, lambda expressions and stream are the biggest changes since the Java language adds generics (generics) and annotations (annotation). In this article, we'll see the toughness of lambda expressions and stream from simple to complex examples.

Environmental preparedness

If you have not installed Java 8, you should install it before you can use the lambda and stream (the translator recommends that you install it in a virtual machine, test it for use). Tools like NetBeans and IntelliJ idea and the IDE support Java 8 features, including lambda expressions, repeatable annotations, compact profiles, and other features.

Syntax for lambda expressions

Basic syntax:
(parameters)-> expression
Or
(parameters)->{statements;}

The following is a simple example of a Java lambda expression:

Copy Code code as follows:

1. No arguments required, the return value is 5
()-> 5

2. Receives a parameter (numeric type) that returns twice times the value of the
X-> 2 * x

3. Accept 2 parameters (numbers) and return their difference
(x, y)-> computes

4. Receives 2 int integers, returns their and
(int x, int y)-> x + y

5. Accepts a string object and prints it on the console without returning any values (looks like return void)
(String s)-> System.out.print (s)

The basic Lambda example

Now that we know what a lambda expression is, let's start with some basic examples. In this section, we'll see how lambda expressions affect how we encode. Assuming that there is a player list, programmers can use the For statement ("for Loop") to Traverse, in Java SE 8 can be converted to another form:

Copy Code code as follows:

string[] ATP = {"Rafael Nadal", "Novak Djokovic",
"Stanislas Wawrinka",
"David Ferrer", "Roger Federer",
"Andy Murray", "Tomas Berdych",
"Juan Martin Del Potro"};
List<string> players = Arrays.aslist (ATP);

The previous cycle mode
for (String player:players) {
System.out.print (player + ";");
}

Using lambda expressions and function operations (functional operation)
Players.foreach (player)-> System.out.print (player + ";");

Using the double colon operator in Java 8 (double colon operator)
Players.foreach (System.out::p rintln);

As you can see, lambda expressions reduce our code to one line. Another example is that in a graphical user interface program, an anonymous class can be substituted with a lambda expression. Similarly, you can use this when implementing the Runnable interface:

Copy Code code as follows:

Using anonymous inner classes
Btn.setonaction (New eventhandler<actionevent> () {
@Override
public void handle (ActionEvent event) {
System.out.println ("Hello world!");
}
});

or use lambda expression
Btn.setonaction (Event-> System.out.println ("Hello world!"));

The following is an example of using Lambdas to implement the Runnable interface:

Copy Code code as follows:

1.1 Using anonymous inner classes
New Thread (New Runnable () {
@Override
public void Run () {
System.out.println ("Hello world!");
}
). Start ();

1.2 Using lambda expression
New Thread (()-> System.out.println ("Hello world!"). Start ();

2.1 Using anonymous inner classes
Runnable Race1 = new Runnable () {
@Override
public void Run () {
System.out.println ("Hello world!");
}
};

2.2 Using lambda expression
Runnable Race2 = ()-> System.out.println ("Hello world!");

Call the Run method directly (no new threads open!)
Race1.run ();
Race2.run ();

Runnable lambda expression, using block format, to convert the five-element code into a single-line statement. Next, we'll sort the collection using Lambdas in the next section.

Using Lambdas to sort collections

In Java, the Comparator class is used to sort collections. In the following example, we will be based on the player's name, surname, name length, and the last letter. As in the previous example, the anonymous inner class is used first to sort, and then the lambda expression is used to streamline our code.
In the first example, we'll sort the list by name. Using the old way, the code looks like this:

Copy Code code as follows:

String[] players = {"Rafael Nadal", "Novak Djokovic",
"Stanislas Wawrinka", "David Ferrer",
"Roger Federer", "Andy Murray",
"Tomas Berdych", "Juan Martin Del Potro",
"Richard Gasquet", "John Isner"};

1.1 Using anonymous inner classes to sort by name players
Arrays.sort (Players, new comparator<string> () {
@Override
public int Compare (string s1, string s2) {
Return (S1.compareto (S2));
}
});

With Lambdas, you can implement the same functionality in the following code:

Copy Code code as follows:

1.2 Using lambda expression to sort players
Comparator<string> sortbyname = (string s1, string s2)-> (S1.compareto (S2));
Arrays.sort (players, sortbyname);

1.3 can also take the following form:
Arrays.sort (Players, (string s1, string s2)-> (S1.compareto (S2)));

The other sorts are shown below. As with the previous example, the code implements comparator by means of an anonymous inner class and some lambda expressions:

Copy Code code as follows:

1.1 Using anonymous inner classes to sort by surname players
Arrays.sort (Players, new comparator<string> () {
@Override
public int Compare (string s1, string s2) {
Return (s1.substring s1.indexof ("")). CompareTo (S2.substring (S2.indexof ("")));
}
});

1.2 Using lambda expression sort, according to surname
Comparator<string> sortbysurname = (string s1, string s2)->
(S1.substring (S1.indexof ("")). CompareTo (S2.substring (S2.indexof ("")));
Arrays.sort (players, sortbysurname);

1.3 Or so, doubt the original person is wrong, parentheses a lot ...
Arrays.sort (Players, (string s1, string s2)->
(S1.substring (S1.indexof ("")). CompareTo (S2.substring (S2.indexof ("")))
);

2.1 Using anonymous inner classes to sort by name lenght players
Arrays.sort (Players, new comparator<string> () {
@Override
public int Compare (string s1, string s2) {
Return (S1.length ()-s2.length ());
}
});

2.2 Using lambda expression sorting, according to name lenght
Comparator<string> sortbynamelenght = (string s1, string s2)-> (S1.length ()-s2.length ());
Arrays.sort (players, sortbynamelenght);

2.3 or this
Arrays.sort (Players, (string s1, string s2)-> (S1.length ()-s2.length ()));

3.1 Using anonymous inner class sort players, according to the last letter
Arrays.sort (Players, new comparator<string> () {
@Override
public int Compare (string s1, string s2) {
Return (S1.charat (S1.length ()-1)-S2.charat (S2.length ()-1));
}
});

3.2 Using a lambda expression sort, according to the last letter
Comparator<string> Sortbylastletter =
(string s1, string s2)->
(S1.charat (S1.length ()-1)-S2.charat (S2.length ()-1));
Arrays.sort (players, Sortbylastletter);

3.3 or this
Arrays.sort (Players, (string s1, string s2)-> (S1.charat (S1.length ()-1)-S2.charat (S2.length ()-1));

That's it, it's simple and intuitive. In the next section, we'll explore more lambdas capabilities and use them in conjunction with stream.

Using Lambdas and Streams

A stream is a wrapper over a collection, usually used with a lambda. Using Lambdas can support many operations, such as map, filter, limit, sorted, count, Min, max, sum, collect, and so on. Similarly, the stream uses lazy arithmetic, they don't really read all the data, and a method like GetFirst () ends the chain syntax. In the next example, we will explore what lambdas and streams can do. We created a person class and used this class to add some data to the list, which will be used for further flow operations. Person is just a simple Pojo class:

Copy Code code as follows:

public class Person {

Private String FirstName, lastName, job, gender;
private int salary, age;

Public person (string firstName, String lastName, String job,
String gender, int age, int salary) {
This.firstname = FirstName;
This.lastname = LastName;
This.gender = gender;
This.age = age;
This.job = job;
This.salary = salary;
}
Getter and Setter
// . . . . .
}

Next, we'll create two lists, all for the person object:

Copy Code code as follows:

list<person> javaprogrammers = new Arraylist<person> () {
{
Add (New Person ("Elsdon", "Jaycob", "Java programmer", "male", 43, 2000));
Add (New Person ("Tamsen", "Brittany", "Java programmer", "female", 23, 1500));
Add (New Person ("Floyd", "Donny", "Java programmer", "male", 33, 1800));
Add (New Person ("Sindy", "Jonie", "Java programmer", "female", 32, 1600));
Add (New Person ("Vere", "Hervey", "Java programmer", "male", 22, 1200));
Add (New Person ("Maude", "Jaimie", "Java programmer", "female", 27, 1900));
Add (New Person ("Shawn", "Randall", "Java programmer", "male", 30, 2300));
Add (New person ("Jayden", "Corrina", "Java programmer", "female", 35, 1700));
Add (New Person ("Palmer", "Dene", "Java programmer", "male", 33, 2000));
Add (New Person ("Addison", "Pam", "Java programmer", "female", 34, 1300));
}
};

list<person> phpprogrammers = new Arraylist<person> () {
{
Add (New Person ("Jarrod", "Pace", "PHP programmer", "male", 34, 1550));
Add (New Person ("Clarette", "Cicely", "PHP programmer", "female", 23, 1200));
Add (New Person ("Victor", "Channing", "PHP programmer", "male", 32, 1600));
Add (New Person ("Tori", "Sheryl", "PHP programmer", "female", 21, 1000));
Add (New Person ("Osborne", "Shad", "PHP programmer", "male", 32, 1100));
Add (New Person ("Rosalind", "Layla", "PHP programmer", "female", 25, 1300));
Add (New Person ("Fraser", "Hewie", "PHP programmer", "male", 36, 1100));
Add (New Person ("Quinn", "Tamara", "PHP programmer", "female", 21, 1000));
Add (New Person ("Alvin", "Lance", "PHP programmer", "male", 38, 1600));
Add (New Person ("Evonne", "Shari", "PHP programmer", "female", 40, 1800));
}
};

Now we use the Foreach method to iterate over the above list:

Copy Code code as follows:

System.out.println ("Name of all programmers:");
Javaprogrammers.foreach ((p)-> System.out.printf ("%s%s;", P.getfirstname (), P.getlastname ());
Phpprogrammers.foreach ((p)-> System.out.printf ("%s%s;", P.getfirstname (), P.getlastname ());

We also use the Foreach method to increase the programmer's pay by 5%:

Copy Code code as follows:

System.out.println ("Give the programmer a raise of 5%:");
consumer<person> giveraise = e-> e.setsalary (e.getsalary ()/MB * 5 + e.getsalary ());

Javaprogrammers.foreach (giveraise);
Phpprogrammers.foreach (giveraise);

Another useful method is filter filters (), which allows us to display a PHP programmer who earns more than 1400 dollars a month:

Copy Code code as follows:

System.out.println ("Below is a monthly salary more than $1,400 PHP Programmer:")
Phpprogrammers.stream ()
. Filter ((p)-> (P.getsalary () > 1400))
. ForEach ((p)-> System.out.printf ("%s%s;", P.getfirstname (), P.getlastname ());

We can also define filters and reuse them to do other things:

Copy Code code as follows:

Define Filters
predicate<person> agefilter = (p)-> (P.getage () > 25);
predicate<person> salaryfilter = (p)-> (P.getsalary () > 1400);
predicate<person> genderfilter = (p)-> ("Female". Equals (P.getgender ()));

System.out.println ("Below is a female PHP programmer who is older than 24 and has a monthly salary above $1,400:");
Phpprogrammers.stream ()
. Filter (Agefilter)
. Filter (Salaryfilter)
. Filter (Genderfilter)
. ForEach ((p)-> System.out.printf ("%s%s;", P.getfirstname (), P.getlastname ());

Reusing filters
System.out.println ("Older than 24-year-old female Java Programmers:");
Javaprogrammers.stream ()
. Filter (Agefilter)
. Filter (Genderfilter)
. ForEach ((p)-> System.out.printf ("%s%s;", P.getfirstname (), P.getlastname ());

You can limit the number of result sets by using the Limit method:

Copy Code code as follows:

System.out.println ("Front 3 Java Programmers:");
Javaprogrammers.stream ()
. Limit (3)
. ForEach ((p)-> System.out.printf ("%s%s;", P.getfirstname (), P.getlastname ());

System.out.println ("Front 3 female Java programmers:");
Javaprogrammers.stream ()
. Filter (Genderfilter)
. Limit (3)
. ForEach ((p)-> System.out.printf ("%s%s;", P.getfirstname (), P.getlastname ());

What sort? Can we handle it in the stream? The answer is yes. In the example below, we'll sort the Java programmers by name and salary, put them in a list, and then display the lists:

Copy Code code as follows:

System.out.println ("sorted by name and displaying the first 5 Java programmers:");
list<person> sortedjavaprogrammers = javaprogrammers
. Stream ()
. Sorted (p, p2)-> (P.getfirstname (). CompareTo (P2.getfirstname ()))
. Limit (5)
. Collect (ToList ());

Sortedjavaprogrammers.foreach ((p)-> System.out.printf ("%s%s; %n ", P.getfirstname (), P.getlastname ());

System.out.println ("Sort Java programmers according to salary:");
Sortedjavaprogrammers = Javaprogrammers
. Stream ()
. Sorted ((p, p2)-> (P.getsalary ()-p2.getsalary ())
. Collect (ToList ());

Sortedjavaprogrammers.foreach ((p)-> System.out.printf ("%s%s; %n ", P.getfirstname (), P.getlastname ());

If we are only interested in the lowest and highest salary, select the first/last one faster than the sort after the Min and Max methods:

Copy Code code as follows:

SYSTEM.OUT.PRINTLN ("lowest-paid Java programmer:");
Person pers = Javaprogrammers
. Stream ()
. Min ((p1, p2)-> (P1.getsalary ()-p2.getsalary ()))
. Get ()

System.out.printf ("Name:%s%s; Salary: $%,d. ", Pers.getfirstname (), Pers.getlastname (), Pers.getsalary ())

System.out.println ("The highest-paid Java programmer:");
Person person = Javaprogrammers
. Stream ()
. Max ((p, p2)-> (P.getsalary ()-p2.getsalary ())
. Get ()

System.out.printf ("Name:%s%s; Salary: $%,d. ", Person.getfirstname (), Person.getlastname (), Person.getsalary ())

In the example above we have seen how the Collect method works. Combining the map method, we can use the Collect method to place our result set in a string, a set, or a treeset:

Copy Code code as follows:

System.out.println ("Concatenation of the PHP programmers's name into a string:");
String phpdevelopers = phpprogrammers
. Stream ()
. Map (Person::getfirstname)
. Collect (Joining (";")); Can be used as a marker in further operations (token)

System.out.println ("Store the Java programmers's name to Set:");
set<string> Javadevfirstname = javaprogrammers
. Stream ()
. Map (Person::getfirstname)
. Collect (Toset ());

System.out.println ("Store the Java programmers's name in the TreeSet:");
treeset<string> Javadevlastname = javaprogrammers
. Stream ()
. Map (Person::getlastname)
. Collect (Tocollection (treeset::new));

Streams can also be parallel (parallel). Examples are as follows:

Copy Code code as follows:

System.out.println ("Calculate all money paid to the Java programmers:");
int totalsalary = Javaprogrammers
. Parallelstream ()
. Maptoint (P-> p.getsalary ())
. sum ();

We can use the Summarystatistics method to get the various rollup data for the elements in the stream. Next, we can access these methods, such as Getmax, Getmin, getsum or getaverage:

Copy Code code as follows:

Calculate count, Min, Max, sum, and average for numbers
list<integer> numbers = arrays.aslist (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Intsummarystatistics stats = Numbers
. Stream ()
. Maptoint ((x)-> x)
. Summarystatistics ();

System.out.println ("The largest number in the list:" + Stats.getmax ());
System.out.println ("The smallest number in the list:" + stats.getmin ());
System.out.println ("Sum of all numbers:" + stats.getsum ());
System.out.println ("Average of all numbers:" + stats.getaverage ());

OK, that's it, I hope you like it!

Summarize

In this article, we learned different ways to use lambda expressions, from basic examples to complex examples that use lambdas and streams. In addition, we learned how to sort the Java collection using lambda expressions and the comparator class.


Translator Note: While looking very advanced, the essence of a lambda expression is simply a "syntactic sugar", which is inferred by the compiler and helps you transform the code that is packaged as normal, so you can use less code to do the same thing. I suggest not to use, because this and some very advanced hackers write code, simple, difficult to understand, difficult to debug, maintenance staff want to dozens.