From eb63164dc6f03b6dcc5fc74ba5b5ee71a151c446 Mon Sep 17 00:00:00 2001 From: parthiv39731 <70740707+parthiv39731@users.noreply.github.com> Date: Sat, 2 Dec 2023 21:38:58 +0530 Subject: [PATCH 1/6] BAEL-7308: Comparing One String with Multiple Values in One Expression in Java --- .../java/compareany/CompareAnyUnitTest.java | 97 +++++++++++++++++++ 1 file changed, 97 insertions(+) create mode 100644 core-java-modules/core-java-string-operations-7/src/test/java/compareany/CompareAnyUnitTest.java diff --git a/core-java-modules/core-java-string-operations-7/src/test/java/compareany/CompareAnyUnitTest.java b/core-java-modules/core-java-string-operations-7/src/test/java/compareany/CompareAnyUnitTest.java new file mode 100644 index 0000000000..778746753c --- /dev/null +++ b/core-java-modules/core-java-string-operations-7/src/test/java/compareany/CompareAnyUnitTest.java @@ -0,0 +1,97 @@ +package compareany; + +import static org.junit.jupiter.api.Assertions.*; + +import java.util.Arrays; +import java.util.Set; + +import org.apache.commons.lang3.ArrayUtils; +import org.apache.commons.lang3.StringUtils; +import org.junit.jupiter.api.Test; + +public class CompareAnyUnitTest { + + @Test + void givenStrings_whenCompareUsingIf_thenSuccess() { + String presentString = "Apple"; + String notPresentString = "Avocado"; + + assertTrue(matchAnyWithIf(presentString, "Mango", "Papaya", "PineApple", "Apple")); + assertFalse(matchAnyWithIf(notPresentString, "Mango", "Papaya", "PineApple", "Apple")); + } + + @Test + void givenStrings_whenCompareUsingArrayUtils_thenSuccess() { + String presentString = "Apple"; + String notPresentString = "Avocado"; + + assertTrue(compareWithAnyUsingArrayUtils(presentString, "Mango", "Papaya", "PineApple", "Apple")); + assertFalse(compareWithAnyUsingArrayUtils(notPresentString, "Mango", "Papaya", "PineApple", "Apple")); + } + + @Test + void givenStrings_whenCompareUsingStringUtils_thenSuccess() { + String presentString = "Apple"; + String notPresentString = "Avocado"; + + assertTrue(compareWithAnyUsingStringUtils(presentString, "Mango", "Papaya", "PineApple", "Apple")); + assertFalse(compareWithAnyUsingStringUtils(notPresentString, "Mango", "Papaya", "PineApple", "Apple")); + } + + @Test + void givenStrings_whenCompareUsingStream_thenSuccess() { + String presentString = "Apple"; + String notPresentString = "Avocado"; + + assertTrue(compareWithAnyUsingStream(presentString, "Mango", "Papaya", "PineApple", "Apple")); + assertFalse(compareWithAnyUsingStream(notPresentString, "Mango", "Papaya", "PineApple", "Apple")); + } + + @Test + void givenStrings_whenCompareUsingSet_thenSuccess() { + String presentString = "Apple"; + String notPresentString = "Avocado"; + + assertTrue(compareWithAnyUsingSet(presentString, "Mango", "Papaya", "PineApple", "Apple")); + assertFalse(compareWithAnyUsingSet(notPresentString, "Mango", "Papaya", "PineApple", "Apple")); + } + + @Test + void givenStrings_whenCompareUsingRegularExpression_thenSuccess() { + String presentString = "Apple"; + String notPresentString = "Avocado"; + + assertTrue(compareWithAnyUsingRegularExpression(presentString, "Mango", "Papaya", "PineApple", "Apple")); + assertFalse(compareWithAnyUsingRegularExpression(notPresentString, "Mango", "Papaya", "PineApple", "Apple")); + } + + private boolean matchAnyWithIf(String str, String ... strs) { + for(String s : strs) { + if (str.equals(s)) { + return true; + } + } + return false; + } + + private boolean compareWithAnyUsingStringUtils(String str, String ... strs) { + return StringUtils.containsAny(str, strs); + } + + private boolean compareWithAnyUsingSet(String str, String ... strs) { + return Set.of(strs).contains(str); + } + + private static boolean compareWithAnyUsingRegularExpression(String str, String ... strs) { + return str.matches(String.join("|", strs)); + } + + private static boolean compareWithAnyUsingStream(String str, String ... strs) { + return Arrays.stream(strs).anyMatch(str::equals); + } + + private static boolean compareWithAnyUsingArrayUtils(String str, String ... strs) { + return ArrayUtils.contains(strs, str); + } + +} From 296e5498e827ed1508b54218e0afbba0617f35ac Mon Sep 17 00:00:00 2001 From: parthiv39731 <70740707+parthiv39731@users.noreply.github.com> Date: Mon, 4 Dec 2023 23:24:24 +0530 Subject: [PATCH 2/6] BAEL-7308: Comparing One String with Multiple Values in One Expression in Java --- .../java/compareany/CompareAnyUnitTest.java | 72 ++++++++++++++----- 1 file changed, 54 insertions(+), 18 deletions(-) diff --git a/core-java-modules/core-java-string-operations-7/src/test/java/compareany/CompareAnyUnitTest.java b/core-java-modules/core-java-string-operations-7/src/test/java/compareany/CompareAnyUnitTest.java index 778746753c..2d6af5456a 100644 --- a/core-java-modules/core-java-string-operations-7/src/test/java/compareany/CompareAnyUnitTest.java +++ b/core-java-modules/core-java-string-operations-7/src/test/java/compareany/CompareAnyUnitTest.java @@ -1,6 +1,7 @@ package compareany; -import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.Arrays; import java.util.Set; @@ -16,8 +17,8 @@ public class CompareAnyUnitTest { String presentString = "Apple"; String notPresentString = "Avocado"; - assertTrue(matchAnyWithIf(presentString, "Mango", "Papaya", "PineApple", "Apple")); - assertFalse(matchAnyWithIf(notPresentString, "Mango", "Papaya", "PineApple", "Apple")); + assertTrue(matchAnyWithIf(presentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertFalse(matchAnyWithIf(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); } @Test @@ -25,8 +26,8 @@ public class CompareAnyUnitTest { String presentString = "Apple"; String notPresentString = "Avocado"; - assertTrue(compareWithAnyUsingArrayUtils(presentString, "Mango", "Papaya", "PineApple", "Apple")); - assertFalse(compareWithAnyUsingArrayUtils(notPresentString, "Mango", "Papaya", "PineApple", "Apple")); + assertTrue(compareWithAnyUsingArrayUtils(presentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertFalse(compareWithAnyUsingArrayUtils(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); } @Test @@ -34,17 +35,34 @@ public class CompareAnyUnitTest { String presentString = "Apple"; String notPresentString = "Avocado"; - assertTrue(compareWithAnyUsingStringUtils(presentString, "Mango", "Papaya", "PineApple", "Apple")); - assertFalse(compareWithAnyUsingStringUtils(notPresentString, "Mango", "Papaya", "PineApple", "Apple")); + assertTrue(compareWithAnyUsingStringUtils(presentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertFalse(compareWithAnyUsingStringUtils(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); } + @Test + void givenStrings_whenCompareCaseInsensitiveUsingStringUtils_thenSuccess() { + String presentString = "APPLE"; + String notPresentString = "AVOCADO"; + + assertTrue(compareWithAnyCaseInsensitiveUsingStringUtils(presentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertFalse(compareWithAnyCaseInsensitiveUsingStringUtils(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); + } @Test void givenStrings_whenCompareUsingStream_thenSuccess() { String presentString = "Apple"; String notPresentString = "Avocado"; - assertTrue(compareWithAnyUsingStream(presentString, "Mango", "Papaya", "PineApple", "Apple")); - assertFalse(compareWithAnyUsingStream(notPresentString, "Mango", "Papaya", "PineApple", "Apple")); + assertTrue(compareWithAnyUsingStream(presentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertFalse(compareWithAnyUsingStream(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); + } + + @Test + void givenStrings_whenCompareCaseInsensitiveUsingStream_thenSuccess() { + String presentString = "APPLE"; + String notPresentString = "AVOCADO"; + + assertTrue(compareWithAnyCaseInsensitiveUsingStream(presentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertFalse(compareWithAnyCaseInsensitiveUsingStream(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); } @Test @@ -52,8 +70,8 @@ public class CompareAnyUnitTest { String presentString = "Apple"; String notPresentString = "Avocado"; - assertTrue(compareWithAnyUsingSet(presentString, "Mango", "Papaya", "PineApple", "Apple")); - assertFalse(compareWithAnyUsingSet(notPresentString, "Mango", "Papaya", "PineApple", "Apple")); + assertTrue(compareWithAnyUsingSet(presentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertFalse(compareWithAnyUsingSet(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); } @Test @@ -61,8 +79,17 @@ public class CompareAnyUnitTest { String presentString = "Apple"; String notPresentString = "Avocado"; - assertTrue(compareWithAnyUsingRegularExpression(presentString, "Mango", "Papaya", "PineApple", "Apple")); - assertFalse(compareWithAnyUsingRegularExpression(notPresentString, "Mango", "Papaya", "PineApple", "Apple")); + assertTrue(compareWithAnyUsingRegularExpression(presentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertFalse(compareWithAnyUsingRegularExpression(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); + } + + @Test + void givenStrings_whenCompareCaseInsensitiveUsingRegularExpression_thenSuccess() { + String presentString = "APPLE"; + String notPresentString = "AVOCADO"; + + assertTrue(compareWithAnyCaseInsensitiveUsingRegularExpression(presentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertFalse(compareWithAnyCaseInsensitiveUsingRegularExpression(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); } private boolean matchAnyWithIf(String str, String ... strs) { @@ -78,20 +105,29 @@ public class CompareAnyUnitTest { return StringUtils.containsAny(str, strs); } + private boolean compareWithAnyCaseInsensitiveUsingStringUtils(String str, String ... strs) { + return StringUtils.containsAnyIgnoreCase(str, strs); + } + private boolean compareWithAnyUsingSet(String str, String ... strs) { return Set.of(strs).contains(str); } - private static boolean compareWithAnyUsingRegularExpression(String str, String ... strs) { + private boolean compareWithAnyUsingRegularExpression(String str, String ... strs) { return str.matches(String.join("|", strs)); } - private static boolean compareWithAnyUsingStream(String str, String ... strs) { + private boolean compareWithAnyCaseInsensitiveUsingRegularExpression(String str, String ... strs) { + return str.matches("(?i)" + String.join("|", strs)); + } + + private boolean compareWithAnyUsingStream(String str, String ... strs) { return Arrays.stream(strs).anyMatch(str::equals); } - - private static boolean compareWithAnyUsingArrayUtils(String str, String ... strs) { + private boolean compareWithAnyCaseInsensitiveUsingStream(String str, String ... strs) { + return Arrays.stream(strs).anyMatch(str::equalsIgnoreCase); + } + private boolean compareWithAnyUsingArrayUtils(String str, String ... strs) { return ArrayUtils.contains(strs, str); } - } From 3a8bae0c8ea7a93b11d9f91435a7f0831c341bb3 Mon Sep 17 00:00:00 2001 From: parthiv39731 <70740707+parthiv39731@users.noreply.github.com> Date: Tue, 5 Dec 2023 23:20:42 +0530 Subject: [PATCH 3/6] BAEL-7308: Comparing One String with Multiple Values in One Expression in Java --- .../compareany/CompareAnyBenchmark.java | 92 +++++++++++++++++++ .../compareany/CompareAnyUnitTest.java | 8 +- 2 files changed, 96 insertions(+), 4 deletions(-) create mode 100644 core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyBenchmark.java rename core-java-modules/core-java-string-operations-7/src/test/java/{ => com/baeldung}/compareany/CompareAnyUnitTest.java (94%) diff --git a/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyBenchmark.java b/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyBenchmark.java new file mode 100644 index 0000000000..70cd1bb3ff --- /dev/null +++ b/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyBenchmark.java @@ -0,0 +1,92 @@ +package com.baeldung.compareany; + +import java.util.Arrays; +import java.util.Set; +import java.util.concurrent.TimeUnit; + +import org.apache.commons.lang3.ArrayUtils; +import org.apache.commons.lang3.StringUtils; +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Measurement; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.Warmup; +import org.openjdk.jmh.runner.Runner; +import org.openjdk.jmh.runner.options.Options; +import org.openjdk.jmh.runner.options.OptionsBuilder; + +@State(Scope.Benchmark) +@BenchmarkMode(Mode.AverageTime) +@Warmup(iterations = 2) +@Measurement(iterations = 5) +@OutputTimeUnit(TimeUnit.NANOSECONDS) +@Fork(value = 1) +public class CompareAnyBenchmark { + private final String[] groupOfFruits = {"Apple", "Mango", "Dragon Fruit", "Water Melon", "Avocado", "Guava", "Orange"}; + private final String fruit = "Apple"; + + @Benchmark + public boolean compareWithAnyUsingStringUtils() { + return StringUtils.containsAny(fruit, groupOfFruits); + } + + @Benchmark + public boolean compareWithAnyCaseInsensitiveUsingStringUtils() { + return StringUtils.containsAnyIgnoreCase(fruit, groupOfFruits); + } + + @Benchmark + public boolean compareWithAnyUsingSet() { + return Set.of(groupOfFruits).contains(fruit); + } + + @Benchmark + public boolean compareWithAnyUsingRegularExpression() { + return fruit.matches(String.join("|", groupOfFruits)); + } + + @Benchmark + public boolean compareWithAnyCaseInsensitiveUsingRegularExpression() { + return fruit.matches("(?i)" + String.join("|", groupOfFruits)); + } + + @Benchmark + public boolean compareWithAnyUsingStream() { + return Arrays.stream(groupOfFruits).anyMatch(fruit::equals); + } + + @Benchmark + public boolean compareWithAnyCaseInsensitiveUsingStream() { + return Arrays.stream(groupOfFruits).anyMatch(fruit::equalsIgnoreCase); + } + + @Benchmark + public boolean compareWithAnyUsingArrayUtils() { + return ArrayUtils.contains(groupOfFruits, fruit); + } + + @Benchmark + public boolean compareWithAnyWithIf() { + for(String s : groupOfFruits) { + if (fruit.equals(s)) { + return true; + } + } + return false; + } + + public static void main(String[] args) throws Exception { + Options options = new OptionsBuilder().include(CompareAnyBenchmark.class.getSimpleName()) + .threads(1) + .shouldFailOnError(true) + .shouldDoGC(true) + .jvmArgs("-server") + .build(); + new Runner(options).run(); + } + +} diff --git a/core-java-modules/core-java-string-operations-7/src/test/java/compareany/CompareAnyUnitTest.java b/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyUnitTest.java similarity index 94% rename from core-java-modules/core-java-string-operations-7/src/test/java/compareany/CompareAnyUnitTest.java rename to core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyUnitTest.java index 2d6af5456a..0995eaf372 100644 --- a/core-java-modules/core-java-string-operations-7/src/test/java/compareany/CompareAnyUnitTest.java +++ b/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyUnitTest.java @@ -1,4 +1,4 @@ -package compareany; +package com.baeldung.compareany; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -17,8 +17,8 @@ public class CompareAnyUnitTest { String presentString = "Apple"; String notPresentString = "Avocado"; - assertTrue(matchAnyWithIf(presentString, "Mango", "Papaya", "Pineapple", "Apple")); - assertFalse(matchAnyWithIf(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertTrue(compareWithAnyWithIf(presentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertFalse(compareWithAnyWithIf(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); } @Test @@ -92,7 +92,7 @@ public class CompareAnyUnitTest { assertFalse(compareWithAnyCaseInsensitiveUsingRegularExpression(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); } - private boolean matchAnyWithIf(String str, String ... strs) { + private boolean compareWithAnyWithIf(String str, String ... strs) { for(String s : strs) { if (str.equals(s)) { return true; From 8ad1043d556756ae024ddb91a6307975bc7e988c Mon Sep 17 00:00:00 2001 From: parthiv39731 <70740707+parthiv39731@users.noreply.github.com> Date: Wed, 6 Dec 2023 14:12:25 +0530 Subject: [PATCH 4/6] BAEL-7308: Comparing One String with Multiple Values in One Expression in Java --- .../compareany/CompareAnyBenchmark.java | 10 ++++++++-- .../compareany/CompareAnyUnitTest.java | 18 ++++++++++++++++-- 2 files changed, 24 insertions(+), 4 deletions(-) diff --git a/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyBenchmark.java b/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyBenchmark.java index 70cd1bb3ff..9a4e5e9431 100644 --- a/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyBenchmark.java +++ b/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyBenchmark.java @@ -1,6 +1,7 @@ package com.baeldung.compareany; import java.util.Arrays; +import java.util.List; import java.util.Set; import java.util.concurrent.TimeUnit; @@ -31,12 +32,12 @@ public class CompareAnyBenchmark { @Benchmark public boolean compareWithAnyUsingStringUtils() { - return StringUtils.containsAny(fruit, groupOfFruits); + return StringUtils.equalsAny(fruit, groupOfFruits); } @Benchmark public boolean compareWithAnyCaseInsensitiveUsingStringUtils() { - return StringUtils.containsAnyIgnoreCase(fruit, groupOfFruits); + return StringUtils.equalsAnyIgnoreCase(fruit, groupOfFruits); } @Benchmark @@ -44,6 +45,11 @@ public class CompareAnyBenchmark { return Set.of(groupOfFruits).contains(fruit); } + @Benchmark + public boolean compareWithAnyUsingList() { + return List.of(groupOfFruits).contains(fruit); + } + @Benchmark public boolean compareWithAnyUsingRegularExpression() { return fruit.matches(String.join("|", groupOfFruits)); diff --git a/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyUnitTest.java b/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyUnitTest.java index 0995eaf372..818035971d 100644 --- a/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyUnitTest.java +++ b/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyUnitTest.java @@ -4,6 +4,7 @@ import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.Arrays; +import java.util.List; import java.util.Set; import org.apache.commons.lang3.ArrayUtils; @@ -74,6 +75,15 @@ public class CompareAnyUnitTest { assertFalse(compareWithAnyUsingSet(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); } + @Test + void givenStrings_whenCompareUsingList_thenSuccess() { + String presentString = "Apple"; + String notPresentString = "Avocado"; + + assertTrue(compareWithAnyUsingList(presentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertFalse(compareWithAnyUsingList(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); + } + @Test void givenStrings_whenCompareUsingRegularExpression_thenSuccess() { String presentString = "Apple"; @@ -102,17 +112,21 @@ public class CompareAnyUnitTest { } private boolean compareWithAnyUsingStringUtils(String str, String ... strs) { - return StringUtils.containsAny(str, strs); + return StringUtils.equalsAny(str, strs); } private boolean compareWithAnyCaseInsensitiveUsingStringUtils(String str, String ... strs) { - return StringUtils.containsAnyIgnoreCase(str, strs); + return StringUtils.equalsAnyIgnoreCase(str, strs); } private boolean compareWithAnyUsingSet(String str, String ... strs) { return Set.of(strs).contains(str); } + private boolean compareWithAnyUsingList(String str, String ... strs) { + return List.of(strs).contains(str); + } + private boolean compareWithAnyUsingRegularExpression(String str, String ... strs) { return str.matches(String.join("|", strs)); } From 2a835a364a5f33e9c333f80315341ab3b3db5ff4 Mon Sep 17 00:00:00 2001 From: parthiv39731 <70740707+parthiv39731@users.noreply.github.com> Date: Sat, 16 Dec 2023 00:16:22 +0530 Subject: [PATCH 5/6] BAEL-7308, renamed methods --- .../compareany/CompareAnyBenchmark.java | 20 ++--- .../compareany/CompareAnyUnitTest.java | 85 ++++++++++--------- 2 files changed, 54 insertions(+), 51 deletions(-) diff --git a/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyBenchmark.java b/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyBenchmark.java index 9a4e5e9431..c018cca718 100644 --- a/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyBenchmark.java +++ b/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyBenchmark.java @@ -31,52 +31,52 @@ public class CompareAnyBenchmark { private final String fruit = "Apple"; @Benchmark - public boolean compareWithAnyUsingStringUtils() { + public boolean compareWithMultipleStringsUsingStringUtils() { return StringUtils.equalsAny(fruit, groupOfFruits); } @Benchmark - public boolean compareWithAnyCaseInsensitiveUsingStringUtils() { + public boolean compareCaseInsensitiveWithMultipleStringsUsingStringUtils() { return StringUtils.equalsAnyIgnoreCase(fruit, groupOfFruits); } @Benchmark - public boolean compareWithAnyUsingSet() { + public boolean compareWithMultipleStringsUsingSet() { return Set.of(groupOfFruits).contains(fruit); } @Benchmark - public boolean compareWithAnyUsingList() { + public boolean compareWithMultipleStringsUsingList() { return List.of(groupOfFruits).contains(fruit); } @Benchmark - public boolean compareWithAnyUsingRegularExpression() { + public boolean compareWithMultipleStringsUsingRegularExpression() { return fruit.matches(String.join("|", groupOfFruits)); } @Benchmark - public boolean compareWithAnyCaseInsensitiveUsingRegularExpression() { + public boolean compareCaseInsensitiveWithMultipleStringsUsingRegularExpression() { return fruit.matches("(?i)" + String.join("|", groupOfFruits)); } @Benchmark - public boolean compareWithAnyUsingStream() { + public boolean compareWithMultipleStringsUsingStream() { return Arrays.stream(groupOfFruits).anyMatch(fruit::equals); } @Benchmark - public boolean compareWithAnyCaseInsensitiveUsingStream() { + public boolean compareCaseInsensitiveWithMultipleStringsUsingStream() { return Arrays.stream(groupOfFruits).anyMatch(fruit::equalsIgnoreCase); } @Benchmark - public boolean compareWithAnyUsingArrayUtils() { + public boolean compareWithMultipleStringsUsingArrayUtils() { return ArrayUtils.contains(groupOfFruits, fruit); } @Benchmark - public boolean compareWithAnyWithIf() { + public boolean compareWithMultipleStringsUsingIf() { for(String s : groupOfFruits) { if (fruit.equals(s)) { return true; diff --git a/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyUnitTest.java b/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyUnitTest.java index 818035971d..b26c05720d 100644 --- a/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyUnitTest.java +++ b/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyUnitTest.java @@ -14,96 +14,97 @@ import org.junit.jupiter.api.Test; public class CompareAnyUnitTest { @Test - void givenStrings_whenCompareUsingIf_thenSuccess() { + void givenStrings_whenCompareWithMultipleStringsUsingIf_thenSuccess() { String presentString = "Apple"; String notPresentString = "Avocado"; - assertTrue(compareWithAnyWithIf(presentString, "Mango", "Papaya", "Pineapple", "Apple")); - assertFalse(compareWithAnyWithIf(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertTrue(compareWithMultipleStringsUsingIf(presentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertFalse(compareWithMultipleStringsUsingIf(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); } @Test - void givenStrings_whenCompareUsingArrayUtils_thenSuccess() { + void givenStrings_whenCompareWithMultipleStringsUsingArrayUtils_thenSuccess() { String presentString = "Apple"; String notPresentString = "Avocado"; - assertTrue(compareWithAnyUsingArrayUtils(presentString, "Mango", "Papaya", "Pineapple", "Apple")); - assertFalse(compareWithAnyUsingArrayUtils(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertTrue(compareWithMultipleStringsUsingArrayUtils(presentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertFalse(compareWithMultipleStringsUsingArrayUtils(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); } @Test - void givenStrings_whenCompareUsingStringUtils_thenSuccess() { + void givenStrings_whenCompareWithMultipleStringsUsingStringUtils_thenSuccess() { String presentString = "Apple"; String notPresentString = "Avocado"; - assertTrue(compareWithAnyUsingStringUtils(presentString, "Mango", "Papaya", "Pineapple", "Apple")); - assertFalse(compareWithAnyUsingStringUtils(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertTrue(compareWithMultipleStringsUsingStringUtils(presentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertFalse(compareWithMultipleStringsUsingStringUtils(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); } @Test - void givenStrings_whenCompareCaseInsensitiveUsingStringUtils_thenSuccess() { + void givenStrings_whenCompareCaseInsensitiveWithMultipleStringsUsingStringUtils_thenSuccess() { String presentString = "APPLE"; String notPresentString = "AVOCADO"; - assertTrue(compareWithAnyCaseInsensitiveUsingStringUtils(presentString, "Mango", "Papaya", "Pineapple", "Apple")); - assertFalse(compareWithAnyCaseInsensitiveUsingStringUtils(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertTrue(compareCaseInsensitiveWithMultipleStringsUsingStringUtils(presentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertFalse(compareCaseInsensitiveWithMultipleStringsUsingStringUtils(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); } + @Test - void givenStrings_whenCompareUsingStream_thenSuccess() { + void givenStrings_whenCompareWithMultipleStringsUsingStream_thenSuccess() { String presentString = "Apple"; String notPresentString = "Avocado"; - assertTrue(compareWithAnyUsingStream(presentString, "Mango", "Papaya", "Pineapple", "Apple")); - assertFalse(compareWithAnyUsingStream(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertTrue(compareWithMultipleStringsUsingStream(presentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertFalse(compareWithMultipleStringsUsingStream(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); } @Test - void givenStrings_whenCompareCaseInsensitiveUsingStream_thenSuccess() { + void givenStrings_whenCompareCaseInsensitiveWithMultipleStringsUsingStream_thenSuccess() { String presentString = "APPLE"; String notPresentString = "AVOCADO"; - assertTrue(compareWithAnyCaseInsensitiveUsingStream(presentString, "Mango", "Papaya", "Pineapple", "Apple")); - assertFalse(compareWithAnyCaseInsensitiveUsingStream(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertTrue(compareCaseInsensitiveWithMultipleStringsUsingStream(presentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertFalse(compareCaseInsensitiveWithMultipleStringsUsingStream(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); } @Test - void givenStrings_whenCompareUsingSet_thenSuccess() { + void givenStrings_whenCompareWithMultipleStringsUsingSet_thenSuccess() { String presentString = "Apple"; String notPresentString = "Avocado"; - assertTrue(compareWithAnyUsingSet(presentString, "Mango", "Papaya", "Pineapple", "Apple")); - assertFalse(compareWithAnyUsingSet(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertTrue(compareWithMultipleStringUsingSet(presentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertFalse(compareWithMultipleStringUsingSet(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); } @Test - void givenStrings_whenCompareUsingList_thenSuccess() { + void givenStrings_whenCompareWithMultipleStringsUsingList_thenSuccess() { String presentString = "Apple"; String notPresentString = "Avocado"; - assertTrue(compareWithAnyUsingList(presentString, "Mango", "Papaya", "Pineapple", "Apple")); - assertFalse(compareWithAnyUsingList(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertTrue(compareWithMultipleStringsUsingList(presentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertFalse(compareWithMultipleStringsUsingList(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); } @Test - void givenStrings_whenCompareUsingRegularExpression_thenSuccess() { + void givenStrings_whenCompareWithMultipleStringsUsingRegularExpression_thenSuccess() { String presentString = "Apple"; String notPresentString = "Avocado"; - assertTrue(compareWithAnyUsingRegularExpression(presentString, "Mango", "Papaya", "Pineapple", "Apple")); - assertFalse(compareWithAnyUsingRegularExpression(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertTrue(compareWithMultipleStringsUsingRegularExpression(presentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertFalse(compareWithMultipleStringsUsingRegularExpression(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); } @Test - void givenStrings_whenCompareCaseInsensitiveUsingRegularExpression_thenSuccess() { + void givenStrings_whenCompareCaseInsensitiveWithMultipleStringsUsingRegularExpression_thenSuccess() { String presentString = "APPLE"; String notPresentString = "AVOCADO"; - assertTrue(compareWithAnyCaseInsensitiveUsingRegularExpression(presentString, "Mango", "Papaya", "Pineapple", "Apple")); - assertFalse(compareWithAnyCaseInsensitiveUsingRegularExpression(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertTrue(compareCaseInsensitiveWithMultipleStringsUsingRegularExpression(presentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertFalse(compareCaseInsensitiveWithMultipleStringsUsingRegularExpression(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); } - private boolean compareWithAnyWithIf(String str, String ... strs) { - for(String s : strs) { + private boolean compareWithMultipleStringsUsingIf(String str, String... strs) { + for (String s : strs) { if (str.equals(s)) { return true; } @@ -111,37 +112,39 @@ public class CompareAnyUnitTest { return false; } - private boolean compareWithAnyUsingStringUtils(String str, String ... strs) { + private boolean compareWithMultipleStringsUsingStringUtils(String str, String... strs) { return StringUtils.equalsAny(str, strs); } - private boolean compareWithAnyCaseInsensitiveUsingStringUtils(String str, String ... strs) { + private boolean compareCaseInsensitiveWithMultipleStringsUsingStringUtils(String str, String... strs) { return StringUtils.equalsAnyIgnoreCase(str, strs); } - private boolean compareWithAnyUsingSet(String str, String ... strs) { + private boolean compareWithMultipleStringUsingSet(String str, String... strs) { return Set.of(strs).contains(str); } - private boolean compareWithAnyUsingList(String str, String ... strs) { + private boolean compareWithMultipleStringsUsingList(String str, String... strs) { return List.of(strs).contains(str); } - private boolean compareWithAnyUsingRegularExpression(String str, String ... strs) { + private boolean compareWithMultipleStringsUsingRegularExpression(String str, String... strs) { return str.matches(String.join("|", strs)); } - private boolean compareWithAnyCaseInsensitiveUsingRegularExpression(String str, String ... strs) { + private boolean compareCaseInsensitiveWithMultipleStringsUsingRegularExpression(String str, String... strs) { return str.matches("(?i)" + String.join("|", strs)); } - private boolean compareWithAnyUsingStream(String str, String ... strs) { + private boolean compareWithMultipleStringsUsingStream(String str, String... strs) { return Arrays.stream(strs).anyMatch(str::equals); } - private boolean compareWithAnyCaseInsensitiveUsingStream(String str, String ... strs) { + + private boolean compareCaseInsensitiveWithMultipleStringsUsingStream(String str, String... strs) { return Arrays.stream(strs).anyMatch(str::equalsIgnoreCase); } - private boolean compareWithAnyUsingArrayUtils(String str, String ... strs) { + + private boolean compareWithMultipleStringsUsingArrayUtils(String str, String... strs) { return ArrayUtils.contains(strs, str); } } From 089f715d8dea4a5f2b99842579ff478555f6cbb6 Mon Sep 17 00:00:00 2001 From: parthiv39731 <70740707+parthiv39731@users.noreply.github.com> Date: Tue, 19 Dec 2023 21:23:38 +0530 Subject: [PATCH 6/6] BAEL-7308, renamed methods --- .../java/com/baeldung/compareany/CompareAnyUnitTest.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyUnitTest.java b/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyUnitTest.java index b26c05720d..052be2fe58 100644 --- a/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyUnitTest.java +++ b/core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyUnitTest.java @@ -72,8 +72,8 @@ public class CompareAnyUnitTest { String presentString = "Apple"; String notPresentString = "Avocado"; - assertTrue(compareWithMultipleStringUsingSet(presentString, "Mango", "Papaya", "Pineapple", "Apple")); - assertFalse(compareWithMultipleStringUsingSet(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertTrue(compareWithMultipleStringsUsingSet(presentString, "Mango", "Papaya", "Pineapple", "Apple")); + assertFalse(compareWithMultipleStringsUsingSet(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); } @Test @@ -120,7 +120,7 @@ public class CompareAnyUnitTest { return StringUtils.equalsAnyIgnoreCase(str, strs); } - private boolean compareWithMultipleStringUsingSet(String str, String... strs) { + private boolean compareWithMultipleStringsUsingSet(String str, String... strs) { return Set.of(strs).contains(str); }