iSharkFly-Docs
/
java-tutorials
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

BAEL-7308, renamed methods

This commit is contained in:
parthiv39731 2023-12-16 00:16:22 +05:30
parent 8ad1043d55
commit 2a835a364a
2 changed files with 54 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyBenchmark.java
View File

@ -31,52 +31,52 @@ public class CompareAnyBenchmark {
private final String fruit = "Apple"; private final String fruit = "Apple";
@Benchmark @Benchmark
public boolean compareWithAnyUsingStringUtils() { public boolean compareWithMultipleStringsUsingStringUtils() {
return StringUtils.equalsAny(fruit, groupOfFruits); return StringUtils.equalsAny(fruit, groupOfFruits);
} }
@Benchmark @Benchmark
public boolean compareWithAnyCaseInsensitiveUsingStringUtils() { public boolean compareCaseInsensitiveWithMultipleStringsUsingStringUtils() {
return StringUtils.equalsAnyIgnoreCase(fruit, groupOfFruits); return StringUtils.equalsAnyIgnoreCase(fruit, groupOfFruits);
} }
@Benchmark @Benchmark
public boolean compareWithAnyUsingSet() { public boolean compareWithMultipleStringsUsingSet() {
return Set.of(groupOfFruits).contains(fruit); return Set.of(groupOfFruits).contains(fruit);
} }
@Benchmark @Benchmark
public boolean compareWithAnyUsingList() { public boolean compareWithMultipleStringsUsingList() {
return List.of(groupOfFruits).contains(fruit); return List.of(groupOfFruits).contains(fruit);
} }
@Benchmark @Benchmark
public boolean compareWithAnyUsingRegularExpression() { public boolean compareWithMultipleStringsUsingRegularExpression() {
return fruit.matches(String.join("|", groupOfFruits)); return fruit.matches(String.join("|", groupOfFruits));
} }
@Benchmark @Benchmark
public boolean compareWithAnyCaseInsensitiveUsingRegularExpression() { public boolean compareCaseInsensitiveWithMultipleStringsUsingRegularExpression() {
return fruit.matches("(?i)" + String.join("|", groupOfFruits)); return fruit.matches("(?i)" + String.join("|", groupOfFruits));
} }
@Benchmark @Benchmark
public boolean compareWithAnyUsingStream() { public boolean compareWithMultipleStringsUsingStream() {
return Arrays.stream(groupOfFruits).anyMatch(fruit::equals); return Arrays.stream(groupOfFruits).anyMatch(fruit::equals);
} }
@Benchmark @Benchmark
public boolean compareWithAnyCaseInsensitiveUsingStream() { public boolean compareCaseInsensitiveWithMultipleStringsUsingStream() {
return Arrays.stream(groupOfFruits).anyMatch(fruit::equalsIgnoreCase); return Arrays.stream(groupOfFruits).anyMatch(fruit::equalsIgnoreCase);
} }
@Benchmark @Benchmark
public boolean compareWithAnyUsingArrayUtils() { public boolean compareWithMultipleStringsUsingArrayUtils() {
return ArrayUtils.contains(groupOfFruits, fruit); return ArrayUtils.contains(groupOfFruits, fruit);
} }
@Benchmark @Benchmark
public boolean compareWithAnyWithIf() { public boolean compareWithMultipleStringsUsingIf() {
for(String s : groupOfFruits) { for(String s : groupOfFruits) {
if (fruit.equals(s)) { if (fruit.equals(s)) {
return true; return true;

83
core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/compareany/CompareAnyUnitTest.java
View File

@ -14,95 +14,96 @@ import org.junit.jupiter.api.Test;
public class CompareAnyUnitTest { public class CompareAnyUnitTest {
@Test @Test
void givenStrings_whenCompareUsingIf_thenSuccess() { void givenStrings_whenCompareWithMultipleStringsUsingIf_thenSuccess() {
String presentString = "Apple"; String presentString = "Apple";
String notPresentString = "Avocado"; String notPresentString = "Avocado";
assertTrue(compareWithAnyWithIf(presentString, "Mango", "Papaya", "Pineapple", "Apple")); assertTrue(compareWithMultipleStringsUsingIf(presentString, "Mango", "Papaya", "Pineapple", "Apple"));
assertFalse(compareWithAnyWithIf(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); assertFalse(compareWithMultipleStringsUsingIf(notPresentString, "Mango", "Papaya", "Pineapple", "Apple"));
} }
@Test @Test
void givenStrings_whenCompareUsingArrayUtils_thenSuccess() { void givenStrings_whenCompareWithMultipleStringsUsingArrayUtils_thenSuccess() {
String presentString = "Apple"; String presentString = "Apple";
String notPresentString = "Avocado"; String notPresentString = "Avocado";
assertTrue(compareWithAnyUsingArrayUtils(presentString, "Mango", "Papaya", "Pineapple", "Apple")); assertTrue(compareWithMultipleStringsUsingArrayUtils(presentString, "Mango", "Papaya", "Pineapple", "Apple"));
assertFalse(compareWithAnyUsingArrayUtils(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); assertFalse(compareWithMultipleStringsUsingArrayUtils(notPresentString, "Mango", "Papaya", "Pineapple", "Apple"));
} }
@Test @Test
void givenStrings_whenCompareUsingStringUtils_thenSuccess() { void givenStrings_whenCompareWithMultipleStringsUsingStringUtils_thenSuccess() {
String presentString = "Apple"; String presentString = "Apple";
String notPresentString = "Avocado"; String notPresentString = "Avocado";
assertTrue(compareWithAnyUsingStringUtils(presentString, "Mango", "Papaya", "Pineapple", "Apple")); assertTrue(compareWithMultipleStringsUsingStringUtils(presentString, "Mango", "Papaya", "Pineapple", "Apple"));
assertFalse(compareWithAnyUsingStringUtils(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); assertFalse(compareWithMultipleStringsUsingStringUtils(notPresentString, "Mango", "Papaya", "Pineapple", "Apple"));
} }
@Test @Test
void givenStrings_whenCompareCaseInsensitiveUsingStringUtils_thenSuccess() { void givenStrings_whenCompareCaseInsensitiveWithMultipleStringsUsingStringUtils_thenSuccess() {
String presentString = "APPLE"; String presentString = "APPLE";
String notPresentString = "AVOCADO"; String notPresentString = "AVOCADO";
assertTrue(compareWithAnyCaseInsensitiveUsingStringUtils(presentString, "Mango", "Papaya", "Pineapple", "Apple")); assertTrue(compareCaseInsensitiveWithMultipleStringsUsingStringUtils(presentString, "Mango", "Papaya", "Pineapple", "Apple"));
assertFalse(compareWithAnyCaseInsensitiveUsingStringUtils(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); assertFalse(compareCaseInsensitiveWithMultipleStringsUsingStringUtils(notPresentString, "Mango", "Papaya", "Pineapple", "Apple"));
} }
@Test @Test
void givenStrings_whenCompareUsingStream_thenSuccess() { void givenStrings_whenCompareWithMultipleStringsUsingStream_thenSuccess() {
String presentString = "Apple"; String presentString = "Apple";
String notPresentString = "Avocado"; String notPresentString = "Avocado";
assertTrue(compareWithAnyUsingStream(presentString, "Mango", "Papaya", "Pineapple", "Apple")); assertTrue(compareWithMultipleStringsUsingStream(presentString, "Mango", "Papaya", "Pineapple", "Apple"));
assertFalse(compareWithAnyUsingStream(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); assertFalse(compareWithMultipleStringsUsingStream(notPresentString, "Mango", "Papaya", "Pineapple", "Apple"));
} }
@Test @Test
void givenStrings_whenCompareCaseInsensitiveUsingStream_thenSuccess() { void givenStrings_whenCompareCaseInsensitiveWithMultipleStringsUsingStream_thenSuccess() {
String presentString = "APPLE"; String presentString = "APPLE";
String notPresentString = "AVOCADO"; String notPresentString = "AVOCADO";
assertTrue(compareWithAnyCaseInsensitiveUsingStream(presentString, "Mango", "Papaya", "Pineapple", "Apple")); assertTrue(compareCaseInsensitiveWithMultipleStringsUsingStream(presentString, "Mango", "Papaya", "Pineapple", "Apple"));
assertFalse(compareWithAnyCaseInsensitiveUsingStream(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); assertFalse(compareCaseInsensitiveWithMultipleStringsUsingStream(notPresentString, "Mango", "Papaya", "Pineapple", "Apple"));
} }
@Test @Test
void givenStrings_whenCompareUsingSet_thenSuccess() { void givenStrings_whenCompareWithMultipleStringsUsingSet_thenSuccess() {
String presentString = "Apple"; String presentString = "Apple";
String notPresentString = "Avocado"; String notPresentString = "Avocado";
assertTrue(compareWithAnyUsingSet(presentString, "Mango", "Papaya", "Pineapple", "Apple")); assertTrue(compareWithMultipleStringUsingSet(presentString, "Mango", "Papaya", "Pineapple", "Apple"));
assertFalse(compareWithAnyUsingSet(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); assertFalse(compareWithMultipleStringUsingSet(notPresentString, "Mango", "Papaya", "Pineapple", "Apple"));
} }
@Test @Test
void givenStrings_whenCompareUsingList_thenSuccess() { void givenStrings_whenCompareWithMultipleStringsUsingList_thenSuccess() {
String presentString = "Apple"; String presentString = "Apple";
String notPresentString = "Avocado"; String notPresentString = "Avocado";
assertTrue(compareWithAnyUsingList(presentString, "Mango", "Papaya", "Pineapple", "Apple")); assertTrue(compareWithMultipleStringsUsingList(presentString, "Mango", "Papaya", "Pineapple", "Apple"));
assertFalse(compareWithAnyUsingList(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); assertFalse(compareWithMultipleStringsUsingList(notPresentString, "Mango", "Papaya", "Pineapple", "Apple"));
} }
@Test @Test
void givenStrings_whenCompareUsingRegularExpression_thenSuccess() { void givenStrings_whenCompareWithMultipleStringsUsingRegularExpression_thenSuccess() {
String presentString = "Apple"; String presentString = "Apple";
String notPresentString = "Avocado"; String notPresentString = "Avocado";
assertTrue(compareWithAnyUsingRegularExpression(presentString, "Mango", "Papaya", "Pineapple", "Apple")); assertTrue(compareWithMultipleStringsUsingRegularExpression(presentString, "Mango", "Papaya", "Pineapple", "Apple"));
assertFalse(compareWithAnyUsingRegularExpression(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); assertFalse(compareWithMultipleStringsUsingRegularExpression(notPresentString, "Mango", "Papaya", "Pineapple", "Apple"));
} }
@Test @Test
void givenStrings_whenCompareCaseInsensitiveUsingRegularExpression_thenSuccess() { void givenStrings_whenCompareCaseInsensitiveWithMultipleStringsUsingRegularExpression_thenSuccess() {
String presentString = "APPLE"; String presentString = "APPLE";
String notPresentString = "AVOCADO"; String notPresentString = "AVOCADO";
assertTrue(compareWithAnyCaseInsensitiveUsingRegularExpression(presentString, "Mango", "Papaya", "Pineapple", "Apple")); assertTrue(compareCaseInsensitiveWithMultipleStringsUsingRegularExpression(presentString, "Mango", "Papaya", "Pineapple", "Apple"));
assertFalse(compareWithAnyCaseInsensitiveUsingRegularExpression(notPresentString, "Mango", "Papaya", "Pineapple", "Apple")); assertFalse(compareCaseInsensitiveWithMultipleStringsUsingRegularExpression(notPresentString, "Mango", "Papaya", "Pineapple", "Apple"));
} }
private boolean compareWithAnyWithIf(String str, String ... strs) { private boolean compareWithMultipleStringsUsingIf(String str, String... strs) {
for (String s : strs) { for (String s : strs) {
if (str.equals(s)) { if (str.equals(s)) {
return true; return true;
@ -111,37 +112,39 @@ public class CompareAnyUnitTest {
return false; return false;
} }
private boolean compareWithAnyUsingStringUtils(String str, String ... strs) { private boolean compareWithMultipleStringsUsingStringUtils(String str, String... strs) {
return StringUtils.equalsAny(str, 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); 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); 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); 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)); 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)); 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); 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); 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); return ArrayUtils.contains(strs, str);
} }
} }