diff --git a/core-java-modules/core-java-17/README.md b/core-java-modules/core-java-17/README.md
new file mode 100644
index 0000000000..074c5e4f86
--- /dev/null
+++ b/core-java-modules/core-java-17/README.md
@@ -0,0 +1,3 @@
+### Relevant articles:
+
+- [Pattern Matching for Switch](https://www.baeldung.com/java-switch-pattern-matching)
diff --git a/core-java-modules/core-java-17/pom.xml b/core-java-modules/core-java-17/pom.xml
new file mode 100644
index 0000000000..f9a7ec326b
--- /dev/null
+++ b/core-java-modules/core-java-17/pom.xml
@@ -0,0 +1,81 @@
+
+
+ 4.0.0
+ core-java-17
+ 0.1.0-SNAPSHOT
+ core-java-17
+ jar
+ http://maven.apache.org
+
+
+ com.baeldung
+ parent-modules
+ 1.0.0-SNAPSHOT
+ ../../
+
+
+
+
+ org.assertj
+ assertj-core
+ ${assertj.version}
+ test
+
+
+ org.junit.jupiter
+ junit-jupiter-engine
+ ${junit-jupiter.version}
+ test
+
+
+ org.junit.jupiter
+ junit-jupiter-api
+ ${junit-jupiter.version}
+ test
+
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-compiler-plugin
+ ${maven-compiler-plugin.version}
+
+ ${maven.compiler.release}
+ --enable-preview
+
+ ${maven.compiler.target.version}
+
+
+
+ org.apache.maven.plugins
+ maven-surefire-plugin
+ ${surefire.plugin.version}
+
+ --enable-preview
+ 1
+
+
+
+ org.apache.maven.surefire
+ surefire-api
+ ${surefire.plugin.version}
+
+
+
+
+
+
+
+ 17
+ 17
+ 17
+ 3.8.1
+ 3.0.0-M5
+ 3.17.2
+
+
+
\ No newline at end of file
diff --git a/core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/GuardedPatterns.java b/core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/GuardedPatterns.java
new file mode 100644
index 0000000000..a76287f64a
--- /dev/null
+++ b/core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/GuardedPatterns.java
@@ -0,0 +1,25 @@
+package com.baeldung.switchpatterns;
+
+public class GuardedPatterns {
+
+ static double getDoubleValueUsingIf(Object o) {
+ return switch (o) {
+ case String s -> {
+ if (s.length() > 0) {
+ yield Double.parseDouble(s);
+ } else {
+ yield 0d;
+ }
+ }
+ default -> 0d;
+ };
+ }
+
+ static double getDoubleValueUsingGuardedPatterns(Object o) {
+ return switch (o) {
+ case String s && s.length() > 0 -> Double.parseDouble(s);
+ default -> 0d;
+ };
+ }
+
+}
diff --git a/core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/HandlingNullValues.java b/core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/HandlingNullValues.java
new file mode 100644
index 0000000000..8e64480a41
--- /dev/null
+++ b/core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/HandlingNullValues.java
@@ -0,0 +1,20 @@
+package com.baeldung.switchpatterns;
+
+public class HandlingNullValues {
+
+ static double getDoubleUsingSwitchNullCase(Object o) {
+ return switch (o) {
+ case String s -> Double.parseDouble(s);
+ case null -> 0d;
+ default -> 0d;
+ };
+ }
+
+ static double getDoubleUsingSwitchTotalType(Object o) {
+ return switch (o) {
+ case String s -> Double.parseDouble(s);
+ case Object ob -> 0d;
+ };
+ }
+
+}
diff --git a/core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/ParenthesizedPatterns.java b/core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/ParenthesizedPatterns.java
new file mode 100644
index 0000000000..49dd5edb31
--- /dev/null
+++ b/core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/ParenthesizedPatterns.java
@@ -0,0 +1,29 @@
+package com.baeldung.switchpatterns;
+
+public class ParenthesizedPatterns {
+
+ static double getDoubleValueUsingIf(Object o) {
+ return switch (o) {
+ case String s -> {
+ if (s.length() > 0) {
+ if (s.contains("#") || s.contains("@")) {
+ yield 0d;
+ } else {
+ yield Double.parseDouble(s);
+ }
+ } else {
+ yield 0d;
+ }
+ }
+ default -> 0d;
+ };
+ }
+
+ static double getDoubleValueUsingParenthesizedPatterns(Object o) {
+ return switch (o) {
+ case String s && s.length() > 0 && !(s.contains("#") || s.contains("@")) -> Double.parseDouble(s);
+ default -> 0d;
+ };
+ }
+
+}
diff --git a/core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/PatternMatching.java b/core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/PatternMatching.java
new file mode 100644
index 0000000000..f026caa3f1
--- /dev/null
+++ b/core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/PatternMatching.java
@@ -0,0 +1,14 @@
+package com.baeldung.switchpatterns;
+
+public class PatternMatching {
+
+ public static void main(String[] args) {
+ Object o = args[0];
+ if (o instanceof String s) {
+ System.out.printf("Object is a string %s", s);
+ } else if(o instanceof Number n) {
+ System.out.printf("Object is a number %n", n);
+ }
+ }
+
+}
diff --git a/core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/SwitchStatement.java b/core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/SwitchStatement.java
new file mode 100644
index 0000000000..17d2b1856d
--- /dev/null
+++ b/core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/SwitchStatement.java
@@ -0,0 +1,14 @@
+package com.baeldung.switchpatterns;
+
+public class SwitchStatement {
+
+ public static void main(String[] args) {
+ final String b = "B";
+ switch (args[0]) {
+ case "A" -> System.out.println("Parameter is A");
+ case b -> System.out.println("Parameter is b");
+ default -> System.out.println("Parameter is unknown");
+ };
+ }
+
+}
diff --git a/core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/TypePatterns.java b/core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/TypePatterns.java
new file mode 100644
index 0000000000..47af090ad0
--- /dev/null
+++ b/core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/TypePatterns.java
@@ -0,0 +1,30 @@
+package com.baeldung.switchpatterns;
+
+public class TypePatterns {
+
+ static double getDoubleUsingIf(Object o) {
+ double result;
+
+ if (o instanceof Integer) {
+ result = ((Integer) o).doubleValue();
+ } else if (o instanceof Float) {
+ result = ((Float) o).doubleValue();
+ } else if (o instanceof String) {
+ result = Double.parseDouble(((String) o));
+ } else {
+ result = 0d;
+ }
+
+ return result;
+ }
+
+ static double getDoubleUsingSwitch(Object o) {
+ return switch (o) {
+ case Integer i -> i.doubleValue();
+ case Float f -> f.doubleValue();
+ case String s -> Double.parseDouble(s);
+ default -> 0d;
+ };
+ }
+
+}
diff --git a/core-java-modules/core-java-17/src/test/java/com/baeldung/switchpatterns/GuardedPatternsUnitTest.java b/core-java-modules/core-java-17/src/test/java/com/baeldung/switchpatterns/GuardedPatternsUnitTest.java
new file mode 100644
index 0000000000..cff8b1caca
--- /dev/null
+++ b/core-java-modules/core-java-17/src/test/java/com/baeldung/switchpatterns/GuardedPatternsUnitTest.java
@@ -0,0 +1,30 @@
+package com.baeldung.switchpatterns;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static com.baeldung.switchpatterns.GuardedPatterns.*;
+
+class GuardedPatternsUnitTest {
+
+ @Test
+ void givenIfImplementation_whenUsingEmptyString_thenDoubleIsReturned() {
+ assertEquals(0d, getDoubleValueUsingIf(""));
+ }
+
+ @Test
+ void givenIfImplementation_whenUsingNonEmptyString_thenDoubleIsReturned() {
+ assertEquals(10d, getDoubleValueUsingIf("10"));
+ }
+
+ @Test
+ void givenPatternsImplementation_whenUsingEmptyString_thenDoubleIsReturned() {
+ assertEquals(0d, getDoubleValueUsingGuardedPatterns(""));
+ }
+
+ @Test
+ void givenPatternsImplementation_whenUsingNonEmptyString_thenDoubleIsReturned() {
+ assertEquals(10d, getDoubleValueUsingGuardedPatterns("10"));
+ }
+
+}
diff --git a/core-java-modules/core-java-17/src/test/java/com/baeldung/switchpatterns/HandlingNullValuesUnitTest.java b/core-java-modules/core-java-17/src/test/java/com/baeldung/switchpatterns/HandlingNullValuesUnitTest.java
new file mode 100644
index 0000000000..ffe045cc26
--- /dev/null
+++ b/core-java-modules/core-java-17/src/test/java/com/baeldung/switchpatterns/HandlingNullValuesUnitTest.java
@@ -0,0 +1,30 @@
+package com.baeldung.switchpatterns;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static com.baeldung.switchpatterns.HandlingNullValues.*;
+
+class HandlingNullValuesUnitTest {
+
+ @Test
+ void givenNullCaseInSwitch_whenUsingStringAsArgument_thenDoubleIsReturned() {
+ assertEquals(10d, getDoubleUsingSwitchNullCase("10"));
+ }
+
+ @Test
+ void givenTotalTypeInSwitch_whenUsingNullArgument_thenDoubleIsReturned() {
+ assertEquals(0d, getDoubleUsingSwitchNullCase(null));
+ }
+
+ @Test
+ void givenTotalTypeInSwitch_whenUsingStringAsArgument_thenDoubleIsReturned() {
+ assertEquals(10d, getDoubleUsingSwitchTotalType("10"));
+ }
+
+ @Test
+ void givenNullCaseInSwitch_whenUsingNullArgument_thenDoubleIsReturned() {
+ assertEquals(0d, getDoubleUsingSwitchTotalType(null));
+ }
+
+}
diff --git a/core-java-modules/core-java-17/src/test/java/com/baeldung/switchpatterns/ParenthesizedPatternsUnitTest.java b/core-java-modules/core-java-17/src/test/java/com/baeldung/switchpatterns/ParenthesizedPatternsUnitTest.java
new file mode 100644
index 0000000000..9548c9f0b6
--- /dev/null
+++ b/core-java-modules/core-java-17/src/test/java/com/baeldung/switchpatterns/ParenthesizedPatternsUnitTest.java
@@ -0,0 +1,40 @@
+package com.baeldung.switchpatterns;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static com.baeldung.switchpatterns.ParenthesizedPatterns.*;
+
+class ParenthesizedPatternsUnitTest {
+
+ @Test
+ void givenIfImplementation_whenUsingEmptyString_thenDoubleIsReturned() {
+ assertEquals(0d, getDoubleValueUsingIf(""));
+ }
+
+ @Test
+ void givenIfImplementation_whenUsingNonEmptyString_thenDoubleIsReturned() {
+ assertEquals(10d, getDoubleValueUsingIf("10"));
+ }
+
+ @Test
+ void givenIfImplementation_whenStringContainsSpecialChar_thenDoubleIsReturned() {
+ assertEquals(0d, getDoubleValueUsingIf("@10"));
+ }
+
+ @Test
+ void givenPatternsImplementation_whenUsingEmptyString_thenDoubleIsReturned() {
+ assertEquals(0d, getDoubleValueUsingParenthesizedPatterns(""));
+ }
+
+ @Test
+ void givenPatternsImplementation_whenUsingNonEmptyString_thenDoubleIsReturned() {
+ assertEquals(10d, getDoubleValueUsingParenthesizedPatterns("10"));
+ }
+
+ @Test
+ void givenPatternsImplementation_whenStringContainsSpecialChar_thenDoubleIsReturned() {
+ assertEquals(0d, getDoubleValueUsingParenthesizedPatterns("@10"));
+ }
+
+}
diff --git a/core-java-modules/core-java-17/src/test/java/com/baeldung/switchpatterns/TypePatternsUnitTest.java b/core-java-modules/core-java-17/src/test/java/com/baeldung/switchpatterns/TypePatternsUnitTest.java
new file mode 100644
index 0000000000..25988be53d
--- /dev/null
+++ b/core-java-modules/core-java-17/src/test/java/com/baeldung/switchpatterns/TypePatternsUnitTest.java
@@ -0,0 +1,49 @@
+package com.baeldung.switchpatterns;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static com.baeldung.switchpatterns.TypePatterns.*;
+
+class TypePatternsUnitTest {
+
+ @Test
+ void givenIfImplementation_whenUsingIntegerAsArgument_thenDoubleIsReturned() {
+ assertEquals(10d, getDoubleUsingIf(10));
+ }
+
+ @Test
+ void givenIfImplementation_whenUsingDoubleAsArgument_thenDoubleIsReturned() {
+ assertEquals(10d, getDoubleUsingIf(10.0f));
+ }
+
+ @Test
+ void givenIfImplementation_whenUsingStringAsArgument_thenDoubleIsReturned() {
+ assertEquals(10d, getDoubleUsingIf("10"));
+ }
+
+ @Test
+ void givenIfImplementation_whenUsingCharAsArgument_thenDoubleIsReturned() {
+ assertEquals(0d, getDoubleUsingIf('c'));
+ }
+
+ @Test
+ void givenSwitchImplementation_whenUsingIntegerAsArgument_thenDoubleIsReturned() {
+ assertEquals(10d, getDoubleUsingSwitch(10));
+ }
+
+ @Test
+ void givenSwitchImplementation_whenUsingDoubleAsArgument_thenDoubleIsReturned() {
+ assertEquals(10d, getDoubleUsingSwitch(10.0f));
+ }
+
+ @Test
+ void givenSwitchImplementation_whenUsingStringAsArgument_thenDoubleIsReturned() {
+ assertEquals(10d, getDoubleUsingSwitch("10"));
+ }
+
+ @Test
+ void givenSwitchImplementation_whenUsingCharAsArgument_thenDoubleIsReturned() {
+ assertEquals(0d, getDoubleUsingSwitch('c'));
+ }
+
+}
diff --git a/core-java-modules/core-java-arrays-convert/README.md b/core-java-modules/core-java-arrays-convert/README.md
index 4bd060a246..b28b97cb09 100644
--- a/core-java-modules/core-java-arrays-convert/README.md
+++ b/core-java-modules/core-java-arrays-convert/README.md
@@ -5,3 +5,4 @@ This module contains articles about arrays conversion in Java
## Relevant Articles
- [Convert a Float to a Byte Array in Java](https://www.baeldung.com/java-convert-float-to-byte-array)
- [Converting Between Stream and Array in Java](https://www.baeldung.com/java-stream-to-array)
+- [Convert a Byte Array to a Numeric Representation in Java](https://www.baeldung.com/java-byte-array-to-number)
diff --git a/core-java-modules/core-java-arrays-convert/pom.xml b/core-java-modules/core-java-arrays-convert/pom.xml
index 4cb2946ac9..6e001e12b0 100644
--- a/core-java-modules/core-java-arrays-convert/pom.xml
+++ b/core-java-modules/core-java-arrays-convert/pom.xml
@@ -19,6 +19,11 @@
guava
${guava.version}
+
+ org.apache.commons
+ commons-lang3
+ ${commons-lang3.version}
+
diff --git a/core-java-modules/core-java-arrays-convert/src/main/java/com/baeldung/array/conversions/ByteArrayToNumericRepresentation.java b/core-java-modules/core-java-arrays-convert/src/main/java/com/baeldung/array/conversions/ByteArrayToNumericRepresentation.java
new file mode 100644
index 0000000000..82d60e1666
--- /dev/null
+++ b/core-java-modules/core-java-arrays-convert/src/main/java/com/baeldung/array/conversions/ByteArrayToNumericRepresentation.java
@@ -0,0 +1,281 @@
+package com.baeldung.array.conversions;
+
+import com.google.common.primitives.Ints;
+import com.google.common.primitives.Longs;
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.Conversion;
+
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+
+class ByteArrayToNumericRepresentation {
+
+ static int convertByteArrayToIntUsingShiftOperator(byte[] bytes) {
+ int value = 0;
+ for (byte b : bytes) {
+ value = (value << 8) + (b & 0xFF);
+ }
+ return value;
+ }
+
+ static byte[] convertIntToByteArrayUsingShiftOperator(int value) {
+ byte[] bytes = new byte[Integer.BYTES];
+ int length = bytes.length;
+ for (int i = 0; i < length; i++) {
+ bytes[length - i - 1] = (byte) (value & 0xFF);
+ value >>= 8;
+ }
+ return bytes;
+ }
+
+ static long convertByteArrayToLongUsingShiftOperator(byte[] bytes) {
+ long value = 0;
+ for (byte b : bytes) {
+ value <<= 8;
+ value |= (b & 0xFF);
+ }
+ return value;
+ }
+
+ static byte[] convertLongToByteArrayUsingShiftOperator(long value) {
+ byte[] bytes = new byte[Long.BYTES];
+ int length = bytes.length;
+ for (int i = 0; i < length; i++) {
+ bytes[length - i - 1] = (byte) (value & 0xFF);
+ value >>= 8;
+ }
+ return bytes;
+ }
+
+ static float convertByteArrayToFloatUsingShiftOperator(byte[] bytes) {
+ // convert bytes to int
+ int intValue = 0;
+ for (byte b : bytes) {
+ intValue = (intValue << 8) + (b & 0xFF);
+ }
+
+ // convert int to float
+ return Float.intBitsToFloat(intValue);
+ }
+
+ static byte[] convertFloatToByteArrayUsingShiftOperator(float value) {
+ // convert float to int
+ int intValue = Float.floatToIntBits(value);
+
+ // convert int to bytes
+ byte[] bytes = new byte[Float.BYTES];
+ int length = bytes.length;
+ for (int i = 0; i < length; i++) {
+ bytes[length - i - 1] = (byte) (intValue & 0xFF);
+ intValue >>= 8;
+ }
+ return bytes;
+ }
+
+ static double convertingByteArrayToDoubleUsingShiftOperator(byte[] bytes) {
+ long longValue = 0;
+ for (byte b : bytes) {
+ longValue = (longValue << 8) + (b & 0xFF);
+ }
+
+ return Double.longBitsToDouble(longValue);
+ }
+
+ static byte[] convertDoubleToByteArrayUsingShiftOperator(double value) {
+ long longValue = Double.doubleToLongBits(value);
+
+ byte[] bytes = new byte[Double.BYTES];
+ int length = bytes.length;
+ for (int i = 0; i < length; i++) {
+ bytes[length - i - 1] = (byte) (longValue & 0xFF);
+ longValue >>= 8;
+ }
+ return bytes;
+ }
+
+ static int convertByteArrayToIntUsingByteBuffer(byte[] bytes) {
+ ByteBuffer buffer = ByteBuffer.allocate(Integer.BYTES);
+ buffer.put(bytes);
+ buffer.rewind();
+ return buffer.getInt();
+ }
+
+ static byte[] convertIntToByteArrayUsingByteBuffer(int value) {
+ ByteBuffer buffer = ByteBuffer.allocate(Integer.BYTES);
+ buffer.putInt(value);
+ buffer.rewind();
+ return buffer.array();
+ }
+
+ static long convertByteArrayToLongUsingByteBuffer(byte[] bytes) {
+ ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
+ buffer.put(bytes);
+ buffer.rewind();
+ return buffer.getLong();
+ }
+
+ static byte[] convertLongToByteArrayUsingByteBuffer(long value) {
+ ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
+ buffer.putLong(value);
+ buffer.rewind();
+ return buffer.array();
+ }
+
+ static float convertByteArrayToFloatUsingByteBuffer(byte[] bytes) {
+ ByteBuffer buffer = ByteBuffer.allocate(Float.BYTES);
+ buffer.put(bytes);
+ buffer.rewind();
+ return buffer.getFloat();
+ }
+
+ static byte[] convertFloatToByteArrayUsingByteBuffer(float value) {
+ ByteBuffer buffer = ByteBuffer.allocate(Float.BYTES);
+ buffer.putFloat(value);
+ buffer.rewind();
+ return buffer.array();
+ }
+
+ static double convertByteArrayToDoubleUsingByteBuffer(byte[] bytes) {
+ ByteBuffer buffer = ByteBuffer.allocate(Double.BYTES);
+ buffer.put(bytes);
+ buffer.rewind();
+ return buffer.getDouble();
+ }
+
+ static byte[] convertDoubleToByteArrayUsingByteBuffer(double value) {
+ ByteBuffer buffer = ByteBuffer.allocate(Double.BYTES);
+ buffer.putDouble(value);
+ buffer.rewind();
+ return buffer.array();
+ }
+
+ static int convertByteArrayToIntUsingBigInteger(byte[] bytes) {
+ return new BigInteger(bytes).intValue();
+ }
+
+ static byte[] convertIntToByteArrayUsingBigInteger(int value) {
+ return BigInteger.valueOf(value).toByteArray();
+ }
+
+ static long convertByteArrayToLongUsingBigInteger(byte[] bytes) {
+ return new BigInteger(bytes).longValue();
+ }
+
+ static byte[] convertLongToByteArrayUsingBigInteger(long value) {
+ return BigInteger.valueOf(value).toByteArray();
+ }
+
+ static float convertByteArrayToFloatUsingBigInteger(byte[] bytes) {
+ int intValue = new BigInteger(bytes).intValue();
+ return Float.intBitsToFloat(intValue);
+ }
+
+ static byte[] convertFloatToByteArrayUsingBigInteger(float value) {
+ int intValue = Float.floatToIntBits(value);
+ return BigInteger.valueOf(intValue).toByteArray();
+ }
+
+ static double convertByteArrayToDoubleUsingBigInteger(byte[] bytes) {
+ long longValue = new BigInteger(bytes).longValue();
+ return Double.longBitsToDouble(longValue);
+ }
+
+ static byte[] convertDoubleToByteArrayUsingBigInteger(double value) {
+ long longValue = Double.doubleToLongBits(value);
+ return BigInteger.valueOf(longValue).toByteArray();
+ }
+
+ static int convertingByteArrayToIntUsingGuava(byte[] bytes) {
+ return Ints.fromByteArray(bytes);
+ }
+
+ static byte[] convertIntToByteArrayUsingGuava(int value) {
+ return Ints.toByteArray(value);
+ }
+
+ static long convertByteArrayToLongUsingGuava(byte[] bytes) {
+ return Longs.fromByteArray(bytes);
+ }
+
+ static byte[] convertLongToByteArrayUsingGuava(long value) {
+ return Longs.toByteArray(value);
+ }
+
+ static float convertByteArrayToFloatUsingGuava(byte[] bytes) {
+ int intValue = Ints.fromByteArray(bytes);
+ return Float.intBitsToFloat(intValue);
+ }
+
+ static byte[] convertFloatToByteArrayUsingGuava(float value) {
+ int intValue = Float.floatToIntBits(value);
+ return Ints.toByteArray(intValue);
+ }
+
+ static double convertByteArrayToDoubleUsingGuava(byte[] bytes) {
+ long longValue = Longs.fromByteArray(bytes);
+ return Double.longBitsToDouble(longValue);
+ }
+
+ static byte[] convertDoubleToByteArrayUsingGuava(double value) {
+ long longValue = Double.doubleToLongBits(value);
+ return Longs.toByteArray(longValue);
+ }
+
+ static int convertByteArrayToIntUsingCommonsLang(byte[] bytes) {
+ byte[] copyBytes = Arrays.copyOf(bytes, bytes.length);
+ ArrayUtils.reverse(copyBytes);
+ return Conversion.byteArrayToInt(copyBytes, 0, 0, 0, copyBytes.length);
+ }
+
+ static byte[] convertIntToByteArrayUsingCommonsLang(int value) {
+ byte[] bytes = new byte[Integer.BYTES];
+ Conversion.intToByteArray(value, 0, bytes, 0, bytes.length);
+ ArrayUtils.reverse(bytes);
+ return bytes;
+ }
+
+ static long convertByteArrayToLongUsingCommonsLang(byte[] bytes) {
+ byte[] copyBytes = Arrays.copyOf(bytes, bytes.length);
+ ArrayUtils.reverse(copyBytes);
+ return Conversion.byteArrayToLong(copyBytes, 0, 0, 0, copyBytes.length);
+ }
+
+ static byte[] convertLongToByteArrayUsingCommonsLang(long value) {
+ byte[] bytes = new byte[Long.BYTES];
+ Conversion.longToByteArray(value, 0, bytes, 0, bytes.length);
+ ArrayUtils.reverse(bytes);
+ return bytes;
+ }
+
+ static float convertByteArrayToFloatUsingCommonsLang(byte[] bytes) {
+ byte[] copyBytes = Arrays.copyOf(bytes, bytes.length);
+ ArrayUtils.reverse(copyBytes);
+ int intValue = Conversion.byteArrayToInt(copyBytes, 0, 0, 0, copyBytes.length);
+ return Float.intBitsToFloat(intValue);
+ }
+
+ static byte[] convertFloatToByteArrayUsingCommonsLang(float value) {
+ int intValue = Float.floatToIntBits(value);
+ byte[] bytes = new byte[Float.BYTES];
+ Conversion.intToByteArray(intValue, 0, bytes, 0, bytes.length);
+ ArrayUtils.reverse(bytes);
+ return bytes;
+ }
+
+ static double convertByteArrayToDoubleUsingCommonsLang(byte[] bytes) {
+ byte[] copyBytes = Arrays.copyOf(bytes, bytes.length);
+ ArrayUtils.reverse(copyBytes);
+ long longValue = Conversion.byteArrayToLong(copyBytes, 0, 0, 0, copyBytes.length);
+ return Double.longBitsToDouble(longValue);
+ }
+
+ static byte[] convertDoubleToByteArrayUsingCommonsLang(double value) {
+ long longValue = Double.doubleToLongBits(value);
+ byte[] bytes = new byte[Long.BYTES];
+ Conversion.longToByteArray(longValue, 0, bytes, 0, bytes.length);
+ ArrayUtils.reverse(bytes);
+ return bytes;
+ }
+
+}
\ No newline at end of file
diff --git a/core-java-modules/core-java-arrays-convert/src/test/java/com/baeldung/array/conversions/ByteArrayToNumericRepresentationUnitTest.java b/core-java-modules/core-java-arrays-convert/src/test/java/com/baeldung/array/conversions/ByteArrayToNumericRepresentationUnitTest.java
new file mode 100644
index 0000000000..0fae765d9c
--- /dev/null
+++ b/core-java-modules/core-java-arrays-convert/src/test/java/com/baeldung/array/conversions/ByteArrayToNumericRepresentationUnitTest.java
@@ -0,0 +1,316 @@
+package com.baeldung.array.conversions;
+
+import org.junit.Test;
+
+import static com.baeldung.array.conversions.ByteArrayToNumericRepresentation.*;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+public class ByteArrayToNumericRepresentationUnitTest {
+ private static final byte[] INT_BYTE_ARRAY = new byte[]{
+ (byte) 0xCA, (byte) 0xFE, (byte) 0xBA, (byte) 0xBE
+ };
+ private static final int INT_VALUE = 0xCAFEBABE;
+
+
+ private static final byte[] FLOAT_BYTE_ARRAY = new byte[]{
+ (byte) 0x40, (byte) 0x48, (byte) 0xF5, (byte) 0xC3
+ };
+ private static final float FLOAT_VALUE = 3.14F;
+
+
+ private static final byte[] LONG_BYTE_ARRAY = new byte[]{
+ (byte) 0x01, (byte) 0x23, (byte) 0x45, (byte) 0x67,
+ (byte) 0x89, (byte) 0xAB, (byte) 0xCD, (byte) 0xEF
+ };
+ private static final long LONG_VALUE = 0x0123456789ABCDEFL;
+
+
+ private static final byte[] DOUBLE_BYTE_ARRAY = new byte[]{
+ (byte) 0x3F, (byte) 0xE3, (byte) 0xC6, (byte) 0xA7,
+ (byte) 0xEF, (byte) 0x9D, (byte) 0xB2, (byte) 0x2D
+ };
+ private static final double DOUBLE_VALUE = 0.618D;
+
+
+ @Test
+ public void givenShiftOperator_whenConvertingByteArrayToInt_thenSuccess() {
+ int value = convertByteArrayToIntUsingShiftOperator(INT_BYTE_ARRAY);
+
+ assertEquals(INT_VALUE, value);
+ }
+
+ @Test
+ public void givenShiftOperator_whenConvertingIntToByteArray_thenSuccess() {
+ byte[] bytes = convertIntToByteArrayUsingShiftOperator(INT_VALUE);
+
+ assertArrayEquals(INT_BYTE_ARRAY, bytes);
+ }
+
+ @Test
+ public void givenShiftOperator_whenConvertingByteArrayToLong_thenSuccess() {
+ long value = convertByteArrayToLongUsingShiftOperator(LONG_BYTE_ARRAY);
+
+ assertEquals(LONG_VALUE, value);
+ }
+
+ @Test
+ public void givenShiftOperator_whenConvertingLongToByteArray_thenSuccess() {
+ byte[] bytes = convertLongToByteArrayUsingShiftOperator(LONG_VALUE);
+
+ assertArrayEquals(LONG_BYTE_ARRAY, bytes);
+ }
+
+ @Test
+ public void givenShiftOperator_whenConvertingByteArrayToFloat_thenSuccess() {
+ float value = convertByteArrayToFloatUsingShiftOperator(FLOAT_BYTE_ARRAY);
+
+ assertEquals(Float.floatToIntBits(FLOAT_VALUE), Float.floatToIntBits(value));
+ }
+
+ @Test
+ public void givenShiftOperator_whenConvertingFloatToByteArray_thenSuccess() {
+ byte[] bytes = convertFloatToByteArrayUsingShiftOperator(FLOAT_VALUE);
+
+ assertArrayEquals(FLOAT_BYTE_ARRAY, bytes);
+ }
+
+ @Test
+ public void givenShiftOperator_whenConvertingByteArrayToDouble_thenSuccess() {
+ double value = convertingByteArrayToDoubleUsingShiftOperator(DOUBLE_BYTE_ARRAY);
+
+ assertEquals(Double.doubleToLongBits(DOUBLE_VALUE), Double.doubleToLongBits(value));
+ }
+
+ @Test
+ public void givenShiftOperator_whenConvertingDoubleToByteArray_thenSuccess() {
+ byte[] bytes = convertDoubleToByteArrayUsingShiftOperator(DOUBLE_VALUE);
+
+ assertArrayEquals(DOUBLE_BYTE_ARRAY, bytes);
+ }
+
+ @Test
+ public void givenByteBuffer_whenConvertingByteArrayToInt_thenSuccess() {
+ int value = convertByteArrayToIntUsingByteBuffer(INT_BYTE_ARRAY);
+
+ assertEquals(INT_VALUE, value);
+ }
+
+ @Test
+ public void givenByteBuffer_whenConvertingIntToByteArray_thenSuccess() {
+ byte[] bytes = convertIntToByteArrayUsingByteBuffer(INT_VALUE);
+
+ assertArrayEquals(INT_BYTE_ARRAY, bytes);
+ }
+
+ @Test
+ public void givenByteBuffer_whenConvertingByteArrayToLong_thenSuccess() {
+ long value = convertByteArrayToLongUsingByteBuffer(LONG_BYTE_ARRAY);
+
+ assertEquals(LONG_VALUE, value);
+ }
+
+ @Test
+ public void givenByteBuffer_whenConvertingLongToByteArray_thenSuccess() {
+ byte[] bytes = convertLongToByteArrayUsingByteBuffer(LONG_VALUE);
+
+ assertArrayEquals(LONG_BYTE_ARRAY, bytes);
+ }
+
+ @Test
+ public void givenByteBuffer_whenConvertingByteArrayToFloat_thenSuccess() {
+ float value = convertByteArrayToFloatUsingByteBuffer(FLOAT_BYTE_ARRAY);
+
+ assertEquals(Float.floatToIntBits(FLOAT_VALUE), Float.floatToIntBits(value));
+ }
+
+ @Test
+ public void givenByteBuffer_whenConvertingFloatToByteArray_thenSuccess() {
+ byte[] bytes = convertFloatToByteArrayUsingByteBuffer(FLOAT_VALUE);
+
+ assertArrayEquals(FLOAT_BYTE_ARRAY, bytes);
+ }
+
+ @Test
+ public void givenByteBuffer_whenConvertingByteArrayToDouble_thenSuccess() {
+ double value = convertByteArrayToDoubleUsingByteBuffer(DOUBLE_BYTE_ARRAY);
+
+ assertEquals(Double.doubleToLongBits(DOUBLE_VALUE), Double.doubleToLongBits(value));
+ }
+
+ @Test
+ public void givenByteBuffer_whenConvertingDoubleToByteArray_thenSuccess() {
+ byte[] bytes = convertDoubleToByteArrayUsingByteBuffer(DOUBLE_VALUE);
+
+ assertArrayEquals(DOUBLE_BYTE_ARRAY, bytes);
+ }
+
+ @Test
+ public void givenBigInteger_whenConvertingByteArrayToInt_thenSuccess() {
+ int value = convertByteArrayToIntUsingBigInteger(INT_BYTE_ARRAY);
+
+ assertEquals(INT_VALUE, value);
+ }
+
+ @Test
+ public void givenBigInteger_whenConvertingIntToByteArray_thenSuccess() {
+ byte[] bytes = convertIntToByteArrayUsingBigInteger(INT_VALUE);
+
+ assertArrayEquals(INT_BYTE_ARRAY, bytes);
+ }
+
+ @Test
+ public void givenBigInteger_whenConvertingByteArrayToLong_thenSuccess() {
+ long value = convertByteArrayToLongUsingBigInteger(LONG_BYTE_ARRAY);
+
+ assertEquals(LONG_VALUE, value);
+ }
+
+ @Test
+ public void givenBigInteger_whenConvertingLongToByteArray_thenSuccess() {
+ byte[] bytes = convertLongToByteArrayUsingBigInteger(LONG_VALUE);
+
+ assertArrayEquals(LONG_BYTE_ARRAY, bytes);
+ }
+
+ @Test
+ public void givenBigInteger_whenConvertingByteArrayToFloat_thenSuccess() {
+ float value = convertByteArrayToFloatUsingBigInteger(FLOAT_BYTE_ARRAY);
+
+ assertEquals(Float.floatToIntBits(FLOAT_VALUE), Float.floatToIntBits(value));
+ }
+
+ @Test
+ public void givenBigInteger_whenConvertingFloatToByteArray_thenSuccess() {
+ byte[] bytes = convertFloatToByteArrayUsingBigInteger(FLOAT_VALUE);
+
+ assertArrayEquals(FLOAT_BYTE_ARRAY, bytes);
+ }
+
+ @Test
+ public void givenBigInteger_whenConvertingByteArrayToDouble_thenSuccess() {
+ double value = convertByteArrayToDoubleUsingBigInteger(DOUBLE_BYTE_ARRAY);
+
+ assertEquals(Double.doubleToLongBits(DOUBLE_VALUE), Double.doubleToLongBits(value));
+ }
+
+ @Test
+ public void givenBigInteger_whenConvertingDoubleToByteArray_thenSuccess() {
+ byte[] bytes = convertDoubleToByteArrayUsingBigInteger(DOUBLE_VALUE);
+
+ assertArrayEquals(DOUBLE_BYTE_ARRAY, bytes);
+ }
+
+ @Test
+ public void givenGuava_whenConvertingByteArrayToInt_thenSuccess() {
+ int value = convertingByteArrayToIntUsingGuava(INT_BYTE_ARRAY);
+
+ assertEquals(INT_VALUE, value);
+ }
+
+ @Test
+ public void givenGuava_whenConvertingIntToByteArray_thenSuccess() {
+ byte[] bytes = convertIntToByteArrayUsingGuava(INT_VALUE);
+
+ assertArrayEquals(INT_BYTE_ARRAY, bytes);
+ }
+
+ @Test
+ public void givenGuava_whenConvertingByteArrayToLong_thenSuccess() {
+ long value = convertByteArrayToLongUsingGuava(LONG_BYTE_ARRAY);
+
+ assertEquals(LONG_VALUE, value);
+ }
+
+ @Test
+ public void givenGuava_whenConvertingLongToByteArray_thenSuccess() {
+ byte[] bytes = convertLongToByteArrayUsingGuava(LONG_VALUE);
+
+ assertArrayEquals(LONG_BYTE_ARRAY, bytes);
+ }
+
+ @Test
+ public void givenGuava_whenConvertingByteArrayToFloat_thenSuccess() {
+ float value = convertByteArrayToFloatUsingGuava(FLOAT_BYTE_ARRAY);
+
+ assertEquals(Float.floatToIntBits(FLOAT_VALUE), Float.floatToIntBits(value));
+ }
+
+ @Test
+ public void givenGuava_whenConvertingFloatToByteArray_thenSuccess() {
+ byte[] bytes = convertFloatToByteArrayUsingGuava(FLOAT_VALUE);
+
+ assertArrayEquals(FLOAT_BYTE_ARRAY, bytes);
+ }
+
+ @Test
+ public void givenGuava_whenConvertingByteArrayToDouble_thenSuccess() {
+ double value = convertByteArrayToDoubleUsingGuava(DOUBLE_BYTE_ARRAY);
+
+ assertEquals(Double.doubleToLongBits(DOUBLE_VALUE), Double.doubleToLongBits(value));
+ }
+
+ @Test
+ public void givenGuava_whenConvertingDoubleToByteArray_thenSuccess() {
+ byte[] bytes = convertDoubleToByteArrayUsingGuava(DOUBLE_VALUE);
+
+ assertArrayEquals(DOUBLE_BYTE_ARRAY, bytes);
+ }
+
+ @Test
+ public void givenCommonsLang_whenConvertingByteArrayToInt_thenSuccess() {
+ int value = convertByteArrayToIntUsingCommonsLang(INT_BYTE_ARRAY);
+
+ assertEquals(INT_VALUE, value);
+ }
+
+ @Test
+ public void givenCommonsLang_whenConvertingIntToByteArray_thenSuccess() {
+ byte[] bytes = convertIntToByteArrayUsingCommonsLang(INT_VALUE);
+
+ assertArrayEquals(INT_BYTE_ARRAY, bytes);
+ }
+
+ @Test
+ public void givenCommonsLang_whenConvertingByteArrayToLong_thenSuccess() {
+ long value = convertByteArrayToLongUsingCommonsLang(LONG_BYTE_ARRAY);
+
+ assertEquals(LONG_VALUE, value);
+ }
+
+ @Test
+ public void givenCommonsLang_whenConvertingLongToByteArray_thenSuccess() {
+ byte[] bytes = convertLongToByteArrayUsingCommonsLang(LONG_VALUE);
+
+ assertArrayEquals(LONG_BYTE_ARRAY, bytes);
+ }
+
+ @Test
+ public void givenCommonsLang_whenConvertingByteArrayToFloat_thenSuccess() {
+ float value = convertByteArrayToFloatUsingCommonsLang(FLOAT_BYTE_ARRAY);
+
+ assertEquals(Float.floatToIntBits(FLOAT_VALUE), Float.floatToIntBits(value));
+ }
+
+ @Test
+ public void givenCommonsLang_whenConvertingFloatToByteArray_thenSuccess() {
+ byte[] bytes = convertFloatToByteArrayUsingCommonsLang(FLOAT_VALUE);
+
+ assertArrayEquals(FLOAT_BYTE_ARRAY, bytes);
+ }
+
+ @Test
+ public void givenCommonsLang_whenConvertingByteArrayToDouble_thenSuccess() {
+ double value = convertByteArrayToDoubleUsingCommonsLang(DOUBLE_BYTE_ARRAY);
+
+ assertEquals(Double.doubleToLongBits(DOUBLE_VALUE), Double.doubleToLongBits(value));
+ }
+
+ @Test
+ public void givenCommonsLang_whenConvertingDoubleToByteArray_thenSuccess() {
+ byte[] bytes = convertDoubleToByteArrayUsingCommonsLang(DOUBLE_VALUE);
+
+ assertArrayEquals(DOUBLE_BYTE_ARRAY, bytes);
+ }
+
+}
\ No newline at end of file
diff --git a/core-java-modules/core-java-string-operations-3/README.md b/core-java-modules/core-java-string-operations-3/README.md
index f4cde6104f..1a131c57ac 100644
--- a/core-java-modules/core-java-string-operations-3/README.md
+++ b/core-java-modules/core-java-string-operations-3/README.md
@@ -6,3 +6,4 @@
- [Split a String in Java and Keep the Delimiters](https://www.baeldung.com/java-split-string-keep-delimiters)
- [Validate String as Filename in Java](https://www.baeldung.com/java-validate-filename)
- [Count Spaces in a Java String](https://www.baeldung.com/java-string-count-spaces)
+- [Remove Accents and Diacritics From a String in Java](https://www.baeldung.com/java-remove-accents-from-text)
diff --git a/core-java-modules/core-java-string-operations-3/src/main/java/com/baeldung/accentsanddiacriticsremoval/StringNormalizer.java b/core-java-modules/core-java-string-operations-3/src/main/java/com/baeldung/accentsanddiacriticsremoval/StringNormalizer.java
new file mode 100644
index 0000000000..d33b9178ea
--- /dev/null
+++ b/core-java-modules/core-java-string-operations-3/src/main/java/com/baeldung/accentsanddiacriticsremoval/StringNormalizer.java
@@ -0,0 +1,49 @@
+package com.baeldung.accentsanddiacriticsremoval;
+
+import org.apache.commons.lang3.StringUtils;
+
+import java.text.Normalizer;
+import java.util.StringJoiner;
+
+class StringNormalizer {
+
+ static String removeAccentsWithApacheCommons(String input) {
+ return StringUtils.stripAccents(input);
+ }
+
+ static String removeAccents(String input) {
+ return normalize(input).replaceAll("\\p{M}", "");
+ }
+
+ static String unicodeValueOfNormalizedString(String input) {
+ return toUnicode(normalize(input));
+ }
+
+ private static String normalize(String input) {
+ return input == null ? null : Normalizer.normalize(input, Normalizer.Form.NFKD);
+ }
+
+ private static String toUnicode(String input) {
+ if (input.length() == 1) {
+ return toUnicode(input.charAt(0));
+ } else {
+ StringJoiner stringJoiner = new StringJoiner(" ");
+ for (char c : input.toCharArray()) {
+ stringJoiner.add(toUnicode(c));
+ }
+ return stringJoiner.toString();
+ }
+ }
+
+ private static String toUnicode(char input) {
+
+ String hex = Integer.toHexString(input);
+ StringBuilder sb = new StringBuilder(hex);
+
+ while (sb.length() < 4) {
+ sb.insert(0, "0");
+ }
+ sb.insert(0, "\\u");
+ return sb.toString();
+ }
+}
diff --git a/core-java-modules/core-java-string-operations-3/src/main/java/com/baeldung/doublequotesremoval/DoubleQuotesRemovalUtils.java b/core-java-modules/core-java-string-operations-3/src/main/java/com/baeldung/doublequotesremoval/DoubleQuotesRemovalUtils.java
new file mode 100644
index 0000000000..c7cc162026
--- /dev/null
+++ b/core-java-modules/core-java-string-operations-3/src/main/java/com/baeldung/doublequotesremoval/DoubleQuotesRemovalUtils.java
@@ -0,0 +1,37 @@
+package com.baeldung.doublequotesremoval;
+
+import com.google.common.base.CharMatcher;
+
+public class DoubleQuotesRemovalUtils {
+
+ public static String removeWithSubString(String input) {
+ if (input != null && input.length() >= 2 && input.charAt(0) == '\"'
+ && input.charAt(input.length() - 1) == '\"') {
+ return input.substring(1, input.length() - 1);
+ }
+
+ return input;
+ }
+
+ public static String removeWithReplaceAllSimple(String input) {
+ if (input == null || input.isEmpty())
+ return input;
+
+ return input.replaceAll("\"", "");
+ }
+
+ public static String removeWithReplaceAllAdvanced(String input) {
+ if (input == null || input.isEmpty())
+ return input;
+
+ return input.replaceAll("^\"|\"$", "");
+ }
+
+ public static String removeWithGuava(String input) {
+ if (input == null || input.isEmpty())
+ return input;
+
+ return CharMatcher.is('\"').trimFrom(input);
+ }
+
+}
diff --git a/core-java-modules/core-java-string-operations-3/src/test/java/com/baeldung/accentsanddiacriticsremoval/CollatorUnitTest.java b/core-java-modules/core-java-string-operations-3/src/test/java/com/baeldung/accentsanddiacriticsremoval/CollatorUnitTest.java
new file mode 100644
index 0000000000..93b4f5af2e
--- /dev/null
+++ b/core-java-modules/core-java-string-operations-3/src/test/java/com/baeldung/accentsanddiacriticsremoval/CollatorUnitTest.java
@@ -0,0 +1,70 @@
+package com.baeldung.accentsanddiacriticsremoval;
+
+import org.junit.Test;
+import org.openjdk.jmh.annotations.Setup;
+
+import java.text.Collator;
+
+import static java.lang.Character.*;
+import static java.lang.String.valueOf;
+import static org.junit.Assert.assertEquals;
+
+public class CollatorUnitTest {
+
+ private final Collator collator = Collator.getInstance();
+
+ @Setup
+ public void setup() {
+ collator.setDecomposition(2);
+ }
+
+ @Test
+ public void givenAccentedStringAndPrimaryCollatorStrength_whenCompareWithASCIIString_thenReturnTrue() {
+ Collator collator = Collator.getInstance();
+ collator.setDecomposition(2);
+ collator.setStrength(0);
+ assertEquals(0, collator.compare("a", "a"));
+ assertEquals(0, collator.compare("ä", "a"));
+ assertEquals(0, collator.compare("A", "a"));
+ assertEquals(1, collator.compare("b", "a"));
+ assertEquals(0, collator.compare(valueOf(toChars(0x0001)), valueOf(toChars(0x0002))));
+ }
+
+ @Test
+ public void givenAccentedStringAndSecondaryCollatorStrength_whenCompareWithASCIIString_thenReturnTrue() {
+ collator.setStrength(1);
+ assertEquals(1, collator.compare("ä", "a"));
+ assertEquals(1, collator.compare("b", "a"));
+ assertEquals(0, collator.compare("A", "a"));
+ assertEquals(0, collator.compare("a", "a"));
+ assertEquals(0, collator.compare(valueOf(toChars(0x0001)), valueOf(toChars(0x0002))));
+
+ }
+
+ @Test
+ public void givenAccentedStringAndTeriaryCollatorStrength_whenCompareWithASCIIString_thenReturnTrue() {
+ collator.setStrength(2);
+ assertEquals(1, collator.compare("A", "a"));
+ assertEquals(1, collator.compare("ä", "a"));
+ assertEquals(1, collator.compare("b", "a"));
+ assertEquals(0, collator.compare("a", "a"));
+ assertEquals(0, collator.compare(valueOf(toChars(0x0001)), valueOf(toChars(0x0002))));
+ }
+
+ @Test
+ public void givenAccentedStringAndIdenticalCollatorStrength_whenCompareWithASCIIString_thenReturnTrue() {
+ collator.setStrength(3);
+ assertEquals(1, collator.compare("A", "a"));
+ assertEquals(1, collator.compare("ä", "a"));
+ assertEquals(1, collator.compare("b", "a"));
+ assertEquals(-1, collator.compare(valueOf(toChars(0x0001)), valueOf(toChars(0x0002))));
+ assertEquals(0, collator.compare("a", "a"));
+ }
+
+ @Test
+ public void givenNondecomposableAccentedStringAndIdenticalCollatorStrength_whenCompareWithASCIIString_thenReturnTrue() {
+ collator.setStrength(0);
+ assertEquals(1, collator.compare("ł", "l"));
+ assertEquals(1, collator.compare("ø", "o"));
+ }
+}
diff --git a/core-java-modules/core-java-string-operations-3/src/test/java/com/baeldung/accentsanddiacriticsremoval/StringNormalizerUnitTest.java b/core-java-modules/core-java-string-operations-3/src/test/java/com/baeldung/accentsanddiacriticsremoval/StringNormalizerUnitTest.java
new file mode 100644
index 0000000000..74359726b7
--- /dev/null
+++ b/core-java-modules/core-java-string-operations-3/src/test/java/com/baeldung/accentsanddiacriticsremoval/StringNormalizerUnitTest.java
@@ -0,0 +1,51 @@
+package com.baeldung.accentsanddiacriticsremoval;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.text.Normalizer;
+
+import org.junit.jupiter.api.Test;
+
+class StringNormalizerUnitTest {
+
+ @Test
+ public void givenNotNormalizedString_whenIsNormalized_thenReturnFalse() {
+ assertFalse(Normalizer.isNormalized("āăąēîïĩíĝġńñšŝśûůŷ", Normalizer.Form.NFKD));
+ }
+
+ @Test
+ void givenStringWithDecomposableUnicodeCharacters_whenRemoveAccents_thenReturnASCIIString() {
+ assertEquals("aaaeiiiiggnnsssuuy", StringNormalizer.removeAccents("āăąēîïĩíĝġńñšŝśûůŷ"));
+ }
+
+ @Test
+ void givenStringWithDecomposableUnicodeCharacters_whenRemoveAccentsWithApacheCommons_thenReturnASCIIString() {
+ assertEquals("aaaeiiiiggnnsssuuy", StringNormalizer.removeAccentsWithApacheCommons("āăąēîïĩíĝġńñšŝśûůŷ"));
+ }
+
+ @Test
+ void givenStringWithNondecomposableUnicodeCharacters_whenRemoveAccents_thenReturnOriginalString() {
+ assertEquals("łđħœ", StringNormalizer.removeAccents("łđħœ"));
+ }
+
+ @Test
+ void givenStringWithNondecomposableUnicodeCharacters_whenRemoveAccentsWithApacheCommons_thenReturnModifiedString() {
+ assertEquals("lđħœ", StringNormalizer.removeAccentsWithApacheCommons("łđħœ"));
+ }
+
+ @Test
+ void givenStringWithDecomposableUnicodeCharacters_whenUnicodeValueOfNormalizedString_thenReturnUnicodeValue() {
+ assertEquals("\\u0066 \\u0069", StringNormalizer.unicodeValueOfNormalizedString("fi"));
+ assertEquals("\\u0061 \\u0304", StringNormalizer.unicodeValueOfNormalizedString("ā"));
+ assertEquals("\\u0069 \\u0308", StringNormalizer.unicodeValueOfNormalizedString("ï"));
+ assertEquals("\\u006e \\u0301", StringNormalizer.unicodeValueOfNormalizedString("ń"));
+ }
+
+ @Test
+ void givenStringWithNonDecomposableUnicodeCharacters_whenUnicodeValueOfNormalizedString_thenReturnOriginalValue() {
+ assertEquals("\\u0142", StringNormalizer.unicodeValueOfNormalizedString("ł"));
+ assertEquals("\\u0127", StringNormalizer.unicodeValueOfNormalizedString("ħ"));
+ assertEquals("\\u0111", StringNormalizer.unicodeValueOfNormalizedString("đ"));
+ }
+}
\ No newline at end of file
diff --git a/core-java-modules/core-java-string-operations-3/src/test/java/com/baeldung/doublequotesremoval/DoubleQuotesRemovalUtilsUnitTest.java b/core-java-modules/core-java-string-operations-3/src/test/java/com/baeldung/doublequotesremoval/DoubleQuotesRemovalUtilsUnitTest.java
new file mode 100644
index 0000000000..2761cc3139
--- /dev/null
+++ b/core-java-modules/core-java-string-operations-3/src/test/java/com/baeldung/doublequotesremoval/DoubleQuotesRemovalUtilsUnitTest.java
@@ -0,0 +1,42 @@
+package com.baeldung.doublequotesremoval;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+public class DoubleQuotesRemovalUtilsUnitTest {
+
+ @Test
+ public void given_EmptyString_ShouldReturn_EmptyString() {
+ String input = "";
+
+ assertTrue(DoubleQuotesRemovalUtils.removeWithSubString(input).isEmpty());
+ assertTrue(DoubleQuotesRemovalUtils.removeWithReplaceAllSimple(input).isEmpty());
+ assertTrue(DoubleQuotesRemovalUtils.removeWithReplaceAllAdvanced(input).isEmpty());
+ assertTrue(DoubleQuotesRemovalUtils.removeWithGuava(input).isEmpty());
+ }
+
+ @Test
+ public void given_DoubleQuotesOnly_ShouldReturn_EmptyString() {
+ String input = "\"\"";
+
+ assertTrue(DoubleQuotesRemovalUtils.removeWithSubString(input).isEmpty());
+ assertTrue(DoubleQuotesRemovalUtils.removeWithReplaceAllSimple(input).isEmpty());
+ assertTrue(DoubleQuotesRemovalUtils.removeWithReplaceAllAdvanced(input).isEmpty());
+ assertTrue(DoubleQuotesRemovalUtils.removeWithGuava(input).isEmpty());
+ }
+
+ @Test
+ public void given_TextWithDoubleQuotes_ShouldReturn_TextOnly() {
+
+ String input = "\"Example of text for this test suit\"";
+ String expectedResult = "Example of text for this test suit";
+
+ assertEquals(expectedResult, DoubleQuotesRemovalUtils.removeWithSubString(input));
+ assertEquals(expectedResult, DoubleQuotesRemovalUtils.removeWithReplaceAllSimple(input));
+ assertEquals(expectedResult, DoubleQuotesRemovalUtils.removeWithReplaceAllAdvanced(input));
+ assertEquals(expectedResult, DoubleQuotesRemovalUtils.removeWithGuava(input));
+ }
+
+}
diff --git a/docker/dockerfile-with-git/.gitmodules b/docker/dockerfile-with-git/.gitmodules
new file mode 100644
index 0000000000..aa3911dfc3
--- /dev/null
+++ b/docker/dockerfile-with-git/.gitmodules
@@ -0,0 +1,4 @@
+[submodule "project"]
+ path = project
+ url = https://github.com/eugenp/tutorials.git
+ branch = master
\ No newline at end of file
diff --git a/docker/dockerfile-with-git/Dockerfile b/docker/dockerfile-with-git/Dockerfile
new file mode 100644
index 0000000000..91dfee3bc6
--- /dev/null
+++ b/docker/dockerfile-with-git/Dockerfile
@@ -0,0 +1,13 @@
+ADD . /project/
+ADD /build/ /project/
+ADD /output/project.jar /project/
+
+ADD ssh-private-key /root/.ssh/id_rsa
+RUN git clone git@github.com:eugenp/tutorials.git
+
+ARG username=$GIT_USERNAME
+ARG password=$GIT_PASSWORD
+RUN git clone https://username:password@github.com:eugenp/tutorials.git
+
+VOLUME /build/ /project/
+
diff --git a/persistence-modules/spring-boot-persistence-h2/src/main/resources/application-lazy-load-no-trans-off.properties b/persistence-modules/spring-boot-persistence-h2/src/main/resources/application-lazy-load-no-trans-off.properties
index ca60ef3ce3..a1243dc1df 100644
--- a/persistence-modules/spring-boot-persistence-h2/src/main/resources/application-lazy-load-no-trans-off.properties
+++ b/persistence-modules/spring-boot-persistence-h2/src/main/resources/application-lazy-load-no-trans-off.properties
@@ -5,7 +5,7 @@ spring.datasource.password=
spring.jpa.hibernate.ddl-auto=create-drop
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console
-spring.datasource.data=data-trans.sql
+spring.sql.init.data-locations=data-trans.sql
logging.level.org.hibernate.SQL=INFO
logging.level.org.hibernate.type=INFO
diff --git a/persistence-modules/spring-boot-persistence-h2/src/main/resources/application-lazy-load-no-trans-on.properties b/persistence-modules/spring-boot-persistence-h2/src/main/resources/application-lazy-load-no-trans-on.properties
index 0469ea0dde..2ea89b2ee6 100644
--- a/persistence-modules/spring-boot-persistence-h2/src/main/resources/application-lazy-load-no-trans-on.properties
+++ b/persistence-modules/spring-boot-persistence-h2/src/main/resources/application-lazy-load-no-trans-on.properties
@@ -5,7 +5,7 @@ spring.datasource.password=
spring.jpa.hibernate.ddl-auto=create-drop
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console
-spring.datasource.data=data-trans.sql
+spring.sql.init.data-locations=data-trans.sql
logging.level.org.hibernate.SQL=INFO
logging.level.org.hibernate.type=INFO
diff --git a/persistence-modules/spring-boot-persistence-h2/src/main/resources/application.yaml b/persistence-modules/spring-boot-persistence-h2/src/main/resources/application.yaml
new file mode 100644
index 0000000000..aeb33f797a
--- /dev/null
+++ b/persistence-modules/spring-boot-persistence-h2/src/main/resources/application.yaml
@@ -0,0 +1,14 @@
+spring:
+ h2:
+ console:
+ enabled: true
+ path: /h2-console
+ console.settings.trace: false
+ spring.h2.console.settings.web-allow-others: false
+ datasource:
+ url: jdbc:h2:mem:mydb
+ username: sa
+ password: password
+ driverClassName: org.h2.Driver
+ jpa:
+ spring.jpa.database-platform: org.hibernate.dialect.H2Dialect
diff --git a/persistence-modules/spring-boot-persistence/src/test/resources/application.properties b/persistence-modules/spring-boot-persistence/src/test/resources/application.properties
index 07101ca2f5..d22bd38426 100644
--- a/persistence-modules/spring-boot-persistence/src/test/resources/application.properties
+++ b/persistence-modules/spring-boot-persistence/src/test/resources/application.properties
@@ -13,4 +13,4 @@ hibernate.cache.use_query_cache=true
hibernate.cache.region.factory_class=org.hibernate.cache.ehcache.EhCacheRegionFactory
spring.jpa.properties.hibernate.hbm2ddl.import_files=import_books.sql
-spring.datasource.data=import_*_users.sql
\ No newline at end of file
+spring.sql.init.data-locations=import_*_users.sql
\ No newline at end of file
diff --git a/persistence-modules/spring-data-jpa-annotations/src/main/resources/ddd.properties b/persistence-modules/spring-data-jpa-annotations/src/main/resources/ddd.properties
index e5126b694b..af14453993 100644
--- a/persistence-modules/spring-data-jpa-annotations/src/main/resources/ddd.properties
+++ b/persistence-modules/spring-data-jpa-annotations/src/main/resources/ddd.properties
@@ -1 +1 @@
-spring.datasource.initialization-mode=never
\ No newline at end of file
+spring.sql.init.mode=never
\ No newline at end of file
diff --git a/persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/spring/data/jpa/query/UserRepositoryIntegrationTest.java b/persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/spring/data/jpa/query/UserRepositoryIntegrationTest.java
index 0ede418acd..a9ab13feed 100644
--- a/persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/spring/data/jpa/query/UserRepositoryIntegrationTest.java
+++ b/persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/spring/data/jpa/query/UserRepositoryIntegrationTest.java
@@ -19,7 +19,7 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
@RunWith(SpringRunner.class)
-@DataJpaTest(properties = "spring.datasource.data=classpath:insert_users.sql")
+@DataJpaTest(properties = "spring.sql.init.data-locations=classpath:insert_users.sql")
public class UserRepositoryIntegrationTest {
@Autowired
diff --git a/persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/spring/data/jpa/query/datetime/ArticleRepositoryIntegrationTest.java b/persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/spring/data/jpa/query/datetime/ArticleRepositoryIntegrationTest.java
index b1158b3dae..e00a340615 100644
--- a/persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/spring/data/jpa/query/datetime/ArticleRepositoryIntegrationTest.java
+++ b/persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/spring/data/jpa/query/datetime/ArticleRepositoryIntegrationTest.java
@@ -17,7 +17,7 @@ import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
@RunWith(SpringRunner.class)
-@DataJpaTest(properties="spring.datasource.data=classpath:import_entities.sql")
+@DataJpaTest(properties="spring.sql.init.data-locations=classpath:import_entities.sql")
public class ArticleRepositoryIntegrationTest {
@Autowired
diff --git a/persistence-modules/spring-data-jpa-query/src/main/resources/application-joins.properties b/persistence-modules/spring-data-jpa-query/src/main/resources/application-joins.properties
index fe2270293b..5fc1fd78e0 100644
--- a/persistence-modules/spring-data-jpa-query/src/main/resources/application-joins.properties
+++ b/persistence-modules/spring-data-jpa-query/src/main/resources/application-joins.properties
@@ -1 +1 @@
-spring.datasource.data=classpath:db/import_joins.sql
+spring.sql.init.data-locations=classpath:db/import_joins.sql
diff --git a/persistence-modules/spring-data-jpa-repo/src/test/java/com/baeldung/boot/daos/JpaRepositoriesIntegrationTest.java b/persistence-modules/spring-data-jpa-repo/src/test/java/com/baeldung/boot/daos/JpaRepositoriesIntegrationTest.java
index 9e4b78dce3..fe02f79a56 100644
--- a/persistence-modules/spring-data-jpa-repo/src/test/java/com/baeldung/boot/daos/JpaRepositoriesIntegrationTest.java
+++ b/persistence-modules/spring-data-jpa-repo/src/test/java/com/baeldung/boot/daos/JpaRepositoriesIntegrationTest.java
@@ -21,7 +21,7 @@ import com.baeldung.boot.domain.Location;
import com.baeldung.boot.domain.Store;
@RunWith(SpringRunner.class)
-@DataJpaTest(properties="spring.datasource.data=classpath:import_entities.sql")
+@DataJpaTest(properties="spring.sql.init.data-locations=classpath:import_entities.sql")
public class JpaRepositoriesIntegrationTest {
@Autowired
private LocationRepository locationRepository;
diff --git a/pom.xml b/pom.xml
index 1e26d09906..4709d4a86a 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1389,7 +1389,7 @@
2.2
1.3
3.3.0
- 1.10.22
+ 1.11.20
1.7.30
@@ -1403,8 +1403,8 @@
1.8
1.2.17
2.2.2.0
- 1.28
- 1.28
+ 1.33
+ 1.33
2.21.0
2.11.0
2.6
diff --git a/ratpack/README.md b/ratpack/README.md
index 9c24670709..f42d4c030b 100644
--- a/ratpack/README.md
+++ b/ratpack/README.md
@@ -11,3 +11,4 @@ This module contains articles about Ratpack.
- [Ratpack HTTP Client](https://www.baeldung.com/ratpack-http-client)
- [Ratpack with RxJava](https://www.baeldung.com/ratpack-rxjava)
- [Ratpack with Groovy](https://www.baeldung.com/ratpack-groovy)
+- [Reactive Streams API with Ratpack](https://www.baeldung.com/ratpack-reactive-streams-api)
diff --git a/rule-engines/evrete/README.md b/rule-engines/evrete/README.md
new file mode 100644
index 0000000000..aa9a3a4b9d
--- /dev/null
+++ b/rule-engines/evrete/README.md
@@ -0,0 +1,3 @@
+## Relevant Articles:
+
+- [Introduction to the Evrete Rule Engine](https://www.baeldung.com/java-evrete-rule-engine)
diff --git a/rule-engines/evrete/pom.xml b/rule-engines/evrete/pom.xml
new file mode 100644
index 0000000000..819a912c43
--- /dev/null
+++ b/rule-engines/evrete/pom.xml
@@ -0,0 +1,35 @@
+
+
+ 4.0.0
+ com.baeldung.evrete
+ evrete
+ 1.0
+ evrete
+
+
+ 2.1.04
+
+
+
+ com.baeldung
+ rule-engines
+ 1.0.0-SNAPSHOT
+
+
+
+
+
+ org.evrete
+ evrete-core
+ ${evrete.version}
+
+
+
+ org.evrete
+ evrete-dsl-java
+ ${evrete.version}
+
+
+
\ No newline at end of file
diff --git a/rule-engines/evrete/src/main/java/com/baeldung/evrete/introduction/IntroductionAJR.java b/rule-engines/evrete/src/main/java/com/baeldung/evrete/introduction/IntroductionAJR.java
new file mode 100644
index 0000000000..287d083311
--- /dev/null
+++ b/rule-engines/evrete/src/main/java/com/baeldung/evrete/introduction/IntroductionAJR.java
@@ -0,0 +1,47 @@
+package com.baeldung.evrete.introduction;
+
+import com.baeldung.evrete.introduction.model.Customer;
+import com.baeldung.evrete.introduction.model.Invoice;
+import org.evrete.KnowledgeService;
+import org.evrete.api.Knowledge;
+
+import java.io.IOException;
+import java.net.URL;
+import java.util.*;
+
+public class IntroductionAJR {
+ public static void main(String[] args) throws IOException {
+ ClassLoader classLoader = IntroductionAJR.class.getClassLoader();
+ KnowledgeService service = new KnowledgeService();
+ URL rulesetUrl = classLoader.getResource("rules/SalesRuleset.java");
+ Knowledge knowledge = service.newKnowledge(
+ "JAVA-SOURCE",
+ rulesetUrl
+ );
+
+ List customers = Arrays.asList(
+ new Customer("Customer A"),
+ new Customer("Customer B"),
+ new Customer("Customer C")
+ );
+
+ Random random = new Random();
+ Collection