Merge pull request #1 from winterbe/master

jkrawczyk · web-flow · commit 679d5610715f · 2016-07-03T21:02:21.000+02:00
Sync with original repo
diff --git a/LICENSE b/LICENSE
@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2014 Benjamin Winterberg
+Copyright (c) 2016 Benjamin Winterberg
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.
diff --git a/README.md b/README.md
@@ -73,7 +73,7 @@ formula.calculate(100);     // 100.0
 formula.sqrt(16);           // 4.0
 ```
 
-The formula is implemented as an anonymous object. The code is quite verbose: 6 lines of code for such a simple calucation of `sqrt(a * 100)`. As we'll see in the next section, there's a much nicer way of implementing single method objects in Java 8.
+The formula is implemented as an anonymous object. The code is quite verbose: 6 lines of code for such a simple calculation of `sqrt(a * 100)`. As we'll see in the next section, there's a much nicer way of implementing single method objects in Java 8.
 
 
 ## Lambda expressions
@@ -107,7 +107,7 @@ As you can see the code is much shorter and easier to read. But it gets even sho
 Collections.sort(names, (String a, String b) -> b.compareTo(a));
 ```
 
-For one line method bodies you can skip both the braces `{}` and the `return` keyword. But it gets even more shorter:
+For one line method bodies you can skip both the braces `{}` and the `return` keyword. But it gets even shorter:
 
 ```java
 names.sort((a, b) -> b.compareTo(a));
@@ -118,7 +118,7 @@ List now has a `sort` method. Also the java compiler is aware of the parameter t
 
 ## Functional Interfaces
 
-How does lambda expressions fit into Javas type system? Each lambda corresponds to a given type, specified by an interface. A so called _functional interface_ must contain **exactly one abstract method** declaration. Each lambda expression of that type will be matched to this abstract method. Since default methods are not abstract you're free to add default methods to your functional interface.
+How does lambda expressions fit into Java's type system? Each lambda corresponds to a given type, specified by an interface. A so called _functional interface_ must contain **exactly one abstract method** declaration. Each lambda expression of that type will be matched to this abstract method. Since default methods are not abstract you're free to add default methods to your functional interface.
 
 We can use arbitrary interfaces as lambda expressions as long as the interface only contains one abstract method. To ensure that your interface meet the requirements, you should add the `@FunctionalInterface` annotation. The compiler is aware of this annotation and throws a compiler error as soon as you try to add a second abstract method declaration to the interface.
 
@@ -137,7 +137,7 @@ Integer converted = converter.convert("123");
 System.out.println(converted);    // 123
 ```
 
-Keep in mind that the code is also valid if the `@FunctionalInterface` annotation would be ommited.
+Keep in mind that the code is also valid if the `@FunctionalInterface` annotation would be omitted.
 
 
 ## Method and Constructor References
@@ -239,7 +239,7 @@ Writing to `num` from within the lambda expression is also prohibited.
 
 ### Accessing fields and static variables
 
-In constrast to local variables we have both read and write access to instance fields and static variables from within lambda expressions. This behaviour is well known from anonymous objects.
+In contrast to local variables, we have both read and write access to instance fields and static variables from within lambda expressions. This behaviour is well known from anonymous objects.
 
 ```java
 class Lambda4 {
@@ -267,7 +267,7 @@ Remember the formula example from the first section? Interface `Formula` defines
 Default methods **cannot** be accessed from within lambda expressions. The following code does not compile:
 
 ```java
-Formula formula = (a) -> sqrt( a * 100);
+Formula formula = (a) -> sqrt(a * 100);
 ```
 
 
@@ -316,7 +316,7 @@ personSupplier.get();   // new Person
 
 ### Consumers
 
-Consumers represents operations to be performed on a single input argument.
+Consumers represent operations to be performed on a single input argument.
 
 ```java
 Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
@@ -339,7 +339,7 @@ comparator.reversed().compare(p1, p2);  // < 0
 
 ## Optionals
 
-Optionals are not functional interfaces, instead it's a nifty utility to prevent `NullPointerException`. It's an important concept for the next section, so let's have a quick look at how Optionals work.
+Optionals are not functional interfaces, but nifty utilities to prevent `NullPointerException`. It's an important concept for the next section, so let's have a quick look at how Optionals work.
 
 Optional is a simple container for a value which may be null or non-null. Think of a method which may return a non-null result but sometimes return nothing. Instead of returning `null` you return an `Optional` in Java 8.
 
@@ -355,9 +355,9 @@ optional.ifPresent((s) -> System.out.println(s.charAt(0)));     // "b"
 
 ## Streams
 
-A `java.util.Stream` represents a sequence of elements on which one or more operations can be performed. Stream operations are either _intermediate_ or _terminal_. While terminal operations return a result of a certain type, intermediate operations return the stream itself so you can chain multiple method calls in a row. Streams are created on a source, e.g. a `java.util.Collection` like lists or sets (maps are not supported). Stream operations can either be executed sequential or parallel.
+A `java.util.Stream` represents a sequence of elements on which one or more operations can be performed. Stream operations are either _intermediate_ or _terminal_. While terminal operations return a result of a certain type, intermediate operations return the stream itself so you can chain multiple method calls in a row. Streams are created on a source, e.g. a `java.util.Collection` like lists or sets (maps are not supported). Stream operations can either be executed sequentially or parallely.
 
