iskm/learnxinyminutes-docs
1
0
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-12-23 17:41:41 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[Java/en] Added Lambdas section.

Browse Source
This commit is contained in:
Shawn M. Hanes 2018-04-11 18:12:59 -04:00
parent a80844cac5
commit cc0329efbb
1 changed files with 82 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

140
java.html.markdown
View File

@ -11,7 +11,7 @@ contributors:
- ["Michael Dähnert", "https://github.com/JaXt0r"] - ["Michael Dähnert", "https://github.com/JaXt0r"]
- ["Rob Rose", "https://github.com/RobRoseKnows"] - ["Rob Rose", "https://github.com/RobRoseKnows"]
- ["Sean Nam", "https://github.com/seannam"] - ["Sean Nam", "https://github.com/seannam"]
- ["Shawn M. Hanes", "https://github.com/smhanes15"] - ["Shawn M. Hanes", "https://github.com/smhanes15"]
filename: LearnJava.java filename: LearnJava.java
--- ---
@ -879,87 +879,87 @@ import java.util.function.*;
import java.security.SecureRandom; import java.security.SecureRandom;
public class Lambdas { public class Lambdas {
public static void main(String[] args) { public static void main(String[] args) {
// Lambda declaration syntax: // Lambda declaration syntax:
// <zero or more parameters> -> <expression body or statement block> // <zero or more parameters> -> <expression body or statement block>
// We will use this hashmap in our examples below. // We will use this hashmap in our examples below.
Map<String, String> planets = new HashMap<>(); Map<String, String> planets = new HashMap<>();
planets.put("Mercury", "87.969"); planets.put("Mercury", "87.969");
planets.put("Venus", "224.7"); planets.put("Venus", "224.7");
planets.put("Earth", "365.2564"); planets.put("Earth", "365.2564");
planets.put("Mars", "687"); planets.put("Mars", "687");
planets.put("Jupiter", "4,332.59"); planets.put("Jupiter", "4,332.59");
planets.put("Saturn", "10,759"); planets.put("Saturn", "10,759");
planets.put("Uranus", "30,688.5"); planets.put("Uranus", "30,688.5");
planets.put("Neptune", "60,182"); planets.put("Neptune", "60,182");
// Lambda with zero parameters using the Supplier functional interface // Lambda with zero parameters using the Supplier functional interface
// from java.util.function.Supplier. The actual lambda expression is // from java.util.function.Supplier. The actual lambda expression is
// what comes after numPlanets =. // what comes after numPlanets =.
Supplier<String> numPlanets = () -> Integer.toString(planets.size()); Supplier<String> numPlanets = () -> Integer.toString(planets.size());
System.out.format("Number of Planets: %s\n\n", numPlanets.get()); System.out.format("Number of Planets: %s\n\n", numPlanets.get());
// Lambda with one parameter and using the Consumer functional interface // Lambda with one parameter and using the Consumer functional interface
// from java.util.function.Consumer. This is because planets is a Map, // from java.util.function.Consumer. This is because planets is a Map,
// which implements both Collection and Iterable. The forEach used here, // which implements both Collection and Iterable. The forEach used here,
// found in Iterable, applies the lambda expression to each member of // found in Iterable, applies the lambda expression to each member of
// the Collection. The default implementation of forEach behaves as if: // the Collection. The default implementation of forEach behaves as if:
/* /*
for (T t : this) for (T t : this)
action.accept(t); action.accept(t);
*/ */
// The actual lambda expression is the parameter passed to forEach. // The actual lambda expression is the parameter passed to forEach.
planets.keySet().forEach((p) -> System.out.format("%s\n", p)); planets.keySet().forEach((p) -> System.out.format("%s\n", p));
// If you are only passing a single argument, then the above can also be // If you are only passing a single argument, then the above can also be
// written as (note absent parentheses around p): // written as (note absent parentheses around p):
planets.keySet().forEach(p -> System.out.format("%s\n", p)); planets.keySet().forEach(p -> System.out.format("%s\n", p));
// Tracing the above, we see that planets is a HashMap, keySet() returns // Tracing the above, we see that planets is a HashMap, keySet() returns
// a Set of its keys, forEach applies each element as the lambda // a Set of its keys, forEach applies each element as the lambda
// expression of: (parameter p) -> System.out.format("%s\n", p). Each // expression of: (parameter p) -> System.out.format("%s\n", p). Each
// time, the element is said to be "consumed" and the statement(s) // time, the element is said to be "consumed" and the statement(s)
// referred to in the lambda body is applied. Remember the lambda body // referred to in the lambda body is applied. Remember the lambda body
// is what comes after the ->. // is what comes after the ->.
// The above without use of lambdas would look more traditionally like: // The above without use of lambdas would look more traditionally like:
for (String planet : planets.keySet()) { for (String planet : planets.keySet()) {
System.out.format("%s\n", planet); System.out.format("%s\n", planet);
} }
// This example differs from the above in that a different forEach // This example differs from the above in that a different forEach
// implementation is used: the forEach found in the HashMap class // implementation is used: the forEach found in the HashMap class
// implementing the Map interface. This forEach accepts a BiConsumer, // implementing the Map interface. This forEach accepts a BiConsumer,
// which generically speaking is a fancy way of saying it handles // which generically speaking is a fancy way of saying it handles
// the Set of each Key -> Value pairs. This default implementation // the Set of each Key -> Value pairs. This default implementation
// behaves as if: // behaves as if:
/* /*
for (Map.Entry<K, V> entry : map.entrySet()) for (Map.Entry<K, V> entry : map.entrySet())
action.accept(entry.getKey(), entry.getValue()); action.accept(entry.getKey(), entry.getValue());
*/ */
// The actual lambda expression is the parameter passed to forEach. // The actual lambda expression is the parameter passed to forEach.
String orbits = "%s orbits the Sun in %s Earth days.\n"; String orbits = "%s orbits the Sun in %s Earth days.\n";
planets.forEach((K, V) -> System.out.format(orbits, K, V)); planets.forEach((K, V) -> System.out.format(orbits, K, V));
// The above without use of lambdas would look more traditionally like: // The above without use of lambdas would look more traditionally like:
for (String planet : planets.keySet()) { for (String planet : planets.keySet()) {
System.out.format(orbits, planet, planets.get(planet)); System.out.format(orbits, planet, planets.get(planet));
} }
// Or, if following more closely the specification provided by the // Or, if following more closely the specification provided by the
// default implementation: // default implementation:
for (Map.Entry<String, String> planet : planets.entrySet()) { for (Map.Entry<String, String> planet : planets.entrySet()) {
System.out.format(orbits, planet.getKey(), planet.getValue()); System.out.format(orbits, planet.getKey(), planet.getValue());
} }
// These examples cover only the very basic use of lambdas. It might not // These examples cover only the very basic use of lambdas. It might not
// seem like much or even very useful, but remember that a lambda can be // seem like much or even very useful, but remember that a lambda can be
// created as an object that can later be passed as parameters to other // created as an object that can later be passed as parameters to other
// methods. // methods.
} }
} }
``` ```