From ac0cc708b19ece74dcfb281081513a2a7c42230b Mon Sep 17 00:00:00 2001 From: Sergey Petunin Date: Thu, 25 Aug 2016 11:24:18 +0600 Subject: [PATCH 1/4] Source code for the article Guide to Java 8 Functional Interfaces (#637) --- .../FunctionalInterfaceTest.java | 186 ++++++++++++++++++ .../ShortToByteFunction.java | 8 + 2 files changed, 194 insertions(+) create mode 100644 core-java-8/src/test/java/com/baeldung/functionalinterface/FunctionalInterfaceTest.java create mode 100644 core-java-8/src/test/java/com/baeldung/functionalinterface/ShortToByteFunction.java diff --git a/core-java-8/src/test/java/com/baeldung/functionalinterface/FunctionalInterfaceTest.java b/core-java-8/src/test/java/com/baeldung/functionalinterface/FunctionalInterfaceTest.java new file mode 100644 index 0000000000..7e49d32b95 --- /dev/null +++ b/core-java-8/src/test/java/com/baeldung/functionalinterface/FunctionalInterfaceTest.java @@ -0,0 +1,186 @@ +package com.baeldung.functionalinterface; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import org.junit.Test; + +import static org.junit.Assert.*; + +public class FunctionalInterfaceTest { + + @Test + public void whenPassingLambdaToComputeIfAbsent_thenTheValueGetsComputedAndPutIntoMap() { + + Map nameMap = new HashMap<>(); + Integer value = nameMap.computeIfAbsent("John", s -> s.length()); + + assertEquals(new Integer(4), nameMap.get("John")); + assertEquals(new Integer(4), value); + + } + + @Test + public void whenPassingMethodReferenceToComputeIfAbsent_thenTheValueGetsComputedAndPutIntoMap() { + + Map nameMap = new HashMap<>(); + Integer value = nameMap.computeIfAbsent("John", String::length); + + assertEquals(new Integer(4), nameMap.get("John")); + assertEquals(new Integer(4), value); + + } + + public byte[] transformArray(short[] array, ShortToByteFunction function) { + byte[] transformedArray = new byte[array.length]; + for (int i = 0; i < array.length; i++) { + transformedArray[i] = function.applyAsByte(array[i]); + } + return transformedArray; + } + + @Test + public void whenUsingCustomFunctionalInterfaceForPrimitives_thenCanUseItAsLambda() { + + short[] array = {(short) 1, (short) 2, (short) 3}; + byte[] transformedArray = transformArray(array, s -> (byte) (s * 2)); + + byte[] expectedArray = {(byte) 2, (byte) 4, (byte) 6}; + assertArrayEquals(expectedArray, transformedArray); + + } + + @Test + public void whenUsingBiFunction_thenCanUseItToReplaceMapValues() { + + Map salaries = new HashMap<>(); + salaries.put("John", 40000); + salaries.put("Freddy", 30000); + salaries.put("Samuel", 50000); + + salaries.replaceAll((name, oldValue) -> { + if (name.equals("Freddy")) { + return oldValue; + } else { + return oldValue + 10000; + } + }); + + assertEquals(new Integer(50000), salaries.get("John")); + assertEquals(new Integer(30000), salaries.get("Freddy")); + assertEquals(new Integer(60000), salaries.get("Samuel")); + + } + + + @Test + public void whenPassingLambdaToThreadConstructor_thenLambdaInferredToRunnable() { + + Thread thread = new Thread(() -> System.out.println("Hello From Another Thread")); + thread.start(); + + } + + @Test + public void whenUsingSupplierToGenerateNumbers_thenCanUseItInStreamGenerate() { + + int[] fibs = {0, 1}; + Stream fibonacci = Stream.generate(() -> { + int result = fibs[1]; + int fib3 = fibs[0] + fibs[1]; + fibs[0] = fibs[1]; + fibs[1] = fib3; + return result; + }); + + List fibonacci5 = fibonacci.limit(5) + .collect(Collectors.toList()); + + assertEquals(new Integer(1), fibonacci5.get(0)); + assertEquals(new Integer(1), fibonacci5.get(1)); + assertEquals(new Integer(2), fibonacci5.get(2)); + assertEquals(new Integer(3), fibonacci5.get(3)); + assertEquals(new Integer(5), fibonacci5.get(4)); + + } + + @Test + public void whenUsingConsumerInForEach_thenConsumerExecutesForEachListElement() { + + List names = Arrays.asList("John", "Freddy", "Samuel"); + names.forEach(name -> System.out.println("Hello, " + name)); + + } + + @Test + public void whenUsingBiConsumerInForEach_thenConsumerExecutesForEachMapElement() { + + Map ages = new HashMap<>(); + ages.put("John", 25); + ages.put("Freddy", 24); + ages.put("Samuel", 30); + + ages.forEach((name, age) -> System.out.println(name + " is " + age + " years old")); + + } + + @Test + public void whenUsingPredicateInFilter_thenListValuesAreFilteredOut() { + + List names = Arrays.asList("Angela", "Aaron", "Bob", "Claire", "David"); + + List namesWithA = names.stream() + .filter(name -> name.startsWith("A")) + .collect(Collectors.toList()); + + assertEquals(2, namesWithA.size()); + assertTrue(namesWithA.contains("Angela")); + assertTrue(namesWithA.contains("Aaron")); + + } + + @Test + public void whenUsingUnaryOperatorWithReplaceAll_thenAllValuesInTheListAreReplaced() { + + List names = Arrays.asList("bob", "josh", "megan"); + + names.replaceAll(String::toUpperCase); + + assertEquals("BOB", names.get(0)); + assertEquals("JOSH", names.get(1)); + assertEquals("MEGAN", names.get(2)); + + } + + @Test + public void whenUsingBinaryOperatorWithStreamReduce_thenResultIsSumOfValues() { + + List values = Arrays.asList(3, 5, 8, 9, 12); + + int sum = values.stream() + .reduce((acc, value) -> acc + value) + .get(); + + assertEquals(37, sum); + + } + + @Test + public void whenComposingTwoFunctions_thenFunctionsExecuteSequentially() { + + Function intToString = Object::toString; + Function quote = s -> "'" + s + "'"; + + Function quoteIntToString = quote.compose(intToString); + + assertEquals("'5'", quoteIntToString.apply(5)); + + } + + +} diff --git a/core-java-8/src/test/java/com/baeldung/functionalinterface/ShortToByteFunction.java b/core-java-8/src/test/java/com/baeldung/functionalinterface/ShortToByteFunction.java new file mode 100644 index 0000000000..3231d6244f --- /dev/null +++ b/core-java-8/src/test/java/com/baeldung/functionalinterface/ShortToByteFunction.java @@ -0,0 +1,8 @@ +package com.baeldung.functionalinterface; + +@FunctionalInterface +public interface ShortToByteFunction { + + byte applyAsByte(short s); + +} From 9ae8b346d9248a08977e0b9aceb79cc6b45f80f3 Mon Sep 17 00:00:00 2001 From: Grzegorz Piwowarek Date: Thu, 25 Aug 2016 08:24:32 +0200 Subject: [PATCH 2/4] Refactor FunctionInterfacesTest --- .../FunctionalInterfaceTest.java | 15 ++++----------- 1 file changed, 4 insertions(+), 11 deletions(-) diff --git a/core-java-8/src/test/java/com/baeldung/functionalinterface/FunctionalInterfaceTest.java b/core-java-8/src/test/java/com/baeldung/functionalinterface/FunctionalInterfaceTest.java index 7e49d32b95..beb3868dbc 100644 --- a/core-java-8/src/test/java/com/baeldung/functionalinterface/FunctionalInterfaceTest.java +++ b/core-java-8/src/test/java/com/baeldung/functionalinterface/FunctionalInterfaceTest.java @@ -1,5 +1,7 @@ package com.baeldung.functionalinterface; +import org.junit.Test; + import java.util.Arrays; import java.util.HashMap; import java.util.List; @@ -8,8 +10,6 @@ import java.util.function.Function; import java.util.stream.Collectors; import java.util.stream.Stream; -import org.junit.Test; - import static org.junit.Assert.*; public class FunctionalInterfaceTest { @@ -63,13 +63,7 @@ public class FunctionalInterfaceTest { salaries.put("Freddy", 30000); salaries.put("Samuel", 50000); - salaries.replaceAll((name, oldValue) -> { - if (name.equals("Freddy")) { - return oldValue; - } else { - return oldValue + 10000; - } - }); + salaries.replaceAll((name, oldValue) -> name.equals("Freddy") ? oldValue : oldValue + 10000); assertEquals(new Integer(50000), salaries.get("John")); assertEquals(new Integer(30000), salaries.get("Freddy")); @@ -163,8 +157,7 @@ public class FunctionalInterfaceTest { List values = Arrays.asList(3, 5, 8, 9, 12); int sum = values.stream() - .reduce((acc, value) -> acc + value) - .get(); + .reduce(0, (acc, value) -> acc + value); assertEquals(37, sum); From 743f6c8806fc208cfbc4b89c06f94c177a710a37 Mon Sep 17 00:00:00 2001 From: Sergey Petunin Date: Thu, 25 Aug 2016 14:30:40 +0600 Subject: [PATCH 3/4] Added example for Supplier lazy generation, corrected the reduce example (#638) --- .../FunctionalInterfaceTest.java | 26 ++++++++++++++++--- 1 file changed, 23 insertions(+), 3 deletions(-) diff --git a/core-java-8/src/test/java/com/baeldung/functionalinterface/FunctionalInterfaceTest.java b/core-java-8/src/test/java/com/baeldung/functionalinterface/FunctionalInterfaceTest.java index beb3868dbc..ce878026d4 100644 --- a/core-java-8/src/test/java/com/baeldung/functionalinterface/FunctionalInterfaceTest.java +++ b/core-java-8/src/test/java/com/baeldung/functionalinterface/FunctionalInterfaceTest.java @@ -1,15 +1,18 @@ package com.baeldung.functionalinterface; -import org.junit.Test; - import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.concurrent.TimeUnit; import java.util.function.Function; +import java.util.function.Supplier; import java.util.stream.Collectors; import java.util.stream.Stream; +import com.google.common.util.concurrent.Uninterruptibles; +import org.junit.Test; + import static org.junit.Assert.*; public class FunctionalInterfaceTest { @@ -157,7 +160,7 @@ public class FunctionalInterfaceTest { List values = Arrays.asList(3, 5, 8, 9, 12); int sum = values.stream() - .reduce(0, (acc, value) -> acc + value); + .reduce(0, (i1, i2) -> i1 + i2); assertEquals(37, sum); @@ -175,5 +178,22 @@ public class FunctionalInterfaceTest { } + public double squareLazy(Supplier lazyValue) { + return Math.pow(lazyValue.get(), 2); + } + + @Test + public void whenUsingSupplierToGenerateValue_thenValueIsGeneratedLazily() { + + Supplier lazyValue = () -> { + Uninterruptibles.sleepUninterruptibly(1000, TimeUnit.MILLISECONDS); + return 9d; + }; + + double valueSquared = squareLazy(lazyValue); + + assertEquals(81d, valueSquared, 0); + + } } From d9ca600cea59de28f58939dd074639254411d521 Mon Sep 17 00:00:00 2001 From: eugenp Date: Thu, 25 Aug 2016 12:03:45 +0300 Subject: [PATCH 4/4] skipping the gatling module as part of the standard build --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index 1ac8c83c99..c64acc145c 100644 --- a/pom.xml +++ b/pom.xml @@ -25,7 +25,7 @@ dependency-injection deltaspike - gatling + gson gson-jackson-performance