diff --git a/core-java-8/src/main/java/com/baeldung/java_8_features/Address.java b/core-java-8/src/main/java/com/baeldung/java_8_features/Address.java index 9cd0d902e3..1f89503288 100644 --- a/core-java-8/src/main/java/com/baeldung/java_8_features/Address.java +++ b/core-java-8/src/main/java/com/baeldung/java_8_features/Address.java @@ -1,8 +1,5 @@ package com.baeldung.java_8_features; -/** - * Created by Alex Vengr - */ public class Address { private String street; diff --git a/core-java-8/src/main/java/com/baeldung/java_8_features/CustomException.java b/core-java-8/src/main/java/com/baeldung/java_8_features/CustomException.java index 651398bfea..ff9be6ab06 100644 --- a/core-java-8/src/main/java/com/baeldung/java_8_features/CustomException.java +++ b/core-java-8/src/main/java/com/baeldung/java_8_features/CustomException.java @@ -1,7 +1,4 @@ package com.baeldung.java_8_features; -/** - * Created by Alex Vengr - */ public class CustomException extends RuntimeException { } diff --git a/core-java-8/src/main/java/com/baeldung/java_8_features/Detail.java b/core-java-8/src/main/java/com/baeldung/java_8_features/Detail.java index 8e8187e0a2..811937dba7 100644 --- a/core-java-8/src/main/java/com/baeldung/java_8_features/Detail.java +++ b/core-java-8/src/main/java/com/baeldung/java_8_features/Detail.java @@ -3,9 +3,6 @@ package com.baeldung.java_8_features; import java.util.Arrays; import java.util.List; -/** - * Created by Alex Vengrov - */ public class Detail { private static final List PARTS = Arrays.asList("turbine", "pump"); diff --git a/core-java-8/src/main/java/com/baeldung/java_8_features/OptionalAddress.java b/core-java-8/src/main/java/com/baeldung/java_8_features/OptionalAddress.java index 925dd5e97b..8d6c517ac5 100644 --- a/core-java-8/src/main/java/com/baeldung/java_8_features/OptionalAddress.java +++ b/core-java-8/src/main/java/com/baeldung/java_8_features/OptionalAddress.java @@ -2,9 +2,6 @@ package com.baeldung.java_8_features; import java.util.Optional; -/** - * Created by Alex Vengrov - */ public class OptionalAddress { private String street; diff --git a/core-java-8/src/main/java/com/baeldung/java_8_features/OptionalUser.java b/core-java-8/src/main/java/com/baeldung/java_8_features/OptionalUser.java index a725a4a817..ff06cd21d6 100644 --- a/core-java-8/src/main/java/com/baeldung/java_8_features/OptionalUser.java +++ b/core-java-8/src/main/java/com/baeldung/java_8_features/OptionalUser.java @@ -2,9 +2,6 @@ package com.baeldung.java_8_features; import java.util.Optional; -/** - * Created by Alex Vengrov - */ public class OptionalUser { private OptionalAddress address; diff --git a/core-java-8/src/main/java/com/baeldung/java_8_features/User.java b/core-java-8/src/main/java/com/baeldung/java_8_features/User.java index 5c496539f2..3708d276c8 100644 --- a/core-java-8/src/main/java/com/baeldung/java_8_features/User.java +++ b/core-java-8/src/main/java/com/baeldung/java_8_features/User.java @@ -2,9 +2,6 @@ package com.baeldung.java_8_features; import java.util.Optional; -/** - * Created by Alex Vengrov - */ public class User { private String name; diff --git a/core-java-8/src/main/java/com/baeldung/java_8_features/Vehicle.java b/core-java-8/src/main/java/com/baeldung/java_8_features/Vehicle.java index bf8ea0e09a..011173bcaf 100644 --- a/core-java-8/src/main/java/com/baeldung/java_8_features/Vehicle.java +++ b/core-java-8/src/main/java/com/baeldung/java_8_features/Vehicle.java @@ -1,8 +1,5 @@ package com.baeldung.java_8_features; -/** - * Created by Alex Vengrov - */ public interface Vehicle { void moveTo(long altitude, long longitude); diff --git a/core-java-8/src/main/java/com/baeldung/java_8_features/VehicleImpl.java b/core-java-8/src/main/java/com/baeldung/java_8_features/VehicleImpl.java index 7d325e3292..83e55f5f4d 100644 --- a/core-java-8/src/main/java/com/baeldung/java_8_features/VehicleImpl.java +++ b/core-java-8/src/main/java/com/baeldung/java_8_features/VehicleImpl.java @@ -1,8 +1,5 @@ package com.baeldung.java_8_features; -/** - * Created by 1 on 15.05.2016. - */ public class VehicleImpl implements Vehicle { @Override diff --git a/core-java-8/src/test/java/com/baeldung/java8/Java8DefaultStaticIntefaceMethodsTest.java b/core-java-8/src/test/java/com/baeldung/java8/Java8DefaultStaticIntefaceMethodsTest.java new file mode 100644 index 0000000000..21a5e34b9b --- /dev/null +++ b/core-java-8/src/test/java/com/baeldung/java8/Java8DefaultStaticIntefaceMethodsTest.java @@ -0,0 +1,27 @@ +package com.baeldung.java8; + +import com.baeldung.java_8_features.Vehicle; +import com.baeldung.java_8_features.VehicleImpl; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public class Java8DefaultStaticIntefaceMethodsTest { + + @Test + public void callStaticInterfaceMethdosMethods_whenExpectedResults_thenCorrect() { + Vehicle vehicle = new VehicleImpl(); + String overview = vehicle.getOverview(); + long[] startPosition = vehicle.startPosition(); + + assertEquals(overview, "ATV made by N&F Vehicles"); + assertEquals(startPosition[0], 23); + assertEquals(startPosition[1], 15); + } + + @Test + public void callDefaultInterfaceMethods_whenExpectedResults_thenCorrect() { + String producer = Vehicle.producer(); + assertEquals(producer, "N&F Vehicles"); + } +} diff --git a/core-java-8/src/test/java/com/baeldung/java8/Java8Features.java b/core-java-8/src/test/java/com/baeldung/java8/Java8Features.java deleted file mode 100644 index 724b1770ea..0000000000 --- a/core-java-8/src/test/java/com/baeldung/java8/Java8Features.java +++ /dev/null @@ -1,220 +0,0 @@ -package com.baeldung.java8; - -import com.baeldung.java_8_features.*; -import org.junit.Before; -import org.junit.Test; -import org.mockito.Mock; - -import java.nio.file.Path; -import java.nio.file.Paths; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.Optional; -import java.util.stream.Collectors; -import java.util.stream.Stream; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; -import static org.mockito.Mockito.mock; - -/** - * Created by Alex Vengrov - */ -public class Java8Features { - - private List list; - - @Before - public void init() { - list = new ArrayList<>(); - list.add("One"); - list.add("OneAndOnly"); - list.add("Derek"); - list.add("Change"); - list.add("factory"); - list.add("justBefore"); - list.add("Italy"); - list.add("Italy"); - list.add("Thursday"); - list.add(""); - list.add(""); - } - - @Test - public void callMethods_whenExpectedResults_thenCorrect() { - - Vehicle vehicle = new VehicleImpl(); - String overview = vehicle.getOverview(); - long[] startPosition = vehicle.startPosition(); - String producer = Vehicle.producer(); - - assertEquals(overview, "ATV made by N&F Vehicles"); - assertEquals(startPosition[0], 23); - assertEquals(startPosition[1], 15); - assertEquals(producer, "N&F Vehicles"); - } - - @Test - public void checkStreamOperations_whenWorkAsSuppose_thenCorrect() { - - String[] arr = new String[]{"a", "b", "c"}; - Stream streamArr = Arrays.stream(arr); - Stream streamOf = Stream.of("a", "b", "c"); - assertEquals(streamArr.count(), 3); - - long count = list.stream().distinct().count(); - assertEquals(count, 9); - - list.parallelStream().forEach(element -> doWork(element)); - - Stream streamFilter = list.stream().filter(element -> element.isEmpty()); - assertEquals(streamFilter.count(), 2); - - List uris = new ArrayList<>(); - uris.add("C:\\My.txt"); - Stream streamMap = uris.stream().map(uri -> Paths.get(uri)); - assertEquals(streamMap.count(), 1); - - List details = new ArrayList<>(); - details.add(new Detail()); - details.add(new Detail()); - Stream streamFlatMap = details.stream() - .flatMap(detail -> detail.getParts().stream()); - assertEquals(streamFlatMap.count(), 4); - - boolean isValid = list.stream().anyMatch(element -> element.contains("h")); - boolean isValidOne = list.stream().allMatch(element -> element.contains("h")); - boolean isValidTwo = list.stream().noneMatch(element -> element.contains("h")); - assertTrue(isValid); - assertFalse(isValidOne); - assertFalse(isValidTwo); - - List integers = new ArrayList<>(); - integers.add(1); - integers.add(1); - integers.add(1); - Integer reduced = integers.stream().reduce(23, (a, b) -> a + b); - assertTrue(reduced == 26); - - List resultList = list.stream() - .map(element -> element.toUpperCase()) - .collect(Collectors.toList()); - assertEquals(resultList.size(), list.size()); - assertTrue(resultList.contains("")); - } - - @Test - public void checkMethodReferences_whenWork_thenCorrect() { - - List users = new ArrayList<>(); - users.add(new User()); - users.add(new User()); - boolean isReal = users.stream().anyMatch(u -> User.isRealUser(u)); - boolean isRealRef = users.stream().anyMatch(User::isRealUser); - assertTrue(isReal); - assertTrue(isRealRef); - - User user = new User(); - boolean isLegalName = list.stream().anyMatch(user::isLegalName); - assertTrue(isLegalName); - - long count = list.stream().filter(String::isEmpty).count(); - assertEquals(count, 2); - - Stream stream = list.stream().map(User::new); - List userList = stream.collect(Collectors.toList()); - assertEquals(userList.size(), list.size()); - assertTrue(userList.get(0) instanceof User); - } - - @Test - public void checkOptional_whenAsExpected_thenCorrect() { - - Optional optionalEmpty = Optional.empty(); - assertFalse(optionalEmpty.isPresent()); - - String str = "value"; - Optional optional = Optional.of(str); - assertEquals(optional.get(), "value"); - - Optional optionalNullable = Optional.ofNullable(str); - Optional optionalNull = Optional.ofNullable(null); - assertEquals(optionalNullable.get(), "value"); - assertFalse(optionalNull.isPresent()); - - List listOpt = Optional.of(list).orElse(new ArrayList<>()); - List listNull = null; - List listOptNull = Optional.ofNullable(listNull).orElse(new ArrayList<>()); - assertTrue(listOpt == list); - assertTrue(listOptNull.isEmpty()); - - Optional user = Optional.ofNullable(getUser()); - String result = user.map(User::getAddress) - .map(Address::getStreet) - .orElse("not specified"); - assertEquals(result, "1st Avenue"); - - Optional optionalUser = Optional.ofNullable(getOptionalUser()); - String resultOpt = optionalUser.flatMap(OptionalUser::getAddress) - .flatMap(OptionalAddress::getStreet) - .orElse("not specified"); - assertEquals(resultOpt, "1st Avenue"); - - Optional userNull = Optional.ofNullable(getUserNull()); - String resultNull = userNull.map(User::getAddress) - .map(Address::getStreet) - .orElse("not specified"); - assertEquals(resultNull, "not specified"); - - Optional optionalUserNull = Optional.ofNullable(getOptionalUserNull()); - String resultOptNull = optionalUserNull.flatMap(OptionalUser::getAddress) - .flatMap(OptionalAddress::getStreet) - .orElse("not specified"); - assertEquals(resultOptNull, "not specified"); - - } - - @Test(expected = CustomException.class) - public void callMethod_whenCustomException_thenCorrect() { - User user = new User(); - String result = user.getOrThrow(); - } - - private User getUser() { - User user = new User(); - Address address = new Address(); - address.setStreet("1st Avenue"); - user.setAddress(address); - return user; - } - - private OptionalUser getOptionalUser() { - OptionalUser user = new OptionalUser(); - OptionalAddress address = new OptionalAddress(); - address.setStreet("1st Avenue"); - user.setAddress(address); - return user; - } - - private OptionalUser getOptionalUserNull() { - OptionalUser user = new OptionalUser(); - OptionalAddress address = new OptionalAddress(); - address.setStreet(null); - user.setAddress(address); - return user; - } - - private User getUserNull() { - User user = new User(); - Address address = new Address(); - address.setStreet(null); - user.setAddress(address); - return user; - } - - private void doWork(String string) { - //just imitate an amount of work - } -} diff --git a/core-java-8/src/test/java/com/baeldung/java8/Java8MethodReferenceTest.java b/core-java-8/src/test/java/com/baeldung/java8/Java8MethodReferenceTest.java new file mode 100644 index 0000000000..d9d88c5052 --- /dev/null +++ b/core-java-8/src/test/java/com/baeldung/java8/Java8MethodReferenceTest.java @@ -0,0 +1,67 @@ +package com.baeldung.java8; + +import com.baeldung.java_8_features.User; +import org.junit.Before; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +public class Java8MethodReferenceTest { + + private List list; + + @Before + public void init() { + list = new ArrayList<>(); + list.add("One"); + list.add("OneAndOnly"); + list.add("Derek"); + list.add("Change"); + list.add("factory"); + list.add("justBefore"); + list.add("Italy"); + list.add("Italy"); + list.add("Thursday"); + list.add(""); + list.add(""); + } + + @Test + public void checkStaticMethodReferences_whenWork_thenCorrect() { + + List users = new ArrayList<>(); + users.add(new User()); + users.add(new User()); + boolean isReal = users.stream().anyMatch(u -> User.isRealUser(u)); + boolean isRealRef = users.stream().anyMatch(User::isRealUser); + assertTrue(isReal); + assertTrue(isRealRef); + } + + @Test + public void checkInstanceMethodReferences_whenWork_thenCorrect() { + User user = new User(); + boolean isLegalName = list.stream().anyMatch(user::isLegalName); + assertTrue(isLegalName); + } + + @Test + public void checkParticularTypeReferences_whenWork_thenCorrect() { + long count = list.stream().filter(String::isEmpty).count(); + assertEquals(count, 2); + } + + @Test + public void checkConstructorReferences_whenWork_thenCorrect() { + Stream stream = list.stream().map(User::new); + List userList = stream.collect(Collectors.toList()); + assertEquals(userList.size(), list.size()); + assertTrue(userList.get(0) instanceof User); + } +} diff --git a/core-java-8/src/test/java/com/baeldung/java8/Java8OptionalTest.java b/core-java-8/src/test/java/com/baeldung/java8/Java8OptionalTest.java new file mode 100644 index 0000000000..26de39bc0e --- /dev/null +++ b/core-java-8/src/test/java/com/baeldung/java8/Java8OptionalTest.java @@ -0,0 +1,118 @@ +package com.baeldung.java8; + +import com.baeldung.java_8_features.*; +import org.junit.Before; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +import static org.junit.Assert.*; + +public class Java8OptionalTest { + + private List list; + + @Before + public void init() { + list = new ArrayList<>(); + list.add("One"); + list.add("OneAndOnly"); + list.add("Derek"); + list.add("Change"); + list.add("factory"); + list.add("justBefore"); + list.add("Italy"); + list.add("Italy"); + list.add("Thursday"); + list.add(""); + list.add(""); + } + + @Test + public void checkOptional_whenAsExpected_thenCorrect() { + + Optional optionalEmpty = Optional.empty(); + assertFalse(optionalEmpty.isPresent()); + + String str = "value"; + Optional optional = Optional.of(str); + assertEquals(optional.get(), "value"); + + Optional optionalNullable = Optional.ofNullable(str); + Optional optionalNull = Optional.ofNullable(null); + assertEquals(optionalNullable.get(), "value"); + assertFalse(optionalNull.isPresent()); + + List listOpt = Optional.of(list).orElse(new ArrayList<>()); + List listNull = null; + List listOptNull = Optional.ofNullable(listNull).orElse(new ArrayList<>()); + assertTrue(listOpt == list); + assertTrue(listOptNull.isEmpty()); + + Optional user = Optional.ofNullable(getUser()); + String result = user.map(User::getAddress) + .map(Address::getStreet) + .orElse("not specified"); + assertEquals(result, "1st Avenue"); + + Optional optionalUser = Optional.ofNullable(getOptionalUser()); + String resultOpt = optionalUser.flatMap(OptionalUser::getAddress) + .flatMap(OptionalAddress::getStreet) + .orElse("not specified"); + assertEquals(resultOpt, "1st Avenue"); + + Optional userNull = Optional.ofNullable(getUserNull()); + String resultNull = userNull.map(User::getAddress) + .map(Address::getStreet) + .orElse("not specified"); + assertEquals(resultNull, "not specified"); + + Optional optionalUserNull = Optional.ofNullable(getOptionalUserNull()); + String resultOptNull = optionalUserNull.flatMap(OptionalUser::getAddress) + .flatMap(OptionalAddress::getStreet) + .orElse("not specified"); + assertEquals(resultOptNull, "not specified"); + + } + + @Test(expected = CustomException.class) + public void callMethod_whenCustomException_thenCorrect() { + User user = new User(); + String result = user.getOrThrow(); + } + + private User getUser() { + User user = new User(); + Address address = new Address(); + address.setStreet("1st Avenue"); + user.setAddress(address); + return user; + } + + private OptionalUser getOptionalUser() { + OptionalUser user = new OptionalUser(); + OptionalAddress address = new OptionalAddress(); + address.setStreet("1st Avenue"); + user.setAddress(address); + return user; + } + + private OptionalUser getOptionalUserNull() { + OptionalUser user = new OptionalUser(); + OptionalAddress address = new OptionalAddress(); + address.setStreet(null); + user.setAddress(address); + return user; + } + + private User getUserNull() { + User user = new User(); + Address address = new Address(); + address.setStreet(null); + user.setAddress(address); + return user; + } + +} diff --git a/core-java-8/src/test/java/com/baeldung/java8/Java8StreamsTest.java b/core-java-8/src/test/java/com/baeldung/java8/Java8StreamsTest.java new file mode 100644 index 0000000000..1f1dda49ce --- /dev/null +++ b/core-java-8/src/test/java/com/baeldung/java8/Java8StreamsTest.java @@ -0,0 +1,113 @@ +package com.baeldung.java8; + +import com.baeldung.java_8_features.Detail; +import org.junit.Before; +import org.junit.Test; + +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import static org.junit.Assert.*; + +public class Java8StreamsTest { + + private List list; + + @Before + public void init() { + list = new ArrayList<>(); + list.add("One"); + list.add("OneAndOnly"); + list.add("Derek"); + list.add("Change"); + list.add("factory"); + list.add("justBefore"); + list.add("Italy"); + list.add("Italy"); + list.add("Thursday"); + list.add(""); + list.add(""); + } + + @Test + public void checkStreamCount_whenCreating_givenDifferentSources() { + String[] arr = new String[]{"a", "b", "c"}; + Stream streamArr = Arrays.stream(arr); + assertEquals(streamArr.count(), 3); + + Stream streamOf = Stream.of("a", "b", "c"); + assertEquals(streamOf.count(), 3); + + long count = list.stream().distinct().count(); + assertEquals(count, 9); + } + + + @Test + public void checkStreamCount_whenOperationFilter_thanCorrect() { + Stream streamFilter = list.stream().filter(element -> element.isEmpty()); + assertEquals(streamFilter.count(), 2); + } + + + @Test + public void checkStreamCount_whenOperationMap_thanCorrect() { + List uris = new ArrayList<>(); + uris.add("C:\\My.txt"); + Stream streamMap = uris.stream().map(uri -> Paths.get(uri)); + assertEquals(streamMap.count(), 1); + + List details = new ArrayList<>(); + details.add(new Detail()); + details.add(new Detail()); + Stream streamFlatMap = details.stream() + .flatMap(detail -> detail.getParts().stream()); + assertEquals(streamFlatMap.count(), 4); + } + + + @Test + public void checkStreamCount_whenOperationMatch_thenCorrect() { + boolean isValid = list.stream().anyMatch(element -> element.contains("h")); + boolean isValidOne = list.stream().allMatch(element -> element.contains("h")); + boolean isValidTwo = list.stream().noneMatch(element -> element.contains("h")); + assertTrue(isValid); + assertFalse(isValidOne); + assertFalse(isValidTwo); + } + + + @Test + public void checkStreamReducedValue_whenOperationReduce_thenCorrect() { + List integers = new ArrayList<>(); + integers.add(1); + integers.add(1); + integers.add(1); + Integer reduced = integers.stream().reduce(23, (a, b) -> a + b); + assertTrue(reduced == 26); + } + + @Test + public void checkStreamContains_whenOperationCollect_thenCorrect() { + List resultList = list.stream() + .map(element -> element.toUpperCase()) + .collect(Collectors.toList()); + assertEquals(resultList.size(), list.size()); + assertTrue(resultList.contains("")); + } + + + @Test + public void checkParallelStream_whenDoWork() { + list.parallelStream().forEach(element -> doWork(element)); + } + + private void doWork(String string) { + assertTrue(true); //just imitate an amount of work + } +}