The explanation for this lambda expression

Question

I am creating a word comparison class and it will also take into account the occurrences of words. (This is Java)

This was my original method:

/** * @param map The map of words to search * @param num The number of words you want printed * @return list of words */ public static List<String> findMaxOccurrence(Map<String, Integer> map, int num) { List<WordComparable> l = new ArrayList<>(); for (Map.Entry<String, Integer> entry : map.entrySet()) l.add(new WordComparable(entry.getKey(), entry.getValue())); 

My IDE suggested that the purpose of the loop and list could be replaced by a "collection call": "stream api calls"

In which he generated this code:

  List<WordComparable> l = map.entrySet().stream() .map(entry -> new WordComparable (entry.getKey(), entry.getValue())).collect(Collectors.toList()); 

I'm a little confused about how lambda math works. If my memory works correctly, → is for each cycle, but other calls are completely confusing.

My IDE can also extend the code in these two snippets:

  List<WordComparable> l = map.entrySet().stream() .map(entry -> { return new WordComparable (entry.getKey(), entry.getValue()); }).collect(Collectors.toList()); 

and

  List<WordComparable> l = map.entrySet().stream() .map(new Function<Map.Entry<String, Integer>, WordComparable>() { @Override public WordComparable apply(Map.Entry<String, Integer> entry) { return new WordComparable (entry.getKey(), entry.getValue()); } }).collect(Collectors.toList()); 

Any light emission would be amazing.

Answer 1

Let's take a closer look at the for loop to see how we can write functionally :

 List<WordComparable> l = new ArrayList<>(); for (Map.Entry<String, Integer> entry : map.entrySet()) l.add(new WordComparable(entry.getKey(), entry.getValue())); 

If we read this code in plain English, we can say "for each record of my card, to convert it to WordComparable and add it to the list."

Now we can rephrase this sentence "for each record of my map, let it convert it to WordComparable , and when we completely convert it, let me make a list from it."

Using this sentence, we see that we need to create a function: one that takes a map entry and converts it to WordComparable . So let it build! Java 8 introduces a new type called Function , which has one important method: apply . This method takes one input, converts it, and returns one output.

Writing good old Java, since Function is an interface, we can implement it to write our conversion code:

 public class EntryConverter implements Function<Map.Entry<String, Integer>, WordComparable> { public WordComparable apply(Map.Entry<String, Integer> entry) { return new WordComparable(entry.getKey(), entry.getValue()); } } 

Now that we have this converter, we need to use it for all records. Java 8 also introduces the concept of Stream , that is, a sequence of elements (note that this sequence can be infinite). Using this sequence, we can finally write into the code what we said earlier, i.e. "For each entry, convert it to WordComparable ." We use the map method, the purpose of which is to apply the method to each element of the stream.

We have a method: EntryConverter , and we build Stream our records using the Stream method.

So, we get:

 map.entrySet().stream().map(new EntryConverter()); 

The last part of the sentence remains: "make it a List ", i.e. collect all the items in a List . This is done using the collect method. This method takes a Collector as an argument, that is, an object that can reduce the flow in the final container. Java 8 comes with many ready-made collectors; one of which is Collectors.toList() .

Finally, we get:

 map.entrySet().stream().map(new EntryConverter()).collect(Collectors.toList()); 

Now, if we remove the temporary EntryConverter class and make it anonymous, we get what your IDE offers:

 List<WordComparable> l = map.entrySet() .stream() //make a Stream of our entries .map(new Function<Map.Entry<String, Integer>, WordComparable>() { @Override public WordComparable apply(Map.Entry<String, Integer> entry) { return new WordComparable(entry.getKey(), entry.getValue()); } }) //let convert each entry to a WordComparable .collect(Collectors.toList()); //and make a List out of it 

Now writing all this code is a bit cumbersome, especially declaring an anonymous class. Java 8 comes to the rescue with the new operator -> . This operator allows you to create Function much more painlessly than before: the left side corresponds to the argument of the function, and the right side corresponds to the result. This is called a lambda expression.

In our case, we get:

 entry -> new WordComparable(entry.getKey(), entry.getValue()) 

You can also write this lambda expression using the block body and the return statement:

 entry -> { return new WordComparable(entry.getKey(), entry.getValue()); } 

Notice how this corresponds to what we wrote earlier in EntryConverter .

This means that we can reorganize our code into:

 List<WordComparable> l = map.entrySet() .stream() .map(entry -> new WordComparable(entry.getKey(), entry.getValue())) .collect(Collectors.toList()); 

which is more readable and is what your IDE offers.

You can find more about lambda expressions on the Oracle website .

Answer 2

This is a lambda expression for Function . It takes an object and returns an object. In this case, it takes the value Map.Entry<String, Integer> and returns a WordComparable .

 entry -> new WordComparable(entry.getKey(), entry.getValue()) 

You can write the equivalent code manually:

 final class ConversionFunction implements Function<Map.Entry<String, Integer>, WordComparable> { @Override public WordComparable apply(Map.Entry<String, Integer> entry) { return new WordComparable(entry.getKey(), entry.getValue()); } } map.entrySet().stream().map(new ConversionFunction()).collect(...); 

The Stream.map() method accepts a Function that can be applied to each element ( Map.Entry ) in the stream and creates a stream of elements of a new type ( WordComparable ).

The Stream.collect() method uses Collector to compact all stream elements for a single object. Usually this is a collection, as here, but it may be some kind of aggregate function.

Answer 3

 List<WordComparable> l = map.entrySet().stream() .map(entry -> new WordComparable(entry.getKey(), entry.getValue())) .collect(Collectors.toList()); 

"->" is part of the lambda itself. In this fragment, .stream () is similar to a foreach loop, and then it starts a set of data processing directives (map, collect, etc.).

map means that you map each element of the current collection to some new collection with some rule:

 entry -> new WordComparable(entry.getKey(), entry.getValue()) 

your rule means that you use each element (with the nickname "entry") to create new elements for the collection of results (). then you must collect your items in the appropriate collection using a suitable collector.

Note: this collection applies to the result of map ().