From 5d12fa28c1727d8b349ec92ab0b50915b85b9cb9 Mon Sep 17 00:00:00 2001 From: YuCheng Hu Date: Thu, 25 Apr 2024 18:16:01 -0400 Subject: [PATCH 01/13] =?UTF-8?q?=E5=AE=8C=E6=88=90=E6=9B=B4=E6=96=B0=20Ja?= =?UTF-8?q?va=20=E6=96=B0=E7=89=B9=E6=80=A7=E9=A2=84=E8=A7=88=E5=86=85?= =?UTF-8?q?=E5=AE=B9=E7=9A=84=E7=BF=BB=E8=AF=91=E5=92=8C=E5=A4=84=E7=90=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .idea/compiler.xml | 2 ++ .idea/encodings.xml | 2 ++ core-java-modules/core-java/README.md | 2 +- 3 files changed, 5 insertions(+), 1 deletion(-) diff --git a/.idea/compiler.xml b/.idea/compiler.xml index d01bf0a170..e1211661e8 100644 --- a/.idea/compiler.xml +++ b/.idea/compiler.xml @@ -11,6 +11,8 @@ + + diff --git a/.idea/encodings.xml b/.idea/encodings.xml index 8e75ad790f..485ea4d754 100644 --- a/.idea/encodings.xml +++ b/.idea/encodings.xml @@ -33,6 +33,8 @@ + + diff --git a/core-java-modules/core-java/README.md b/core-java-modules/core-java/README.md index 0ca45409d3..8ff86380b1 100644 --- a/core-java-modules/core-java/README.md +++ b/core-java-modules/core-java/README.md @@ -3,4 +3,4 @@ 本模块中包含有关 Java 核心新增功能特性的一些文章。 ### 相关文章: -- [Java Preview Features](https://www.baeldung.com/java-preview-features) +- [Java 预览特性](https://track.ossez.com/articles/OSS-A-62628410/Java) -- 2.45.2 From 79eee60239769185e25d8b4d484df1d8f1306171 Mon Sep 17 00:00:00 2001 From: YuCheng Hu Date: Sat, 27 Apr 2024 07:31:50 -0400 Subject: [PATCH 02/13] =?UTF-8?q?=E6=9B=B4=E6=96=B0=20Java=208=20=E4=B8=AD?= =?UTF-8?q?=E7=9A=84=E8=AE=BE=E8=AE=A1=E6=A8=A1=E5=BC=8F=E7=AD=96=E7=95=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- core-java-modules/core-java-8/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core-java-modules/core-java-8/README.md b/core-java-modules/core-java-8/README.md index e207871def..5ec4b3ddef 100644 --- a/core-java-modules/core-java-8/README.md +++ b/core-java-modules/core-java-8/README.md @@ -5,7 +5,7 @@ ### 相关文章: - [New Features in Java 8](https://www.baeldung.com/java-8-new-features) - [Guide to Java 8 groupingBy Collector](https://www.baeldung.com/java-groupingby-collector) -- [Java 8 中的设计模式策略](https://www.ossez.com/t/java-8/13978) +- [Java 8 中的设计模式策略](https://track.ossez.com/articles/PL-A-37491935/Java-8) - [Guide to Java 8 Comparator.comparing()](https://www.baeldung.com/java-8-comparator-comparing) - [Guide to the Java 8 forEach](https://www.baeldung.com/foreach-java) - [Introduction to Spliterator in Java](https://www.baeldung.com/java-spliterator) -- 2.45.2 From 203042a6961e475176c3e116cdaa89e5100f371d Mon Sep 17 00:00:00 2001 From: YuCheng Hu Date: Sat, 27 Apr 2024 07:36:47 -0400 Subject: [PATCH 03/13] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E6=B3=A8=E8=A7=A3?= =?UTF-8?q?=E6=96=87=E4=BB=B6=E8=AF=B4=E6=98=8E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- core-java-modules/core-java-annotations/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core-java-modules/core-java-annotations/README.md b/core-java-modules/core-java-annotations/README.md index e8a8d19f04..547dab00c4 100644 --- a/core-java-modules/core-java-annotations/README.md +++ b/core-java-modules/core-java-annotations/README.md @@ -7,6 +7,6 @@ Java 语言中的类、方法、变量、参数和包等都可以被标注。和 - [Java @Override Annotation](https://www.baeldung.com/java-override) - [Java @SuppressWarnings Annotation](https://www.baeldung.com/java-suppresswarnings) - [Java @SafeVarargs Annotation](https://www.baeldung.com/java-safevarargs) -- [Java @Deprecated Annotation（注解）](https://www.cwiki.us/display/JAVAZH/Java+@Deprecated+Annotation) +- [Java @Deprecated Annotation（注解）](https://track.ossez.com/articles/PL-A-37491765/Java-Deprecated-Annotation) - [Overview of Java Built-in Annotations](https://www.baeldung.com/java-default-annotations) - [Creating a Custom Annotation in Java](https://www.baeldung.com/java-custom-annotation) -- 2.45.2 From 86ba6dfe749d2af36b3e01c18eee3cc5f1dd54b4 Mon Sep 17 00:00:00 2001 From: YuCheng Hu Date: Sat, 27 Apr 2024 08:02:07 -0400 Subject: [PATCH 04/13] Move the link for document --- .../core-java-collections-conversions/README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/core-java-modules/core-java-collections-conversions/README.md b/core-java-modules/core-java-collections-conversions/README.md index 73ab6b4b01..86e882a567 100644 --- a/core-java-modules/core-java-collections-conversions/README.md +++ b/core-java-modules/core-java-collections-conversions/README.md @@ -4,10 +4,10 @@ ### 相关文章 -- [Java 如何在 Array 和 List 之间进行转换](https://www.ossez.com/t/java-array-list/14416) -- [Java 如何在 Array 和 Set 之间进行转换](https://www.ossez.com/t/java-array-set/14417) -- [Java 把 Map 的值（Value）转换为 Array, List 或 Set](https://www.ossez.com/t/java-map-value-array-list-set/14388) -- [Java 把一个 List 转换为字符串](https://www.ossez.com/t/converting-a-list-to-string-in-java/14427) +- [Java 如何在 Array 和 List 之间进行转换](https://track.ossez.com/articles/PL-A-37491937/Java-Array-List) +- [Java 如何在 Array 和 Set 之间进行转换](https://track.ossez.com/articles/PL-A-37491936/Java-Array-Set) +- [Java 把 Map 的值（Value）转换为 Array, List 或 Set](https://track.ossez.com/articles/PL-A-37491647/Java-Map-Value-Array-List-Set) +- [Java 把一个 List 转换为字符串](https://track.ossez.com/articles/PL-A-37491646/Java-List) - [How to Convert List to Map in Java](https://www.baeldung.com/java-list-to-map) - [Converting a Collection to ArrayList in Java](https://www.baeldung.com/java-convert-collection-arraylist) - [Java 8 Collectors toMap](https://www.baeldung.com/java-collectors-tomap) -- 2.45.2 From afb622ad78947ff2ccd1948d70111d323d166bc6 Mon Sep 17 00:00:00 2001 From: YuCheng Hu Date: Sat, 27 Apr 2024 08:20:01 -0400 Subject: [PATCH 05/13] Update UUID --- core-java-modules/README.md | 2 +- core-java-modules/core-java-uuid/README.md | 9 ++++----- 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/core-java-modules/README.md b/core-java-modules/README.md index 165531dd16..59dab31559 100644 --- a/core-java-modules/README.md +++ b/core-java-modules/README.md @@ -4,7 +4,7 @@ ## 相关文章 -- [J2EE，Java EE，Jakarta EE 命名之间的恩恩怨怨](https://www.ossez.com/t/j2ee-java-ee-jakarta-ee/14382) +- [J2EE，Java EE，Jakarta EE 命名之间的恩恩怨怨](https://track.ossez.com/articles/PL-A-37491644/J2EEJava-EEJakarta-EE) - [Understanding the NumberFormatException in Java](https://www.baeldung.com/java-number-format-exception) diff --git a/core-java-modules/core-java-uuid/README.md b/core-java-modules/core-java-uuid/README.md index 4867bc47e4..b40196e490 100644 --- a/core-java-modules/core-java-uuid/README.md +++ b/core-java-modules/core-java-uuid/README.md @@ -1,8 +1,7 @@ ## Core Java UUID ### 相关文章： -- [在 Java 中生成只有数组和字母的 UUID](https://www.isharkfly.com/t/java-uuid/15097) -- [Guide to UUID in Java](http://www.baeldung.com/java-uuid) -- [Validate UUID String in Java](https://www.baeldung.com/java-validate-uuid-string) -- [Generate the Same UUID From a String in Java](https://www.baeldung.com/java-generate-same-uuid-from-string) -- [Generating Time Based UUIDs](https://www.baeldung.com/java-generating-time-based-uuids) +- [在 Java 中生成只有数组和字母的 UUID](https://track.ossez.com/articles/PL-A-37491643/Java-UUID) +- [Java 校验 UUID 字符串](https://www.baeldung.com/java-validate-uuid-string) +- [Java 从字符串中创建相同的 UUID](https://track.ossez.com/articles/PL-A-37491641/Java-UUID) +- [Generating Time Based UUIDs](https://track.ossez.com/articles/PL-A-37491625/UUID) -- 2.45.2 From afe803be48dd08192a77592238506f8b52c89267 Mon Sep 17 00:00:00 2001 From: YuCheng Hu Date: Sat, 27 Apr 2024 08:27:10 -0400 Subject: [PATCH 06/13] =?UTF-8?q?=E6=9B=B4=E6=96=B0=20Java=20=20UUID=20?= =?UTF-8?q?=E4=B8=AD=E9=97=AE=E6=96=87=E7=AB=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- core-java-modules/core-java-uuid/README.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/core-java-modules/core-java-uuid/README.md b/core-java-modules/core-java-uuid/README.md index b40196e490..84ff9cdaeb 100644 --- a/core-java-modules/core-java-uuid/README.md +++ b/core-java-modules/core-java-uuid/README.md @@ -1,7 +1,9 @@ ## Core Java UUID -### 相关文章： +### Relevant Articles: - [在 Java 中生成只有数组和字母的 UUID](https://track.ossez.com/articles/PL-A-37491643/Java-UUID) - [Java 校验 UUID 字符串](https://www.baeldung.com/java-validate-uuid-string) - [Java 从字符串中创建相同的 UUID](https://track.ossez.com/articles/PL-A-37491641/Java-UUID) -- [Generating Time Based UUIDs](https://track.ossez.com/articles/PL-A-37491625/UUID) +- [创建基于时间的 UUID](https://track.ossez.com/articles/PL-A-37491625/UUID) +- [Java 中使用 UUID 创建一个正 Long 类型](hhttps://track.ossez.com/articles/PL-A-37491627/Java-UUID-Long) +- [Java 中将 UUID 存储为 Base64 字符串](https://track.ossez.com/articles/PL-A-37491626/Java-UUID-Base64) -- 2.45.2 From 7efaee81eaa18bf15232392fde65450c3693a669 Mon Sep 17 00:00:00 2001 From: YuCheng Hu Date: Sat, 27 Apr 2024 08:27:44 -0400 Subject: [PATCH 07/13] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E6=A0=87=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- core-java-modules/core-java-uuid/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core-java-modules/core-java-uuid/README.md b/core-java-modules/core-java-uuid/README.md index 84ff9cdaeb..d06571267d 100644 --- a/core-java-modules/core-java-uuid/README.md +++ b/core-java-modules/core-java-uuid/README.md @@ -1,6 +1,6 @@ -## Core Java UUID +## Core Java （Java 核心） UUID -### Relevant Articles: +### 相关文章 - [在 Java 中生成只有数组和字母的 UUID](https://track.ossez.com/articles/PL-A-37491643/Java-UUID) - [Java 校验 UUID 字符串](https://www.baeldung.com/java-validate-uuid-string) - [Java 从字符串中创建相同的 UUID](https://track.ossez.com/articles/PL-A-37491641/Java-UUID) -- 2.45.2 From 87a004e47a353a4e584d6a7e6c2e376cff11cb25 Mon Sep 17 00:00:00 2001 From: YuCheng Hu Date: Sat, 27 Apr 2024 13:34:32 -0400 Subject: [PATCH 08/13] =?UTF-8?q?=E6=9B=B4=E6=96=B0=20UUID=20=E6=96=87?= =?UTF-8?q?=E6=A1=A3=E5=86=85=E5=AE=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../resources/log4jstructuraldp.properties | 9 +++ .../src/main/resources/logback.xml | 19 ++++++ .../DecodeUUIDStringFromBase64UnitTest.java | 64 +++++++++++++++++++ .../EncodeUUIDToBase64StringUnitTest.java | 62 ++++++++++++++++++ .../UUIDPositiveLongGeneratorUnitTest.java | 22 +++++++ .../src/test/resources/logback.xml | 18 ++++++ 6 files changed, 194 insertions(+) create mode 100644 core-java-modules/core-java-uuid/src/main/resources/log4jstructuraldp.properties create mode 100644 core-java-modules/core-java-uuid/src/main/resources/logback.xml create mode 100644 core-java-modules/core-java-uuid/src/test/java/com/ossez/uuid/DecodeUUIDStringFromBase64UnitTest.java create mode 100644 core-java-modules/core-java-uuid/src/test/java/com/ossez/uuid/EncodeUUIDToBase64StringUnitTest.java create mode 100644 core-java-modules/core-java-uuid/src/test/java/com/ossez/uuid/UUIDPositiveLongGeneratorUnitTest.java create mode 100644 core-java-modules/core-java-uuid/src/test/resources/logback.xml diff --git a/core-java-modules/core-java-uuid/src/main/resources/log4jstructuraldp.properties b/core-java-modules/core-java-uuid/src/main/resources/log4jstructuraldp.properties new file mode 100644 index 0000000000..5bc2bfe4b9 --- /dev/null +++ b/core-java-modules/core-java-uuid/src/main/resources/log4jstructuraldp.properties @@ -0,0 +1,9 @@ + +# Root logger +log4j.rootLogger=INFO, file, stdout + +# Write to console +log4j.appender.stdout=org.apache.log4j.ConsoleAppender +log4j.appender.stdout.Target=System.out +log4j.appender.stdout.layout=org.apache.log4j.PatternLayout +log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n \ No newline at end of file diff --git a/core-java-modules/core-java-uuid/src/main/resources/logback.xml b/core-java-modules/core-java-uuid/src/main/resources/logback.xml new file mode 100644 index 0000000000..56af2d397e --- /dev/null +++ b/core-java-modules/core-java-uuid/src/main/resources/logback.xml @@ -0,0 +1,19 @@ + + + + + %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n + + + + + + + + + + + + + + \ No newline at end of file diff --git a/core-java-modules/core-java-uuid/src/test/java/com/ossez/uuid/DecodeUUIDStringFromBase64UnitTest.java b/core-java-modules/core-java-uuid/src/test/java/com/ossez/uuid/DecodeUUIDStringFromBase64UnitTest.java new file mode 100644 index 0000000000..a0fffb1027 --- /dev/null +++ b/core-java-modules/core-java-uuid/src/test/java/com/ossez/uuid/DecodeUUIDStringFromBase64UnitTest.java @@ -0,0 +1,64 @@ +package com.ossez.uuid; + +import static org.apache.commons.codec.binary.Base64.decodeBase64; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.nio.ByteBuffer; +import java.util.Base64; +import java.util.UUID; + +import org.apache.commons.lang3.Conversion; +import org.junit.jupiter.api.Test; + +public class DecodeUUIDStringFromBase64UnitTest { + private final UUID originalUUID = UUID.fromString("cc5f93f7-8cf1-4a51-83c6-e740313a0c6c"); + + @Test + public void givenEncodedString_whenDecodingUsingBase64Decoder_thenGiveExpectedUUID() { + String expectedEncodedString = "UUrxjPeTX8xsDDoxQOfGgw"; + byte[] decodedBytes = Base64.getDecoder() + .decode(expectedEncodedString); + UUID uuid = convertToUUID(decodedBytes); + assertEquals(originalUUID, uuid); + } + + @Test + public void givenEncodedString_whenDecodingUsingByteBufferAndBase64UrlDecoder_thenGiveExpectedUUID() { + String expectedEncodedString = "zF-T94zxSlGDxudAMToMbA"; + byte[] decodedBytes = Base64.getUrlDecoder() + .decode(expectedEncodedString); + ByteBuffer byteBuffer = ByteBuffer.wrap(decodedBytes); + long mostSignificantBits = byteBuffer.getLong(); + long leastSignificantBits = byteBuffer.getLong(); + UUID uuid = new UUID(mostSignificantBits, leastSignificantBits); + assertEquals(originalUUID, uuid); + } + + @Test + public void givenEncodedString_whenDecodingUsingApacheUtils_thenGiveExpectedUUID() { + String expectedEncodedString = "UUrxjPeTX8xsDDoxQOfGgw"; + byte[] decodedBytes = decodeBase64(expectedEncodedString); + UUID uuid = Conversion.byteArrayToUuid(decodedBytes, 0); + assertEquals(originalUUID, uuid); + } + + private UUID convertToUUID(byte[] src) { + long mostSignificantBits = convertBytesToLong(src, 0); + long leastSignificantBits = convertBytesToLong(src, 8); + + return new UUID(mostSignificantBits, leastSignificantBits); + } + + private long convertBytesToLong(byte[] uuidBytes, int start) { + long result = 0; + + for(int i = 0; i < 8; i++) { + int shift = i * 8; + long bits = (255L & (long)uuidBytes[i + start]) << shift; + long mask = 255L << shift; + result = result & ~mask | bits; + } + + return result; + } +} diff --git a/core-java-modules/core-java-uuid/src/test/java/com/ossez/uuid/EncodeUUIDToBase64StringUnitTest.java b/core-java-modules/core-java-uuid/src/test/java/com/ossez/uuid/EncodeUUIDToBase64StringUnitTest.java new file mode 100644 index 0000000000..d8f1b4a13f --- /dev/null +++ b/core-java-modules/core-java-uuid/src/test/java/com/ossez/uuid/EncodeUUIDToBase64StringUnitTest.java @@ -0,0 +1,62 @@ +package com.ossez.uuid; + +import static org.apache.commons.codec.binary.Base64.encodeBase64URLSafeString; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.nio.ByteBuffer; +import java.util.Base64; +import java.util.UUID; + +import org.apache.commons.lang3.Conversion; +import org.junit.jupiter.api.Test; + +public class EncodeUUIDToBase64StringUnitTest { + private final UUID originalUUID = UUID.fromString("cc5f93f7-8cf1-4a51-83c6-e740313a0c6c"); + + @Test + public void givenUUID_whenEncodingUsingBase64Encoder_thenGiveExpectedEncodedString() { + String expectedEncodedString = "UUrxjPeTX8xsDDoxQOfGgw"; + byte[] uuidBytes = convertToByteArray(originalUUID); + String encodedUUID = Base64.getEncoder().withoutPadding() + .encodeToString(uuidBytes); + assertEquals(expectedEncodedString, encodedUUID); + } + + @Test + public void givenUUID_whenEncodingUsingByteBufferAndBase64UrlEncoder_thenGiveExpectedEncodedString() { + String expectedEncodedString = "zF-T94zxSlGDxudAMToMbA"; + ByteBuffer byteBuffer = ByteBuffer.wrap(new byte[16]); + byteBuffer.putLong(originalUUID.getMostSignificantBits()); + byteBuffer.putLong(originalUUID.getLeastSignificantBits()); + String encodedUUID = Base64.getUrlEncoder().withoutPadding() + .encodeToString(byteBuffer.array()); + assertEquals(expectedEncodedString, encodedUUID); + } + + @Test + public void givenUUID_whenEncodingUsingApacheUtils_thenGiveExpectedEncodedString() { + String expectedEncodedString = "UUrxjPeTX8xsDDoxQOfGgw"; + byte[] bytes = Conversion.uuidToByteArray(originalUUID, new byte[16], 0, 16); + String encodedUUID = encodeBase64URLSafeString(bytes); + assertEquals(expectedEncodedString, encodedUUID); + } + + private byte[] convertToByteArray(UUID uuid) { + byte[] result = new byte[16]; + + long mostSignificantBits = uuid.getMostSignificantBits(); + fillByteArray(0, 8, result, mostSignificantBits); + + long leastSignificantBits = uuid.getLeastSignificantBits(); + fillByteArray(8, 16, result, leastSignificantBits); + + return result; + } + + private static void fillByteArray(int start, int end, byte[] result, long bits) { + for (int i = start; i < end; i++) { + int shift = i * 8; + result[i] = (byte) ((int) (255L & bits >> shift)); + } + } +} diff --git a/core-java-modules/core-java-uuid/src/test/java/com/ossez/uuid/UUIDPositiveLongGeneratorUnitTest.java b/core-java-modules/core-java-uuid/src/test/java/com/ossez/uuid/UUIDPositiveLongGeneratorUnitTest.java new file mode 100644 index 0000000000..e16c866c34 --- /dev/null +++ b/core-java-modules/core-java-uuid/src/test/java/com/ossez/uuid/UUIDPositiveLongGeneratorUnitTest.java @@ -0,0 +1,22 @@ +package com.ossez.uuid; + +import org.junit.jupiter.api.Test; + +import java.util.UUID; + +import static org.assertj.core.api.Assertions.assertThat; + +public class UUIDPositiveLongGeneratorUnitTest { + + @Test + public void whenGetMostSignificantBits_thenAssertPositive() { + long randomPositiveLong = Math.abs(UUID.randomUUID().getMostSignificantBits()); + assertThat(randomPositiveLong).isNotNegative(); + } + + @Test + public void whenGetLeastSignificantBits_thenAssertPositive() { + long randomPositiveLong = Math.abs(UUID.randomUUID().getLeastSignificantBits()); + assertThat(randomPositiveLong).isNotNegative(); + } +} diff --git a/core-java-modules/core-java-uuid/src/test/resources/logback.xml b/core-java-modules/core-java-uuid/src/test/resources/logback.xml new file mode 100644 index 0000000000..a076f8db47 --- /dev/null +++ b/core-java-modules/core-java-uuid/src/test/resources/logback.xml @@ -0,0 +1,18 @@ + + + + + %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n + + + + + + + + + + + + + \ No newline at end of file -- 2.45.2 From afc5ab001b6974fb693bd6fff1496c9600d1fd00 Mon Sep 17 00:00:00 2001 From: YuCheng Hu Date: Tue, 30 Apr 2024 09:21:11 -0400 Subject: [PATCH 09/13] =?UTF-8?q?core-java-lambdas=20=E9=A1=B9=E7=9B=AE?= =?UTF-8?q?=E6=B7=BB=E5=8A=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- core-java-modules/core-java-lambdas/README.md | 12 + core-java-modules/core-java-lambdas/pom.xml | 25 +++ .../com/baeldung/doublecolon/Computer.java | 85 +++++++ .../baeldung/doublecolon/ComputerUtils.java | 27 +++ .../com/baeldung/doublecolon/MacbookPro.java | 39 ++++ .../function/ComputerPredicate.java | 10 + .../doublecolon/function/TriFunction.java | 15 ++ .../java/com/baeldung/java8/entity/Human.java | 89 ++++++++ .../exceptions/LambdaExceptionWrappers.java | 62 ++++++ .../lambda/exceptions/ThrowingConsumer.java | 8 + .../com/baeldung/java8/lambda/tips/Bar.java | 16 ++ .../com/baeldung/java8/lambda/tips/Baz.java | 16 ++ .../com/baeldung/java8/lambda/tips/Foo.java | 11 + .../java8/lambda/tips/FooExtended.java | 11 + .../baeldung/java8/lambda/tips/Processor.java | 12 + .../java8/lambda/tips/ProcessorImpl.java | 20 ++ .../baeldung/java8/lambda/tips/UseFoo.java | 38 ++++ .../com/baeldung/lambdas/LambdaVariables.java | 88 ++++++++ .../src/main/resources/logback.xml | 13 ++ .../doublecolon/ComputerUtilsUnitTest.java | 91 ++++++++ .../FunctionalInterfaceUnitTest.java | 187 ++++++++++++++++ .../ShortToByteFunction.java | 8 + .../com/baeldung/java8/Java8SortUnitTest.java | 210 ++++++++++++++++++ .../LambdaExceptionWrappersUnitTest.java | 50 +++++ .../java8/lambda/methodreference/Bicycle.java | 34 +++ .../methodreference/BicycleComparator.java | 13 ++ .../MethodReferenceUnitTest.java | 79 +++++++ ...va8FunctionalInteracesLambdasUnitTest.java | 94 ++++++++ core-java-modules/pom.xml | 1 + 29 files changed, 1364 insertions(+) create mode 100644 core-java-modules/core-java-lambdas/README.md create mode 100644 core-java-modules/core-java-lambdas/pom.xml create mode 100644 core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/Computer.java create mode 100644 core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/ComputerUtils.java create mode 100644 core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/MacbookPro.java create mode 100644 core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/function/ComputerPredicate.java create mode 100644 core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/function/TriFunction.java create mode 100644 core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/entity/Human.java create mode 100644 core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/exceptions/LambdaExceptionWrappers.java create mode 100644 core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/exceptions/ThrowingConsumer.java create mode 100644 core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Bar.java create mode 100644 core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Baz.java create mode 100644 core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Foo.java create mode 100644 core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/FooExtended.java create mode 100644 core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Processor.java create mode 100644 core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/ProcessorImpl.java create mode 100644 core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/UseFoo.java create mode 100644 core-java-modules/core-java-lambdas/src/main/java/com/baeldung/lambdas/LambdaVariables.java create mode 100644 core-java-modules/core-java-lambdas/src/main/resources/logback.xml create mode 100644 core-java-modules/core-java-lambdas/src/test/java/com/baeldung/doublecolon/ComputerUtilsUnitTest.java create mode 100644 core-java-modules/core-java-lambdas/src/test/java/com/baeldung/functionalinterface/FunctionalInterfaceUnitTest.java create mode 100644 core-java-modules/core-java-lambdas/src/test/java/com/baeldung/functionalinterface/ShortToByteFunction.java create mode 100644 core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/Java8SortUnitTest.java create mode 100644 core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/exceptions/LambdaExceptionWrappersUnitTest.java create mode 100644 core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/Bicycle.java create mode 100644 core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/BicycleComparator.java create mode 100644 core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/MethodReferenceUnitTest.java create mode 100644 core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/tips/Java8FunctionalInteracesLambdasUnitTest.java diff --git a/core-java-modules/core-java-lambdas/README.md b/core-java-modules/core-java-lambdas/README.md new file mode 100644 index 0000000000..cad2097673 --- /dev/null +++ b/core-java-modules/core-java-lambdas/README.md @@ -0,0 +1,12 @@ +## Relevant articles: + +- [Why Do Local Variables Used in Lambdas Have to Be Final or Effectively Final?](https://www.baeldung.com/java-lambda-effectively-final-local-variables) +- [Java 8 – Powerful Comparison with Lambdas](http://www.baeldung.com/java-8-sort-lambda) +- [Functional Interfaces in Java 8](http://www.baeldung.com/java-8-functional-interfaces) +- [Lambda Expressions and Functional Interfaces: Tips and Best Practices](http://www.baeldung.com/java-8-lambda-expressions-tips) +- [Exceptions in Java 8 Lambda Expressions](http://www.baeldung.com/java-lambda-exceptions) +- [Method References in Java](https://www.baeldung.com/java-method-references) +- [The Double Colon Operator in Java 8](https://www.baeldung.com/java-8-double-colon-operator) +- [Serialize a Lambda in Java](https://www.baeldung.com/java-serialize-lambda) +- [Convert Anonymous Class into Lambda in Java](https://www.baeldung.com/java-from-anonymous-class-to-lambda) +- [When to Use Callable and Supplier in Java](https://www.baeldung.com/java-callable-vs-supplier) diff --git a/core-java-modules/core-java-lambdas/pom.xml b/core-java-modules/core-java-lambdas/pom.xml new file mode 100644 index 0000000000..0e6b049d2a --- /dev/null +++ b/core-java-modules/core-java-lambdas/pom.xml @@ -0,0 +1,25 @@ + + + 4.0.0 + core-java-lambdas + jar + core-java-lambdas + + + com.ossez.core-java-modules + core-java-modules + 0.0.2-SNAPSHOT + ../pom.xml + + + + + org.apache.commons + commons-lang3 + ${commons-lang3.version} + + + + \ No newline at end of file diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/Computer.java b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/Computer.java new file mode 100644 index 0000000000..dc0b064013 --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/Computer.java @@ -0,0 +1,85 @@ +package com.baeldung.doublecolon; + +public class Computer { + + private Integer age; + private String color; + private Integer healty; + + Computer(final int age, final String color) { + this.age = age; + this.color = color; + } + + Computer(final Integer age, final String color, final Integer healty) { + this.age = age; + this.color = color; + this.healty = healty; + } + + public Computer() { + } + + public Integer getAge() { + return age; + } + + public void setAge(final Integer age) { + this.age = age; + } + + String getColor() { + return color; + } + + public void setColor(final String color) { + this.color = color; + } + + Integer getHealty() { + return healty; + } + + void setHealty(final Integer healty) { + this.healty = healty; + } + + public void turnOnPc() { + System.out.println("Computer turned on"); + } + + public void turnOffPc() { + System.out.println("Computer turned off"); + } + + public Double calculateValue(Double initialValue) { + return initialValue / 1.50; + } + + @Override + public String toString() { + return "Computer{" + "age=" + age + ", color='" + color + '\'' + ", healty=" + healty + '}'; + } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + + final Computer computer = (Computer) o; + + return (age != null ? age.equals(computer.age) : computer.age == null) && (color != null ? color.equals(computer.color) : computer.color == null); + + } + + @Override + public int hashCode() { + int result = age != null ? age.hashCode() : 0; + result = 31 * result + (color != null ? color.hashCode() : 0); + return result; + } +} diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/ComputerUtils.java b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/ComputerUtils.java new file mode 100644 index 0000000000..ea274072ea --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/ComputerUtils.java @@ -0,0 +1,27 @@ +package com.baeldung.doublecolon; + +import java.util.ArrayList; +import java.util.List; + +import com.baeldung.doublecolon.function.ComputerPredicate; + +public class ComputerUtils { + + static final ComputerPredicate after2010Predicate = (c) -> (c.getAge() > 2010); + static final ComputerPredicate blackPredicate = (c) -> "black".equals(c.getColor()); + + public static List filter(final List inventory, final ComputerPredicate p) { + + final List result = new ArrayList<>(); + inventory.stream().filter(p::filter).forEach(result::add); + + return result; + } + + static void repair(final Computer computer) { + if (computer.getHealty() < 50) { + computer.setHealty(100); + } + } + +} diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/MacbookPro.java b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/MacbookPro.java new file mode 100644 index 0000000000..79c8d9e383 --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/MacbookPro.java @@ -0,0 +1,39 @@ +package com.baeldung.doublecolon; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.function.Function; + +public class MacbookPro extends Computer { + + private static final Logger LOG = LoggerFactory.getLogger(MacbookPro.class); + + public MacbookPro(int age, String color) { + super(age, color); + } + + MacbookPro(Integer age, String color, Integer healty) { + super(age, color, healty); + } + + @Override + public void turnOnPc() { + LOG.debug("MacbookPro turned on"); + } + + @Override + public void turnOffPc() { + LOG.debug("MacbookPro turned off"); + } + + @Override + public Double calculateValue(Double initialValue) { + + Function function = super::calculateValue; + final Double pcValue = function.apply(initialValue); + LOG.debug("First value is:" + pcValue); + return pcValue + (initialValue / 10); + + } +} diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/function/ComputerPredicate.java b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/function/ComputerPredicate.java new file mode 100644 index 0000000000..5ce491e86a --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/function/ComputerPredicate.java @@ -0,0 +1,10 @@ +package com.baeldung.doublecolon.function; + +import com.baeldung.doublecolon.Computer; + +@FunctionalInterface +public interface ComputerPredicate { + + boolean filter(Computer c); + +} diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/function/TriFunction.java b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/function/TriFunction.java new file mode 100644 index 0000000000..d0d6299479 --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/function/TriFunction.java @@ -0,0 +1,15 @@ +package com.baeldung.doublecolon.function; + +import java.util.Objects; +import java.util.function.Function; + +@FunctionalInterface +public interface TriFunction { + + R apply(A a, B b, C c); + + default TriFunction andThen(final Function after) { + Objects.requireNonNull(after); + return (final A a, final B b, final C c) -> after.apply(apply(a, b, c)); + } +} \ No newline at end of file diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/entity/Human.java b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/entity/Human.java new file mode 100644 index 0000000000..98e35d0af2 --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/entity/Human.java @@ -0,0 +1,89 @@ +package com.baeldung.java8.entity; + +public class Human { + private String name; + private int age; + + public Human() { + super(); + } + + public Human(final String name, final int age) { + super(); + + this.name = name; + this.age = age; + } + + // API + + public String getName() { + return name; + } + + public void setName(final String name) { + this.name = name; + } + + public int getAge() { + return age; + } + + public void setAge(final int age) { + this.age = age; + } + + // compare + + public static int compareByNameThenAge(final Human lhs, final Human rhs) { + if (lhs.name.equals(rhs.name)) { + return Integer.compare(lhs.age, rhs.age); + } else { + return lhs.name.compareTo(rhs.name); + } + } + + // + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + age; + result = prime * result + ((name == null) ? 0 : name.hashCode()); + return result; + } + + @Override + public boolean equals(final Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + final Human other = (Human) obj; + if (age != other.age) { + return false; + } + if (name == null) { + if (other.name != null) { + return false; + } + } else if (!name.equals(other.name)) { + return false; + } + return true; + } + + @Override + public String toString() { + final StringBuilder builder = new StringBuilder(); + builder.append("Human [name=").append(name).append(", age=").append(age).append("]"); + return builder.toString(); + } + +} diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/exceptions/LambdaExceptionWrappers.java b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/exceptions/LambdaExceptionWrappers.java new file mode 100644 index 0000000000..db710589e7 --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/exceptions/LambdaExceptionWrappers.java @@ -0,0 +1,62 @@ +package com.baeldung.java8.lambda.exceptions; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.function.Consumer; + +public class LambdaExceptionWrappers { + + private static final Logger LOGGER = LoggerFactory.getLogger(LambdaExceptionWrappers.class); + + public static Consumer lambdaWrapper(Consumer consumer) { + return i -> { + try { + consumer.accept(i); + } catch (ArithmeticException e) { + LOGGER.error("Arithmetic Exception occurred.", e); + } + }; + } + + static Consumer consumerWrapper(Consumer consumer, Class clazz) { + return i -> { + try { + consumer.accept(i); + } catch (Exception ex) { + try { + E exCast = clazz.cast(ex); + LOGGER.error("Exception occurred.", exCast); + } catch (ClassCastException ccEx) { + throw ex; + } + } + }; + } + + public static Consumer throwingConsumerWrapper(ThrowingConsumer throwingConsumer) { + return i -> { + try { + throwingConsumer.accept(i); + } catch (Exception ex) { + throw new RuntimeException(ex); + } + }; + } + + public static Consumer handlingConsumerWrapper(ThrowingConsumer throwingConsumer, Class exceptionClass) { + return i -> { + try { + throwingConsumer.accept(i); + } catch (Exception ex) { + try { + E exCast = exceptionClass.cast(ex); + LOGGER.error("Exception occurred.", exCast); + } catch (ClassCastException ccEx) { + throw new RuntimeException(ex); + } + } + }; + } + +} \ No newline at end of file diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/exceptions/ThrowingConsumer.java b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/exceptions/ThrowingConsumer.java new file mode 100644 index 0000000000..c5860e7f6b --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/exceptions/ThrowingConsumer.java @@ -0,0 +1,8 @@ +package com.baeldung.java8.lambda.exceptions; + +@FunctionalInterface +public interface ThrowingConsumer { + + void accept(T t) throws E; + +} \ No newline at end of file diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Bar.java b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Bar.java new file mode 100644 index 0000000000..3ee78bd7a3 --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Bar.java @@ -0,0 +1,16 @@ +package com.baeldung.java8.lambda.tips; + + +@FunctionalInterface +public interface Bar { + + String method(String string); + + default String defaultBar() { + return "Default String from Bar"; + } + + default String defaultCommon() { + return "Default Common from Bar"; + } +} diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Baz.java b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Baz.java new file mode 100644 index 0000000000..1e1e9ae094 --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Baz.java @@ -0,0 +1,16 @@ +package com.baeldung.java8.lambda.tips; + + +@FunctionalInterface +public interface Baz { + + String method(String string); + + default String defaultBaz() { + return "Default String from Baz"; + } + + default String defaultCommon(){ + return "Default Common from Baz"; + } +} diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Foo.java b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Foo.java new file mode 100644 index 0000000000..b63ba61e7e --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Foo.java @@ -0,0 +1,11 @@ +package com.baeldung.java8.lambda.tips; + + +@FunctionalInterface +public interface Foo { + + String method(String string); + + default void defaultMethod() { + } +} diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/FooExtended.java b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/FooExtended.java new file mode 100644 index 0000000000..27ab86dca3 --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/FooExtended.java @@ -0,0 +1,11 @@ +package com.baeldung.java8.lambda.tips; + + +@FunctionalInterface +public interface FooExtended extends Baz, Bar { + + @Override + default String defaultCommon() { + return Bar.super.defaultCommon(); + } +} diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Processor.java b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Processor.java new file mode 100644 index 0000000000..7931129cf5 --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Processor.java @@ -0,0 +1,12 @@ +package com.baeldung.java8.lambda.tips; + +import java.util.concurrent.Callable; +import java.util.function.Supplier; + +public interface Processor { + + String processWithCallable(Callable c) throws Exception; + + String processWithSupplier(Supplier s); + +} diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/ProcessorImpl.java b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/ProcessorImpl.java new file mode 100644 index 0000000000..cb1b3dcdd2 --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/ProcessorImpl.java @@ -0,0 +1,20 @@ +package com.baeldung.java8.lambda.tips; + + +import java.util.concurrent.Callable; +import java.util.function.Consumer; +import java.util.function.Function; +import java.util.function.Supplier; + +public class ProcessorImpl implements Processor { + + @Override + public String processWithCallable(Callable c) throws Exception { + return c.call(); + } + + @Override + public String processWithSupplier(Supplier s) { + return s.get(); + } +} diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/UseFoo.java b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/UseFoo.java new file mode 100644 index 0000000000..a64d8bb920 --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/UseFoo.java @@ -0,0 +1,38 @@ +package com.baeldung.java8.lambda.tips; + + +import java.util.function.Function; + +public class UseFoo { + + private String value = "Enclosing scope value"; + + public String add(final String string, final Foo foo) { + return foo.method(string); + } + + public String addWithStandardFI(final String string, final Function fn) { + return fn.apply(string); + } + + public String scopeExperiment() { + final Foo fooIC = new Foo() { + String value = "Inner class value"; + + @Override + public String method(final String string) { + return value; + } + }; + final String resultIC = fooIC.method(""); + + final Foo fooLambda = parameter -> { + final String value = "Lambda value"; + return this.value; + }; + final String resultLambda = fooLambda.method(""); + + return "Results: resultIC = " + resultIC + ", resultLambda = " + resultLambda; + } + +} diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/lambdas/LambdaVariables.java b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/lambdas/LambdaVariables.java new file mode 100644 index 0000000000..5c1201150f --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/lambdas/LambdaVariables.java @@ -0,0 +1,88 @@ +package com.baeldung.lambdas; + +import java.util.Random; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.function.Supplier; +import java.util.stream.IntStream; + +/** + * Class with examples about working with capturing lambdas. + */ +public class LambdaVariables { + + private volatile boolean run = true; + private int start = 0; + + private ExecutorService executor = Executors.newFixedThreadPool(3); + + public static void main(String[] args) { + new LambdaVariables().localVariableMultithreading(); + } + + Supplier incrementer(int start) { + return () -> start; // can't modify start parameter inside the lambda + } + + Supplier incrementer() { + return () -> start++; + } + + public void localVariableMultithreading() { + boolean run = true; + executor.execute(() -> { + while (run) { + // do operation + } + }); + // commented because it doesn't compile, it's just an example of non-final local variables in lambdas + // run = false; + } + + public void instanceVariableMultithreading() { + executor.execute(() -> { + while (run) { + // do operation + } + }); + + run = false; + } + + /** + * WARNING: always avoid this workaround!! + */ + public void workaroundSingleThread() { + int[] holder = new int[] { 2 }; + IntStream sums = IntStream + .of(1, 2, 3) + .map(val -> val + holder[0]); + + holder[0] = 0; + + System.out.println(sums.sum()); + } + + /** + * WARNING: always avoid this workaround!! + */ + public void workaroundMultithreading() { + int[] holder = new int[] { 2 }; + Runnable runnable = () -> System.out.println(IntStream + .of(1, 2, 3) + .map(val -> val + holder[0]) + .sum()); + + new Thread(runnable).start(); + + // simulating some processing + try { + Thread.sleep(new Random().nextInt(3) * 1000L); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + + holder[0] = 0; + } + +} diff --git a/core-java-modules/core-java-lambdas/src/main/resources/logback.xml b/core-java-modules/core-java-lambdas/src/main/resources/logback.xml new file mode 100644 index 0000000000..7d900d8ea8 --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/main/resources/logback.xml @@ -0,0 +1,13 @@ + + + + + %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n + + + + + + + + \ No newline at end of file diff --git a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/doublecolon/ComputerUtilsUnitTest.java b/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/doublecolon/ComputerUtilsUnitTest.java new file mode 100644 index 0000000000..7157dead6e --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/doublecolon/ComputerUtilsUnitTest.java @@ -0,0 +1,91 @@ +package com.baeldung.doublecolon; + +import com.baeldung.doublecolon.function.TriFunction; +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import java.util.Arrays; +import java.util.Comparator; +import java.util.List; +import java.util.function.BiFunction; + +import static com.baeldung.doublecolon.ComputerUtils.*; + +public class ComputerUtilsUnitTest { + + @Before + public void setup() { + } + + @After + public void tearDown() { + } + + @Test + public void testConstructorReference() { + + Computer c1 = new Computer(2015, "white"); + Computer c2 = new Computer(2009, "black"); + Computer c3 = new Computer(2014, "black"); + + BiFunction c4Function = Computer::new; + Computer c4 = c4Function.apply(2013, "white"); + BiFunction c5Function = Computer::new; + Computer c5 = c5Function.apply(2010, "black"); + BiFunction c6Function = Computer::new; + Computer c6 = c6Function.apply(2008, "black"); + + List inventory = Arrays.asList(c1, c2, c3, c4, c5, c6); + + List blackComputer = filter(inventory, blackPredicate); + Assert.assertEquals("The black Computers are: ", blackComputer.size(), 4); + + List after2010Computer = filter(inventory, after2010Predicate); + Assert.assertEquals("The Computer bought after 2010 are: ", after2010Computer.size(), 3); + + List before2011Computer = filter(inventory, c -> c.getAge() < 2011); + Assert.assertEquals("The Computer bought before 2011 are: ", before2011Computer.size(), 3); + + inventory.sort(Comparator.comparing(Computer::getAge)); + + Assert.assertEquals("Oldest Computer in inventory", c6, inventory.get(0)); + + } + + @Test + public void testStaticMethodReference() { + + Computer c1 = new Computer(2015, "white", 35); + Computer c2 = new Computer(2009, "black", 65); + TriFunction c6Function = Computer::new; + Computer c3 = c6Function.apply(2008, "black", 90); + + List inventory = Arrays.asList(c1, c2, c3); + inventory.forEach(ComputerUtils::repair); + + Assert.assertEquals("Computer repaired", new Integer(100), c1.getHealty()); + } + + @Test + public void testInstanceMethodArbitraryObjectParticularType() { + + Computer c1 = new Computer(2015, "white", 35); + Computer c2 = new MacbookPro(2009, "black", 65); + List inventory = Arrays.asList(c1, c2); + inventory.forEach(Computer::turnOnPc); + + } + + @Test + public void testSuperMethodReference() { + + final TriFunction integerStringIntegerObjectTriFunction = MacbookPro::new; + final MacbookPro macbookPro = integerStringIntegerObjectTriFunction.apply(2010, "black", 100); + Double initialValue = 999.99; + final Double actualValue = macbookPro.calculateValue(initialValue); + Assert.assertEquals(766.659, actualValue, 0.0); + } + +} diff --git a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/functionalinterface/FunctionalInterfaceUnitTest.java b/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/functionalinterface/FunctionalInterfaceUnitTest.java new file mode 100644 index 0000000000..e91cbfcb75 --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/functionalinterface/FunctionalInterfaceUnitTest.java @@ -0,0 +1,187 @@ +package com.baeldung.functionalinterface; + +import com.google.common.util.concurrent.Uninterruptibles; +import org.junit.Test; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +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 static org.junit.Assert.*; + +public class FunctionalInterfaceUnitTest { + + private static final Logger LOG = LoggerFactory.getLogger(FunctionalInterfaceUnitTest.class); + + @Test + public void whenPassingLambdaToComputeIfAbsent_thenTheValueGetsComputedAndPutIntoMap() { + Map nameMap = new HashMap<>(); + Integer value = nameMap.computeIfAbsent("John", String::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); + } + + @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) -> name.equals("Freddy") ? oldValue : 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(() -> LOG.debug("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 -> LOG.debug("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) -> LOG.debug(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(0, (i1, i2) -> i1 + i2); + + 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)); + + } + + @Test + public void whenUsingSupplierToGenerateValue_thenValueIsGeneratedLazily() { + + Supplier lazyValue = () -> { + Uninterruptibles.sleepUninterruptibly(1000, TimeUnit.MILLISECONDS); + return 9d; + }; + + double valueSquared = squareLazy(lazyValue); + + assertEquals(81d, valueSquared, 0); + + } + + // + + public double squareLazy(Supplier lazyValue) { + return Math.pow(lazyValue.get(), 2); + } + + 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; + } + +} diff --git a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/functionalinterface/ShortToByteFunction.java b/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/functionalinterface/ShortToByteFunction.java new file mode 100644 index 0000000000..3231d6244f --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/functionalinterface/ShortToByteFunction.java @@ -0,0 +1,8 @@ +package com.baeldung.functionalinterface; + +@FunctionalInterface +public interface ShortToByteFunction { + + byte applyAsByte(short s); + +} diff --git a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/Java8SortUnitTest.java b/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/Java8SortUnitTest.java new file mode 100644 index 0000000000..e5f876c84b --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/Java8SortUnitTest.java @@ -0,0 +1,210 @@ +package com.baeldung.java8; + +import com.baeldung.java8.entity.Human; +import com.google.common.collect.Lists; +import com.google.common.primitives.Ints; +import org.junit.Assert; +import org.junit.Test; + +import java.util.Collections; +import java.util.Comparator; +import java.util.List; +import java.util.stream.Collectors; + +import static org.hamcrest.Matchers.equalTo; + +public class Java8SortUnitTest { + + // tests - + + @Test + public final void givenPreLambda_whenSortingEntitiesByName_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); + + Collections.sort(humans, new Comparator() { + @Override + public final int compare(final Human h1, final Human h2) { + return h1.getName().compareTo(h2.getName()); + } + }); + + Assert.assertThat(humans.get(0), equalTo(new Human("Jack", 12))); + } + + @Test + public final void whenSortingEntitiesByName_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); + + humans.sort((final Human h1, final Human h2) -> h1.getName().compareTo(h2.getName())); + + Assert.assertThat(humans.get(0), equalTo(new Human("Jack", 12))); + } + + @Test + public final void givenLambdaShortForm_whenSortingEntitiesByName_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); + + humans.sort((h1, h2) -> h1.getName().compareTo(h2.getName())); + + Assert.assertThat(humans.get(0), equalTo(new Human("Jack", 12))); + } + + @Test + public final void whenSortingEntitiesByNameThenAge_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 12), new Human("Sarah", 10), new Human("Zack", 12)); + humans.sort((lhs, rhs) -> { + if (lhs.getName().equals(rhs.getName())) { + return Integer.compare(lhs.getAge(), rhs.getAge()); + } else { + return lhs.getName().compareTo(rhs.getName()); + } + }); + Assert.assertThat(humans.get(0), equalTo(new Human("Sarah", 10))); + } + + @Test + public final void givenCompositionVerbose_whenSortingEntitiesByNameThenAge_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 12), new Human("Sarah", 10), new Human("Zack", 12)); + final Comparator byName = (h1, h2) -> h1.getName().compareTo(h2.getName()); + final Comparator byAge = (h1, h2) -> Ints.compare(h1.getAge(), h2.getAge()); + + humans.sort(byName.thenComparing(byAge)); + Assert.assertThat(humans.get(0), equalTo(new Human("Sarah", 10))); + } + + @Test + public final void givenComposition_whenSortingEntitiesByNameThenAge_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 12), new Human("Sarah", 10), new Human("Zack", 12)); + + humans.sort(Comparator.comparing(Human::getName).thenComparing(Human::getAge)); + Assert.assertThat(humans.get(0), equalTo(new Human("Sarah", 10))); + } + + @Test + public final void whenSortingEntitiesByAge_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); + + humans.sort((h1, h2) -> Ints.compare(h1.getAge(), h2.getAge())); + Assert.assertThat(humans.get(0), equalTo(new Human("Sarah", 10))); + } + + @Test + public final void whenSortingEntitiesByNameReversed_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); + final Comparator comparator = (h1, h2) -> h1.getName().compareTo(h2.getName()); + + humans.sort(comparator.reversed()); + Assert.assertThat(humans.get(0), equalTo(new Human("Sarah", 10))); + } + + @Test + public final void givenMethodDefinition_whenSortingEntitiesByNameThenAge_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); + + humans.sort(Human::compareByNameThenAge); + Assert.assertThat(humans.get(0), equalTo(new Human("Jack", 12))); + } + + @Test + public final void givenInstanceMethod_whenSortingEntitiesByName_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); + + humans.sort(Comparator.comparing(Human::getName)); + Assert.assertThat(humans.get(0), equalTo(new Human("Jack", 12))); + } + + @Test + public final void givenStreamNaturalOrdering_whenSortingEntitiesByName_thenCorrectlySorted() { + final List letters = Lists.newArrayList("B", "A", "C"); + + final List sortedLetters = letters.stream().sorted().collect(Collectors.toList()); + Assert.assertThat(sortedLetters.get(0), equalTo("A")); + } + + @Test + public final void givenStreamCustomOrdering_whenSortingEntitiesByName_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); + final Comparator nameComparator = (h1, h2) -> h1.getName().compareTo(h2.getName()); + + final List sortedHumans = humans.stream().sorted(nameComparator).collect(Collectors.toList()); + Assert.assertThat(sortedHumans.get(0), equalTo(new Human("Jack", 12))); + } + + @Test + public final void givenStreamComparatorOrdering_whenSortingEntitiesByName_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); + + final List sortedHumans = humans.stream().sorted(Comparator.comparing(Human::getName)).collect(Collectors.toList()); + Assert.assertThat(sortedHumans.get(0), equalTo(new Human("Jack", 12))); + } + + @Test + public final void givenStreamNaturalOrdering_whenSortingEntitiesByNameReversed_thenCorrectlySorted() { + final List letters = Lists.newArrayList("B", "A", "C"); + + final List reverseSortedLetters = letters.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList()); + Assert.assertThat(reverseSortedLetters.get(0), equalTo("C")); + } + + @Test + public final void givenStreamCustomOrdering_whenSortingEntitiesByNameReversed_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); + final Comparator reverseNameComparator = (h1, h2) -> h2.getName().compareTo(h1.getName()); + + final List reverseSortedHumans = humans.stream().sorted(reverseNameComparator).collect(Collectors.toList()); + Assert.assertThat(reverseSortedHumans.get(0), equalTo(new Human("Sarah", 10))); + } + + @Test + public final void givenStreamComparatorOrdering_whenSortingEntitiesByNameReversed_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); + + final List reverseSortedHumans = humans.stream().sorted(Comparator.comparing(Human::getName, Comparator.reverseOrder())).collect(Collectors.toList()); + Assert.assertThat(reverseSortedHumans.get(0), equalTo(new Human("Sarah", 10))); + } + + @Test(expected = NullPointerException.class) + public final void givenANullElement_whenSortingEntitiesByName_thenThrowsNPE() { + final List humans = Lists.newArrayList(null, new Human("Jack", 12)); + + humans.sort((h1, h2) -> h1.getName().compareTo(h2.getName())); + } + + @Test + public final void givenANullElement_whenSortingEntitiesByNameManually_thenMovesTheNullToLast() { + final List humans = Lists.newArrayList(null, new Human("Jack", 12), null); + + humans.sort((h1, h2) -> { + if (h1 == null) return h2 == null ? 0 : 1; + else if (h2 == null) return -1; + + return h1.getName().compareTo(h2.getName()); + }); + + Assert.assertNotNull(humans.get(0)); + Assert.assertNull(humans.get(1)); + Assert.assertNull(humans.get(2)); + } + + @Test + public final void givenANullElement_whenSortingEntitiesByName_thenMovesTheNullToLast() { + final List humans = Lists.newArrayList(null, new Human("Jack", 12), null); + + humans.sort(Comparator.nullsLast(Comparator.comparing(Human::getName))); + + Assert.assertNotNull(humans.get(0)); + Assert.assertNull(humans.get(1)); + Assert.assertNull(humans.get(2)); + } + + @Test + public final void givenANullElement_whenSortingEntitiesByName_thenMovesTheNullToStart() { + final List humans = Lists.newArrayList(null, new Human("Jack", 12), null); + + humans.sort(Comparator.nullsFirst(Comparator.comparing(Human::getName))); + + Assert.assertNull(humans.get(0)); + Assert.assertNull(humans.get(1)); + Assert.assertNotNull(humans.get(2)); + } +} diff --git a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/exceptions/LambdaExceptionWrappersUnitTest.java b/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/exceptions/LambdaExceptionWrappersUnitTest.java new file mode 100644 index 0000000000..fe10266043 --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/exceptions/LambdaExceptionWrappersUnitTest.java @@ -0,0 +1,50 @@ +package com.baeldung.java8.lambda.exceptions; + +import org.junit.Before; +import org.junit.Test; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.io.IOException; +import java.util.Arrays; +import java.util.List; + +import static com.baeldung.java8.lambda.exceptions.LambdaExceptionWrappers.*; + +public class LambdaExceptionWrappersUnitTest { + + private static final Logger LOG = LoggerFactory.getLogger(LambdaExceptionWrappersUnitTest.class); + + private List integers; + + @Before + public void init() { + integers = Arrays.asList(3, 9, 7, 0, 10, 20); + } + + @Test + public void whenNoExceptionFromLambdaWrapper_thenSuccess() { + integers.forEach(lambdaWrapper(i -> LOG.debug("{}", 50 / i))); + } + + @Test + public void whenNoExceptionFromConsumerWrapper_thenSuccess() { + integers.forEach(consumerWrapper(i -> LOG.debug("{}", 50 / i), ArithmeticException.class)); + } + + @Test(expected = RuntimeException.class) + public void whenExceptionFromThrowingConsumerWrapper_thenSuccess() { + integers.forEach(throwingConsumerWrapper(i -> writeToFile(i))); + } + + @Test + public void whenNoExceptionFromHandlingConsumerWrapper_thenSuccess() { + integers.forEach(handlingConsumerWrapper(i -> writeToFile(i), IOException.class)); + } + + private void writeToFile(Integer i) throws IOException { + if (i == 0) { + throw new IOException(); // mock IOException + } + } +} diff --git a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/Bicycle.java b/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/Bicycle.java new file mode 100644 index 0000000000..26f9f8bc46 --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/Bicycle.java @@ -0,0 +1,34 @@ +package com.baeldung.java8.lambda.methodreference; + +public class Bicycle { + + private String brand; + private Integer frameSize; + + public Bicycle(String brand) { + this.brand = brand; + this.frameSize = 0; + } + + public Bicycle(String brand, Integer frameSize) { + this.brand = brand; + this.frameSize = frameSize; + } + + public String getBrand() { + return brand; + } + + public void setBrand(String brand) { + this.brand = brand; + } + + public Integer getFrameSize() { + return frameSize; + } + + public void setFrameSize(Integer frameSize) { + this.frameSize = frameSize; + } + +} diff --git a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/BicycleComparator.java b/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/BicycleComparator.java new file mode 100644 index 0000000000..153a7d105a --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/BicycleComparator.java @@ -0,0 +1,13 @@ +package com.baeldung.java8.lambda.methodreference; + +import java.util.Comparator; + +public class BicycleComparator implements Comparator { + + @Override + public int compare(Bicycle a, Bicycle b) { + return a.getFrameSize() + .compareTo(b.getFrameSize()); + } + +} diff --git a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/MethodReferenceUnitTest.java b/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/MethodReferenceUnitTest.java new file mode 100644 index 0000000000..87c01c3ded --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/MethodReferenceUnitTest.java @@ -0,0 +1,79 @@ +package com.baeldung.java8.lambda.methodreference; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.BiFunction; + +import org.apache.commons.lang3.StringUtils; +import org.junit.Test; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class MethodReferenceUnitTest { + + private static final Logger LOGGER = LoggerFactory.getLogger(MethodReferenceUnitTest.class); + + private static void doNothingAtAll(Object... o) { + } + + @Test + public void referenceToStaticMethod() { + List messages = Arrays.asList("Hello", "Baeldung", "readers!"); + messages.forEach(word -> StringUtils.capitalize(word)); + messages.forEach(StringUtils::capitalize); + } + + @Test + public void referenceToInstanceMethodOfParticularObject() { + BicycleComparator bikeFrameSizeComparator = new BicycleComparator(); + createBicyclesList().stream() + .sorted((a, b) -> bikeFrameSizeComparator.compare(a, b)); + createBicyclesList().stream() + .sorted(bikeFrameSizeComparator::compare); + } + + @Test + public void referenceToInstanceMethodOfArbitratyObjectOfParticularType() { + List numbers = Arrays.asList(5, 3, 50, 24, 40, 2, 9, 18); + numbers.stream() + .sorted((a, b) -> a.compareTo(b)); + numbers.stream() + .sorted(Integer::compareTo); + } + + @Test + public void referenceToConstructor() { + BiFunction bikeCreator = (brand, frameSize) -> new Bicycle(brand, frameSize); + BiFunction bikeCreatorMethodReference = Bicycle::new; + List bikes = new ArrayList<>(); + bikes.add(bikeCreator.apply("Giant", 50)); + bikes.add(bikeCreator.apply("Scott", 20)); + bikes.add(bikeCreatorMethodReference.apply("Trek", 35)); + bikes.add(bikeCreatorMethodReference.apply("GT", 40)); + } + + @Test + public void referenceToConstructorSimpleExample() { + List bikeBrands = Arrays.asList("Giant", "Scott", "Trek", "GT"); + bikeBrands.stream() + .map(Bicycle::new) + .toArray(Bicycle[]::new); + } + + @Test + public void limitationsAndAdditionalExamples() { + createBicyclesList().forEach(b -> LOGGER.debug("Bike brand is '{}' and frame size is '{}'", b.getBrand(), b.getFrameSize())); + createBicyclesList().forEach((o) -> MethodReferenceUnitTest.doNothingAtAll(o)); + } + + private List createBicyclesList() { + List bikes = new ArrayList<>(); + bikes.add(new Bicycle("Giant", 50)); + bikes.add(new Bicycle("Scott", 20)); + bikes.add(new Bicycle("Trek", 35)); + bikes.add(new Bicycle("GT", 40)); + return bikes; + } + +} diff --git a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/tips/Java8FunctionalInteracesLambdasUnitTest.java b/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/tips/Java8FunctionalInteracesLambdasUnitTest.java new file mode 100644 index 0000000000..acc3bc8fa3 --- /dev/null +++ b/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/tips/Java8FunctionalInteracesLambdasUnitTest.java @@ -0,0 +1,94 @@ +package com.baeldung.java8.lambda.tips; + +import com.baeldung.java8.lambda.tips.Foo; +import com.baeldung.java8.lambda.tips.FooExtended; +import com.baeldung.java8.lambda.tips.UseFoo; +import org.junit.Before; +import org.junit.Test; + +import java.util.function.Function; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotEquals; + +public class Java8FunctionalInteracesLambdasUnitTest { + + private UseFoo useFoo; + + @Before + public void init() { + useFoo = new UseFoo(); + } + + @Test + public void functionalInterfaceInstantiation_whenReturnDefiniteString_thenCorrect() { + final Foo foo = parameter -> parameter + "from lambda"; + final String result = useFoo.add("Message ", foo); + + assertEquals("Message from lambda", result); + } + + @Test + public void standardFIParameter_whenReturnDefiniteString_thenCorrect() { + final Function fn = parameter -> parameter + "from lambda"; + final String result = useFoo.addWithStandardFI("Message ", fn); + + assertEquals("Message from lambda", result); + } + + @Test + public void defaultMethodFromExtendedInterface_whenReturnDefiniteString_thenCorrect() { + final FooExtended fooExtended = string -> string; + final String result = fooExtended.defaultCommon(); + + assertEquals("Default Common from Bar", result); + } + + @Test + public void lambdaAndInnerClassInstantiation_whenReturnSameString_thenCorrect() { + final Foo foo = parameter -> parameter + "from Foo"; + + final Foo fooByIC = new Foo() { + @Override + public String method(final String string) { + return string + "from Foo"; + } + }; + + assertEquals(foo.method("Something "), fooByIC.method("Something ")); + } + + @Test + public void accessVariablesFromDifferentScopes_whenReturnPredefinedString_thenCorrect() { + assertEquals("Results: resultIC = Inner class value, resultLambda = Enclosing scope value", useFoo.scopeExperiment()); + } + + @Test + public void shorteningLambdas_whenReturnEqualsResults_thenCorrect() { + final Foo foo = parameter -> buildString(parameter); + + final Foo fooHuge = parameter -> { + final String result = "Something " + parameter; + // many lines of code + return result; + }; + + assertEquals(foo.method("Something"), fooHuge.method("Something")); + } + + private String buildString(final String parameter) { + final String result = "Something " + parameter; + // many lines of code + return result; + } + + @Test + public void mutatingOfEffectivelyFinalVariable_whenNotEquals_thenCorrect() { + final int[] total = new int[1]; + final Runnable r = () -> total[0]++; + r.run(); + + assertNotEquals(0, total[0]); + } + +} diff --git a/core-java-modules/pom.xml b/core-java-modules/pom.xml index cfb968235b..ade1ebdbd8 100644 --- a/core-java-modules/pom.xml +++ b/core-java-modules/pom.xml @@ -32,6 +32,7 @@ core-java-datetime-conversion core-java-io core-java-io-2 + core-java-lambdas core-java-serialization core-java-streams core-java-streams -- 2.45.2 From 26712ab8211051502fab5ab31110a300962c3a3d Mon Sep 17 00:00:00 2001 From: YuCheng Hu Date: Tue, 30 Apr 2024 09:21:19 -0400 Subject: [PATCH 10/13] =?UTF-8?q?core-java-lambdas=20=E9=A1=B9=E7=9B=AE?= =?UTF-8?q?=E6=B7=BB=E5=8A=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .idea/compiler.xml | 1 + .idea/encodings.xml | 1 + 2 files changed, 2 insertions(+) diff --git a/.idea/compiler.xml b/.idea/compiler.xml index e1211661e8..fd6687cea8 100644 --- a/.idea/compiler.xml +++ b/.idea/compiler.xml @@ -18,6 +18,7 @@ + diff --git a/.idea/encodings.xml b/.idea/encodings.xml index 485ea4d754..9cb0625105 100644 --- a/.idea/encodings.xml +++ b/.idea/encodings.xml @@ -33,6 +33,7 @@ + -- 2.45.2 From 80c4ccc441acce338aa3db5b1041248942d648be Mon Sep 17 00:00:00 2001 From: YuCheng Hu Date: Tue, 30 Apr 2024 09:28:47 -0400 Subject: [PATCH 11/13] core-java-lambdas up date package for ossez --- .idea/encodings.xml | 1 + .../com/{baeldung => ossez}/doublecolon/Computer.java | 2 +- .../{baeldung => ossez}/doublecolon/ComputerUtils.java | 4 ++-- .../com/{baeldung => ossez}/doublecolon/MacbookPro.java | 2 +- .../doublecolon/function/ComputerPredicate.java | 4 ++-- .../doublecolon/function/TriFunction.java | 2 +- .../java/com/{baeldung => ossez}/java8/entity/Human.java | 2 +- .../java8/lambda/exceptions/LambdaExceptionWrappers.java | 2 +- .../java8/lambda/exceptions/ThrowingConsumer.java | 2 +- .../com/{baeldung => ossez}/java8/lambda/tips/Bar.java | 2 +- .../com/{baeldung => ossez}/java8/lambda/tips/Baz.java | 2 +- .../com/{baeldung => ossez}/java8/lambda/tips/Foo.java | 2 +- .../java8/lambda/tips/FooExtended.java | 2 +- .../{baeldung => ossez}/java8/lambda/tips/Processor.java | 2 +- .../java8/lambda/tips/ProcessorImpl.java | 4 +--- .../{baeldung => ossez}/java8/lambda/tips/UseFoo.java | 2 +- .../com/{baeldung => ossez}/lambdas/LambdaVariables.java | 2 +- .../doublecolon/ComputerUtilsUnitTest.java | 9 ++++++--- .../functionalinterface/FunctionalInterfaceUnitTest.java | 2 +- .../functionalinterface/ShortToByteFunction.java | 2 +- .../com/{baeldung => ossez}/java8/Java8SortUnitTest.java | 4 ++-- .../exceptions/LambdaExceptionWrappersUnitTest.java | 4 ++-- .../java8/lambda/methodreference/Bicycle.java | 2 +- .../java8/lambda/methodreference/BicycleComparator.java | 2 +- .../lambda/methodreference/MethodReferenceUnitTest.java | 2 +- .../tips/Java8FunctionalInteracesLambdasUnitTest.java | 8 ++++---- 26 files changed, 38 insertions(+), 36 deletions(-) rename core-java-modules/core-java-lambdas/src/main/java/com/{baeldung => ossez}/doublecolon/Computer.java (98%) rename core-java-modules/core-java-lambdas/src/main/java/com/{baeldung => ossez}/doublecolon/ComputerUtils.java (87%) rename core-java-modules/core-java-lambdas/src/main/java/com/{baeldung => ossez}/doublecolon/MacbookPro.java (96%) rename core-java-modules/core-java-lambdas/src/main/java/com/{baeldung => ossez}/doublecolon/function/ComputerPredicate.java (53%) rename core-java-modules/core-java-lambdas/src/main/java/com/{baeldung => ossez}/doublecolon/function/TriFunction.java (89%) rename core-java-modules/core-java-lambdas/src/main/java/com/{baeldung => ossez}/java8/entity/Human.java (98%) rename core-java-modules/core-java-lambdas/src/main/java/com/{baeldung => ossez}/java8/lambda/exceptions/LambdaExceptionWrappers.java (97%) rename core-java-modules/core-java-lambdas/src/main/java/com/{baeldung => ossez}/java8/lambda/exceptions/ThrowingConsumer.java (71%) rename core-java-modules/core-java-lambdas/src/main/java/com/{baeldung => ossez}/java8/lambda/tips/Bar.java (86%) rename core-java-modules/core-java-lambdas/src/main/java/com/{baeldung => ossez}/java8/lambda/tips/Baz.java (86%) rename core-java-modules/core-java-lambdas/src/main/java/com/{baeldung => ossez}/java8/lambda/tips/Foo.java (75%) rename core-java-modules/core-java-lambdas/src/main/java/com/{baeldung => ossez}/java8/lambda/tips/FooExtended.java (81%) rename core-java-modules/core-java-lambdas/src/main/java/com/{baeldung => ossez}/java8/lambda/tips/Processor.java (85%) rename core-java-modules/core-java-lambdas/src/main/java/com/{baeldung => ossez}/java8/lambda/tips/ProcessorImpl.java (76%) rename core-java-modules/core-java-lambdas/src/main/java/com/{baeldung => ossez}/java8/lambda/tips/UseFoo.java (95%) rename core-java-modules/core-java-lambdas/src/main/java/com/{baeldung => ossez}/lambdas/LambdaVariables.java (98%) rename core-java-modules/core-java-lambdas/src/test/java/com/{baeldung => ossez}/doublecolon/ComputerUtilsUnitTest.java (92%) rename core-java-modules/core-java-lambdas/src/test/java/com/{baeldung => ossez}/functionalinterface/FunctionalInterfaceUnitTest.java (99%) rename core-java-modules/core-java-lambdas/src/test/java/com/{baeldung => ossez}/functionalinterface/ShortToByteFunction.java (69%) rename core-java-modules/core-java-lambdas/src/test/java/com/{baeldung => ossez}/java8/Java8SortUnitTest.java (99%) rename core-java-modules/core-java-lambdas/src/test/java/com/{baeldung => ossez}/java8/lambda/exceptions/LambdaExceptionWrappersUnitTest.java (91%) rename core-java-modules/core-java-lambdas/src/test/java/com/{baeldung => ossez}/java8/lambda/methodreference/Bicycle.java (92%) rename core-java-modules/core-java-lambdas/src/test/java/com/{baeldung => ossez}/java8/lambda/methodreference/BicycleComparator.java (82%) rename core-java-modules/core-java-lambdas/src/test/java/com/{baeldung => ossez}/java8/lambda/methodreference/MethodReferenceUnitTest.java (98%) rename core-java-modules/core-java-lambdas/src/test/java/com/{baeldung => ossez}/java8/lambda/tips/Java8FunctionalInteracesLambdasUnitTest.java (93%) diff --git a/.idea/encodings.xml b/.idea/encodings.xml index 9cb0625105..ec5eb51b99 100644 --- a/.idea/encodings.xml +++ b/.idea/encodings.xml @@ -34,6 +34,7 @@ + diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/Computer.java b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/doublecolon/Computer.java similarity index 98% rename from core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/Computer.java rename to core-java-modules/core-java-lambdas/src/main/java/com/ossez/doublecolon/Computer.java index dc0b064013..e3f04d7fee 100644 --- a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/Computer.java +++ b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/doublecolon/Computer.java @@ -1,4 +1,4 @@ -package com.baeldung.doublecolon; +package com.ossez.doublecolon; public class Computer { diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/ComputerUtils.java b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/doublecolon/ComputerUtils.java similarity index 87% rename from core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/ComputerUtils.java rename to core-java-modules/core-java-lambdas/src/main/java/com/ossez/doublecolon/ComputerUtils.java index ea274072ea..1949d62db6 100644 --- a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/ComputerUtils.java +++ b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/doublecolon/ComputerUtils.java @@ -1,9 +1,9 @@ -package com.baeldung.doublecolon; +package com.ossez.doublecolon; import java.util.ArrayList; import java.util.List; -import com.baeldung.doublecolon.function.ComputerPredicate; +import com.ossez.doublecolon.function.ComputerPredicate; public class ComputerUtils { diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/MacbookPro.java b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/doublecolon/MacbookPro.java similarity index 96% rename from core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/MacbookPro.java rename to core-java-modules/core-java-lambdas/src/main/java/com/ossez/doublecolon/MacbookPro.java index 79c8d9e383..50a206067d 100644 --- a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/MacbookPro.java +++ b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/doublecolon/MacbookPro.java @@ -1,4 +1,4 @@ -package com.baeldung.doublecolon; +package com.ossez.doublecolon; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/function/ComputerPredicate.java b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/doublecolon/function/ComputerPredicate.java similarity index 53% rename from core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/function/ComputerPredicate.java rename to core-java-modules/core-java-lambdas/src/main/java/com/ossez/doublecolon/function/ComputerPredicate.java index 5ce491e86a..fe64ba90df 100644 --- a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/function/ComputerPredicate.java +++ b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/doublecolon/function/ComputerPredicate.java @@ -1,6 +1,6 @@ -package com.baeldung.doublecolon.function; +package com.ossez.doublecolon.function; -import com.baeldung.doublecolon.Computer; +import com.ossez.doublecolon.Computer; @FunctionalInterface public interface ComputerPredicate { diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/function/TriFunction.java b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/doublecolon/function/TriFunction.java similarity index 89% rename from core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/function/TriFunction.java rename to core-java-modules/core-java-lambdas/src/main/java/com/ossez/doublecolon/function/TriFunction.java index d0d6299479..66fc53e908 100644 --- a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/function/TriFunction.java +++ b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/doublecolon/function/TriFunction.java @@ -1,4 +1,4 @@ -package com.baeldung.doublecolon.function; +package com.ossez.doublecolon.function; import java.util.Objects; import java.util.function.Function; diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/entity/Human.java b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/entity/Human.java similarity index 98% rename from core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/entity/Human.java rename to core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/entity/Human.java index 98e35d0af2..49f62d7ae4 100644 --- a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/entity/Human.java +++ b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/entity/Human.java @@ -1,4 +1,4 @@ -package com.baeldung.java8.entity; +package com.ossez.java8.entity; public class Human { private String name; diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/exceptions/LambdaExceptionWrappers.java b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/exceptions/LambdaExceptionWrappers.java similarity index 97% rename from core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/exceptions/LambdaExceptionWrappers.java rename to core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/exceptions/LambdaExceptionWrappers.java index db710589e7..21c441b545 100644 --- a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/exceptions/LambdaExceptionWrappers.java +++ b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/exceptions/LambdaExceptionWrappers.java @@ -1,4 +1,4 @@ -package com.baeldung.java8.lambda.exceptions; +package com.ossez.java8.lambda.exceptions; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/exceptions/ThrowingConsumer.java b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/exceptions/ThrowingConsumer.java similarity index 71% rename from core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/exceptions/ThrowingConsumer.java rename to core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/exceptions/ThrowingConsumer.java index c5860e7f6b..36db53e158 100644 --- a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/exceptions/ThrowingConsumer.java +++ b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/exceptions/ThrowingConsumer.java @@ -1,4 +1,4 @@ -package com.baeldung.java8.lambda.exceptions; +package com.ossez.java8.lambda.exceptions; @FunctionalInterface public interface ThrowingConsumer { diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Bar.java b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/tips/Bar.java similarity index 86% rename from core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Bar.java rename to core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/tips/Bar.java index 3ee78bd7a3..698f51c89c 100644 --- a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Bar.java +++ b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/tips/Bar.java @@ -1,4 +1,4 @@ -package com.baeldung.java8.lambda.tips; +package com.ossez.java8.lambda.tips; @FunctionalInterface diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Baz.java b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/tips/Baz.java similarity index 86% rename from core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Baz.java rename to core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/tips/Baz.java index 1e1e9ae094..990f2b7149 100644 --- a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Baz.java +++ b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/tips/Baz.java @@ -1,4 +1,4 @@ -package com.baeldung.java8.lambda.tips; +package com.ossez.java8.lambda.tips; @FunctionalInterface diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Foo.java b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/tips/Foo.java similarity index 75% rename from core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Foo.java rename to core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/tips/Foo.java index b63ba61e7e..7a042bf368 100644 --- a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Foo.java +++ b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/tips/Foo.java @@ -1,4 +1,4 @@ -package com.baeldung.java8.lambda.tips; +package com.ossez.java8.lambda.tips; @FunctionalInterface diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/FooExtended.java b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/tips/FooExtended.java similarity index 81% rename from core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/FooExtended.java rename to core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/tips/FooExtended.java index 27ab86dca3..55eb83865b 100644 --- a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/FooExtended.java +++ b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/tips/FooExtended.java @@ -1,4 +1,4 @@ -package com.baeldung.java8.lambda.tips; +package com.ossez.java8.lambda.tips; @FunctionalInterface diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Processor.java b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/tips/Processor.java similarity index 85% rename from core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Processor.java rename to core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/tips/Processor.java index 7931129cf5..056e6d3f25 100644 --- a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Processor.java +++ b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/tips/Processor.java @@ -1,4 +1,4 @@ -package com.baeldung.java8.lambda.tips; +package com.ossez.java8.lambda.tips; import java.util.concurrent.Callable; import java.util.function.Supplier; diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/ProcessorImpl.java b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/tips/ProcessorImpl.java similarity index 76% rename from core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/ProcessorImpl.java rename to core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/tips/ProcessorImpl.java index cb1b3dcdd2..db4f67536f 100644 --- a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/ProcessorImpl.java +++ b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/tips/ProcessorImpl.java @@ -1,9 +1,7 @@ -package com.baeldung.java8.lambda.tips; +package com.ossez.java8.lambda.tips; import java.util.concurrent.Callable; -import java.util.function.Consumer; -import java.util.function.Function; import java.util.function.Supplier; public class ProcessorImpl implements Processor { diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/UseFoo.java b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/tips/UseFoo.java similarity index 95% rename from core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/UseFoo.java rename to core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/tips/UseFoo.java index a64d8bb920..d3bb13df0b 100644 --- a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/UseFoo.java +++ b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/java8/lambda/tips/UseFoo.java @@ -1,4 +1,4 @@ -package com.baeldung.java8.lambda.tips; +package com.ossez.java8.lambda.tips; import java.util.function.Function; diff --git a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/lambdas/LambdaVariables.java b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/lambdas/LambdaVariables.java similarity index 98% rename from core-java-modules/core-java-lambdas/src/main/java/com/baeldung/lambdas/LambdaVariables.java rename to core-java-modules/core-java-lambdas/src/main/java/com/ossez/lambdas/LambdaVariables.java index 5c1201150f..52dca253d2 100644 --- a/core-java-modules/core-java-lambdas/src/main/java/com/baeldung/lambdas/LambdaVariables.java +++ b/core-java-modules/core-java-lambdas/src/main/java/com/ossez/lambdas/LambdaVariables.java @@ -1,4 +1,4 @@ -package com.baeldung.lambdas; +package com.ossez.lambdas; import java.util.Random; import java.util.concurrent.ExecutorService; diff --git a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/doublecolon/ComputerUtilsUnitTest.java b/core-java-modules/core-java-lambdas/src/test/java/com/ossez/doublecolon/ComputerUtilsUnitTest.java similarity index 92% rename from core-java-modules/core-java-lambdas/src/test/java/com/baeldung/doublecolon/ComputerUtilsUnitTest.java rename to core-java-modules/core-java-lambdas/src/test/java/com/ossez/doublecolon/ComputerUtilsUnitTest.java index 7157dead6e..0afce2e0e6 100644 --- a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/doublecolon/ComputerUtilsUnitTest.java +++ b/core-java-modules/core-java-lambdas/src/test/java/com/ossez/doublecolon/ComputerUtilsUnitTest.java @@ -1,6 +1,9 @@ -package com.baeldung.doublecolon; +package com.ossez.doublecolon; -import com.baeldung.doublecolon.function.TriFunction; +import com.ossez.doublecolon.Computer; +import com.ossez.doublecolon.ComputerUtils; +import com.ossez.doublecolon.MacbookPro; +import com.ossez.doublecolon.function.TriFunction; import org.junit.After; import org.junit.Assert; import org.junit.Before; @@ -11,7 +14,7 @@ import java.util.Comparator; import java.util.List; import java.util.function.BiFunction; -import static com.baeldung.doublecolon.ComputerUtils.*; +import static com.ossez.doublecolon.ComputerUtils.*; public class ComputerUtilsUnitTest { diff --git a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/functionalinterface/FunctionalInterfaceUnitTest.java b/core-java-modules/core-java-lambdas/src/test/java/com/ossez/functionalinterface/FunctionalInterfaceUnitTest.java similarity index 99% rename from core-java-modules/core-java-lambdas/src/test/java/com/baeldung/functionalinterface/FunctionalInterfaceUnitTest.java rename to core-java-modules/core-java-lambdas/src/test/java/com/ossez/functionalinterface/FunctionalInterfaceUnitTest.java index e91cbfcb75..c48b67d2f9 100644 --- a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/functionalinterface/FunctionalInterfaceUnitTest.java +++ b/core-java-modules/core-java-lambdas/src/test/java/com/ossez/functionalinterface/FunctionalInterfaceUnitTest.java @@ -1,4 +1,4 @@ -package com.baeldung.functionalinterface; +package com.ossez.functionalinterface; import com.google.common.util.concurrent.Uninterruptibles; import org.junit.Test; diff --git a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/functionalinterface/ShortToByteFunction.java b/core-java-modules/core-java-lambdas/src/test/java/com/ossez/functionalinterface/ShortToByteFunction.java similarity index 69% rename from core-java-modules/core-java-lambdas/src/test/java/com/baeldung/functionalinterface/ShortToByteFunction.java rename to core-java-modules/core-java-lambdas/src/test/java/com/ossez/functionalinterface/ShortToByteFunction.java index 3231d6244f..ce34c74e18 100644 --- a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/functionalinterface/ShortToByteFunction.java +++ b/core-java-modules/core-java-lambdas/src/test/java/com/ossez/functionalinterface/ShortToByteFunction.java @@ -1,4 +1,4 @@ -package com.baeldung.functionalinterface; +package com.ossez.functionalinterface; @FunctionalInterface public interface ShortToByteFunction { diff --git a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/Java8SortUnitTest.java b/core-java-modules/core-java-lambdas/src/test/java/com/ossez/java8/Java8SortUnitTest.java similarity index 99% rename from core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/Java8SortUnitTest.java rename to core-java-modules/core-java-lambdas/src/test/java/com/ossez/java8/Java8SortUnitTest.java index e5f876c84b..0ba3e63eaf 100644 --- a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/Java8SortUnitTest.java +++ b/core-java-modules/core-java-lambdas/src/test/java/com/ossez/java8/Java8SortUnitTest.java @@ -1,6 +1,6 @@ -package com.baeldung.java8; +package com.ossez.java8; -import com.baeldung.java8.entity.Human; +import com.ossez.java8.entity.Human; import com.google.common.collect.Lists; import com.google.common.primitives.Ints; import org.junit.Assert; diff --git a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/exceptions/LambdaExceptionWrappersUnitTest.java b/core-java-modules/core-java-lambdas/src/test/java/com/ossez/java8/lambda/exceptions/LambdaExceptionWrappersUnitTest.java similarity index 91% rename from core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/exceptions/LambdaExceptionWrappersUnitTest.java rename to core-java-modules/core-java-lambdas/src/test/java/com/ossez/java8/lambda/exceptions/LambdaExceptionWrappersUnitTest.java index fe10266043..d23ec4caf9 100644 --- a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/exceptions/LambdaExceptionWrappersUnitTest.java +++ b/core-java-modules/core-java-lambdas/src/test/java/com/ossez/java8/lambda/exceptions/LambdaExceptionWrappersUnitTest.java @@ -1,4 +1,4 @@ -package com.baeldung.java8.lambda.exceptions; +package com.ossez.java8.lambda.exceptions; import org.junit.Before; import org.junit.Test; @@ -9,7 +9,7 @@ import java.io.IOException; import java.util.Arrays; import java.util.List; -import static com.baeldung.java8.lambda.exceptions.LambdaExceptionWrappers.*; +import static com.ossez.java8.lambda.exceptions.LambdaExceptionWrappers.*; public class LambdaExceptionWrappersUnitTest { diff --git a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/Bicycle.java b/core-java-modules/core-java-lambdas/src/test/java/com/ossez/java8/lambda/methodreference/Bicycle.java similarity index 92% rename from core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/Bicycle.java rename to core-java-modules/core-java-lambdas/src/test/java/com/ossez/java8/lambda/methodreference/Bicycle.java index 26f9f8bc46..a83d76faae 100644 --- a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/Bicycle.java +++ b/core-java-modules/core-java-lambdas/src/test/java/com/ossez/java8/lambda/methodreference/Bicycle.java @@ -1,4 +1,4 @@ -package com.baeldung.java8.lambda.methodreference; +package com.ossez.java8.lambda.methodreference; public class Bicycle { diff --git a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/BicycleComparator.java b/core-java-modules/core-java-lambdas/src/test/java/com/ossez/java8/lambda/methodreference/BicycleComparator.java similarity index 82% rename from core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/BicycleComparator.java rename to core-java-modules/core-java-lambdas/src/test/java/com/ossez/java8/lambda/methodreference/BicycleComparator.java index 153a7d105a..4406ef4faa 100644 --- a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/BicycleComparator.java +++ b/core-java-modules/core-java-lambdas/src/test/java/com/ossez/java8/lambda/methodreference/BicycleComparator.java @@ -1,4 +1,4 @@ -package com.baeldung.java8.lambda.methodreference; +package com.ossez.java8.lambda.methodreference; import java.util.Comparator; diff --git a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/MethodReferenceUnitTest.java b/core-java-modules/core-java-lambdas/src/test/java/com/ossez/java8/lambda/methodreference/MethodReferenceUnitTest.java similarity index 98% rename from core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/MethodReferenceUnitTest.java rename to core-java-modules/core-java-lambdas/src/test/java/com/ossez/java8/lambda/methodreference/MethodReferenceUnitTest.java index 87c01c3ded..f3cc99951e 100644 --- a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/MethodReferenceUnitTest.java +++ b/core-java-modules/core-java-lambdas/src/test/java/com/ossez/java8/lambda/methodreference/MethodReferenceUnitTest.java @@ -1,4 +1,4 @@ -package com.baeldung.java8.lambda.methodreference; +package com.ossez.java8.lambda.methodreference; import java.util.ArrayList; import java.util.Arrays; diff --git a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/tips/Java8FunctionalInteracesLambdasUnitTest.java b/core-java-modules/core-java-lambdas/src/test/java/com/ossez/java8/lambda/tips/Java8FunctionalInteracesLambdasUnitTest.java similarity index 93% rename from core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/tips/Java8FunctionalInteracesLambdasUnitTest.java rename to core-java-modules/core-java-lambdas/src/test/java/com/ossez/java8/lambda/tips/Java8FunctionalInteracesLambdasUnitTest.java index acc3bc8fa3..19d7b5a8ae 100644 --- a/core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/tips/Java8FunctionalInteracesLambdasUnitTest.java +++ b/core-java-modules/core-java-lambdas/src/test/java/com/ossez/java8/lambda/tips/Java8FunctionalInteracesLambdasUnitTest.java @@ -1,8 +1,8 @@ -package com.baeldung.java8.lambda.tips; +package com.ossez.java8.lambda.tips; -import com.baeldung.java8.lambda.tips.Foo; -import com.baeldung.java8.lambda.tips.FooExtended; -import com.baeldung.java8.lambda.tips.UseFoo; +import com.ossez.java8.lambda.tips.Foo; +import com.ossez.java8.lambda.tips.FooExtended; +import com.ossez.java8.lambda.tips.UseFoo; import org.junit.Before; import org.junit.Test; -- 2.45.2 From 9dc6847a963f15db6a4a1ca8207613dbb14ec952 Mon Sep 17 00:00:00 2001 From: YuCheng Hu Date: Tue, 30 Apr 2024 09:30:50 -0400 Subject: [PATCH 12/13] Update README.md --- core-java-modules/core-java-lambdas/README.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/core-java-modules/core-java-lambdas/README.md b/core-java-modules/core-java-lambdas/README.md index cad2097673..a216a50574 100644 --- a/core-java-modules/core-java-lambdas/README.md +++ b/core-java-modules/core-java-lambdas/README.md @@ -1,4 +1,6 @@ -## Relevant articles: +## Lambdas 函数 + +本文件夹中包含有所有 Java 相关的 Lambdas 函数及其示例 - [Why Do Local Variables Used in Lambdas Have to Be Final or Effectively Final?](https://www.baeldung.com/java-lambda-effectively-final-local-variables) - [Java 8 – Powerful Comparison with Lambdas](http://www.baeldung.com/java-8-sort-lambda) -- 2.45.2 From 899c4d7bbc80032815673176e6ebc5da4e47e6bf Mon Sep 17 00:00:00 2001 From: YuCheng Hu Date: Tue, 30 Apr 2024 09:35:09 -0400 Subject: [PATCH 13/13] Merge List section 2 to main section --- .idea/compiler.xml | 4 ++- .../core-java-collections-list-2/README.md | 15 --------- .../core-java-collections-list-2/pom.xml | 32 ------------------- .../src/main/resources/logback.xml | 13 -------- .../core-java-collections-list/README.md | 10 +++++- .../findastring/FindAStringInGivenList.java | 0 .../java/com/ossez}/list/WaysToIterate.java | 2 +- .../converter/ArrayConvertToListUnitTest.java | 2 +- .../FindItemsBasedOnOtherStreamUnitTest.java | 0 .../FindAStringInListUnitTest.java | 0 .../FlattenNestedListUnitTest.java | 2 +- .../ossez/java/list/ListAssertJUnitTest.java | 0 .../com/ossez/java/list/ListJUnitTest.java | 0 .../ossez/java/list/ListTestNgUnitTest.java | 0 .../java/list/WaysToIterateUnitTest.java | 0 .../ListInitializationUnitTest.java | 0 core-java-modules/pom.xml | 1 - 17 files changed, 15 insertions(+), 66 deletions(-) delete mode 100644 core-java-modules/core-java-collections-list-2/README.md delete mode 100644 core-java-modules/core-java-collections-list-2/pom.xml delete mode 100644 core-java-modules/core-java-collections-list-2/src/main/resources/logback.xml rename core-java-modules/{core-java-collections-list-2 => core-java-collections-list}/src/main/java/com/ossez/findastring/FindAStringInGivenList.java (100%) rename core-java-modules/{core-java-collections-list-2/src/main/java/com/ossez/java => core-java-collections-list/src/main/java/com/ossez}/list/WaysToIterate.java (98%) rename core-java-modules/{core-java-collections-list-2/src/test/java/com/ossez/array => core-java-collections-list/src/test/java/com/ossez}/converter/ArrayConvertToListUnitTest.java (99%) rename core-java-modules/{core-java-collections-list-2 => core-java-collections-list}/src/test/java/com/ossez/findItems/FindItemsBasedOnOtherStreamUnitTest.java (100%) rename core-java-modules/{core-java-collections-list-2 => core-java-collections-list}/src/test/java/com/ossez/findastring/FindAStringInListUnitTest.java (100%) rename core-java-modules/{core-java-collections-list-2/src/test/java/com/ossez/list => core-java-collections-list/src/test/java/com/ossez}/flattennestedlist/FlattenNestedListUnitTest.java (97%) rename core-java-modules/{core-java-collections-list-2 => core-java-collections-list}/src/test/java/com/ossez/java/list/ListAssertJUnitTest.java (100%) rename core-java-modules/{core-java-collections-list-2 => core-java-collections-list}/src/test/java/com/ossez/java/list/ListJUnitTest.java (100%) rename core-java-modules/{core-java-collections-list-2 => core-java-collections-list}/src/test/java/com/ossez/java/list/ListTestNgUnitTest.java (100%) rename core-java-modules/{core-java-collections-list-2 => core-java-collections-list}/src/test/java/com/ossez/java/list/WaysToIterateUnitTest.java (100%) rename core-java-modules/{core-java-collections-list-2 => core-java-collections-list}/src/test/java/com/ossez/java/listInitialization/ListInitializationUnitTest.java (100%) diff --git a/.idea/compiler.xml b/.idea/compiler.xml index fd6687cea8..0d92c7f2b6 100644 --- a/.idea/compiler.xml +++ b/.idea/compiler.xml @@ -32,7 +32,6 @@ - @@ -40,6 +39,9 @@ + + +