-> You should also check out [Stream.js](https://github.com/winterbe/streamjs), a JavaScript port of the Java 8 Streams API.
+> Streams are extremely powerful, so I wrote a separate [Java 8 Streams Tutorial](http://winterbe.com/posts/2014/07/31/java8-stream-tutorial-examples/). You should also check out [Stream.js](https://github.com/winterbe/streamjs), a JavaScript port of the Java 8 Streams API.
 
 Let's first look how sequential streams work. First we create a sample source in form of a list of strings:
 
@@ -482,7 +482,7 @@ reduced.ifPresent(System.out::println);
 
 ## Parallel Streams
 
-As mentioned above streams can be either sequential or parallel. Operations on sequential streams are performed on a single thread while operations on parallel streams are performed concurrent on multiple threads.
+As mentioned above streams can be either sequential or parallel. Operations on sequential streams are performed on a single thread while operations on parallel streams are performed concurrently on multiple threads.
 
 The following example demonstrates how easy it is to increase the performance by using parallel streams.
 
@@ -535,7 +535,9 @@ As you can see both code snippets are almost identical but the parallel sort is
 
 ## Maps
 
-As already mentioned maps don't support streams. Instead maps now support various new and useful methods for doing common tasks.
+As already mentioned maps do not directly support streams. There's no `stream()` method available on the `Map` interface itself, however you can create specialized streams upon the keys, values or entries of a map via `map.keySet().stream()`, `map.values().stream()` and `map.entrySet().stream()`. 
+
+Furthermore maps support various new and useful methods for doing common tasks.
 
 ```java
 Map<Integer, String> map = new HashMap<>();
@@ -600,7 +602,7 @@ Java 8 contains a brand new date and time API under the package `java.time`. The
 
 ### Clock
 
-Clock provides access to the current date and time. Clocks are aware of a timezone and may be used instead of `System.currentTimeMillis()` to retrieve the current milliseconds. Such an instantaneous point on the time-line is also represented by the class `Instant`. Instants can be used to create legacy `java.util.Date` objects.
+Clock provides access to the current date and time. Clocks are aware of a timezone and may be used instead of `System.currentTimeMillis()` to retrieve the current time in milliseconds since Unix EPOCH. Such an instantaneous point on the time-line is also represented by the class `Instant`. Instants can be used to create legacy `java.util.Date` objects.
 
 ```java
 Clock clock = Clock.systemDefaultZone();
@@ -644,7 +646,7 @@ System.out.println(hoursBetween);       // -3
 System.out.println(minutesBetween);     // -239
 ```
 
-LocalTime comes with various factory method to simplify the creation of new instances, including parsing of time strings.
+LocalTime comes with various factory methods to simplify the creation of new instances, including parsing of time strings.
 
 ```java
 LocalTime late = LocalTime.of(23, 59, 59);
@@ -661,7 +663,7 @@ System.out.println(leetTime);   // 13:37
 
 ### LocalDate
 
-LocalDate represents a distinct date, e.g. 2014-03-11. It's immutable and works exactly analog to LocalTime. The sample demonstrates how to calculate new dates by adding or substracting days, months or years. Keep in mind that each manipulation returns a new instance.
+LocalDate represents a distinct date, e.g. 2014-03-11. It's immutable and works exactly analog to LocalTime. The sample demonstrates how to calculate new dates by adding or subtracting days, months or years. Keep in mind that each manipulation returns a new instance.
 
 ```java
 LocalDate today = LocalDate.now();
@@ -727,7 +729,7 @@ System.out.println(string);     // Nov 03, 2014 - 07:13
 
 Unlike `java.text.NumberFormat` the new `DateTimeFormatter` is immutable and **thread-safe**.
 
-For details on the pattern syntax read [here](http://download.java.net/jdk8/docs/api/java/time/format/DateTimeFormatter.html).
+For details on the pattern syntax read [here](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html).
 
 
 ## Annotations
@@ -763,7 +765,7 @@ class Person {}
 class Person {}
 ```
 
-Using variant 2 the java compiler implicitly sets up the `@Hints` annotation under the hood. That's important for reading annotation informations via reflection.
+Using variant 2 the java compiler implicitly sets up the `@Hints` annotation under the hood. That's important for reading annotation information via reflection.
 
 ```java
 Hint hint = Person.class.getAnnotation(Hint.class);
diff --git a/src/com/winterbe/java8/samples/lambda/Lambda5.java b/src/com/winterbe/java8/samples/lambda/Lambda5.java
@@ -0,0 +1,32 @@
+package com.winterbe.java8.samples.lambda;
+
+import java.util.HashMap;
+import java.util.function.BiConsumer;
+
+/**
+ * Created by grijesh
+ */
+public class Lambda5 {
+
+    //Pre-Defined Functional Interfaces
+    public static void main(String... args) {
+
+        //BiConsumer Example
+        BiConsumer<String,Integer> printKeyAndValue
+                = (key,value) -> System.out.println(key+"-"+value);
+
+        printKeyAndValue.accept("One",1);
+        printKeyAndValue.accept("Two",2);
+
+        System.out.println("##################");
+
+        //Java Hash-Map foreach supports BiConsumer
+        HashMap<String, Integer> dummyValues = new HashMap<>();
+        dummyValues.put("One", 1);
+        dummyValues.put("Two", 2);
+        dummyValues.put("Three", 3);
+
+        dummyValues.forEach((key,value) -> System.out.println(key+"-"+value));
+
+    }
+}
