mindol1004/spring-boot-rest
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Move articles out of java-strings part4

Browse Source
This commit is contained in:
catalin-burcea
2019-10-29 14:54:28 +02:00
parent 994651a49f
commit ba50a42d43
55 changed files with 299 additions and 340 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
java-strings-2/README.md
View File

@@ -5,13 +5,7 @@ This module contains articles about strings in Java.
### Relevant Articles:
- [Java Localization – Formatting Messages](https://www.baeldung.com/java-localization-messages-formatting)
- [Check If a String Contains a Substring](https://www.baeldung.com/java-string-contains-substring)
- [Java – Generate Random String](https://www.baeldung.com/java-random-string)
- [Java Base64 Encoding and Decoding](https://www.baeldung.com/java-base64-encode-and-decode)
- [Concatenating Strings In Java](https://www.baeldung.com/java-strings-concatenation)
- [Java String Interview Questions and Answers](https://www.baeldung.com/java-string-interview-questions)
- [Checking for Empty or Blank Strings in Java](https://www.baeldung.com/java-blank-empty-strings)
- [String Initialization in Java](https://www.baeldung.com/java-string-initialization)
- [Java Multi-line String](https://www.baeldung.com/java-multiline-string)
- [String toLowerCase and toUpperCase Methods in Java](https://www.baeldung.com/java-string-convert-case)
- More articles: [[<-- prev>]](/java-strings) [[next -->]](/java-strings-3)
- More articles: [[<-- prev>]](/java-strings)

8
java-strings-2/src/main/java/com/baeldung/string/emptystrings/EmptyStringCheck.java
View File

@@ -1,8 +0,0 @@
package com.baeldung.string.emptystrings;
class EmptyStringCheck {
boolean isEmptyString(String string) {
return string == null || string.isEmpty();
}
}

8
java-strings-2/src/main/java/com/baeldung/string/emptystrings/Java5EmptyStringCheck.java
View File

@@ -1,8 +0,0 @@
package com.baeldung.string.emptystrings;
class Java5EmptyStringCheck {
boolean isEmptyString(String string) {
return string == null || string.length() == 0;
}
}

8
java-strings-2/src/main/java/com/baeldung/string/emptystrings/PlainJavaBlankStringCheck.java
View File

@@ -1,8 +0,0 @@
package com.baeldung.string.emptystrings;
class PlainJavaBlankStringCheck {
boolean isBlankString(String string) {
return string == null || string.trim().isEmpty();
}
}

14
java-strings-2/src/main/java/com/baeldung/string/emptystrings/SomeClassWithValidations.java
View File

@@ -1,14 +0,0 @@
package com.baeldung.string.emptystrings;
import javax.validation.constraints.Pattern;
class SomeClassWithValidations {
@Pattern(regexp = "\\A(?!\\s*\\Z).+")
private String someString;
SomeClassWithValidations setSomeString(String someString) {
this.someString = someString;
return this;
}
}

58
java-strings-2/src/main/java/com/baeldung/string/search/performance/SubstringSearchPerformanceComparison.java
View File

@@ -1,58 +0,0 @@
package com.baeldung.string.search.performance;
import java.util.concurrent.TimeUnit;
import java.util.regex.Pattern;
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.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
/**
* Based on https://github.com/tedyoung/indexof-contains-benchmark
*/
@Fork(5)
@State(Scope.Benchmark)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class SubstringSearchPerformanceComparison {
private String message;
private Pattern pattern;
public static void main(String[] args) throws Exception {
org.openjdk.jmh.Main.main(args);
}
@Setup
public void setup() {
message = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum";
pattern = Pattern.compile("(?<!\\S)" + "eiusmod" + "(?!\\S)");
}
@Benchmark
public int indexOf() {
return message.indexOf("eiusmod");
}
@Benchmark
public boolean contains() {
return message.contains("eiusmod");
}
@Benchmark
public boolean containsStringUtilsIgnoreCase() {
return StringUtils.containsIgnoreCase(message, "eiusmod");
}
@Benchmark
public boolean searchWithPattern() {
return pattern.matcher(message).find();
}
}

105
java-strings-2/src/test/java/com/baeldung/StringConcatenationUnitTest.java
View File

@@ -1,105 +0,0 @@
package com.baeldung;
import org.junit.Test;
import java.util.Arrays;
import java.util.List;
import java.util.StringJoiner;
import java.util.stream.Collectors;
import static org.junit.Assert.assertEquals;
public class StringConcatenationUnitTest {
@Test
public void givenMultipleStrings_whenConcatUsingStringBuilder_checkStringCorrect() {
StringBuilder stringBuilder = new StringBuilder(100);
stringBuilder.append("Baeldung");
stringBuilder.append(" is");
stringBuilder.append(" awesome");
assertEquals("Baeldung is awesome", stringBuilder.toString());
}
@Test
public void givenMultipleString_whenConcatUsingAdditionOperator_checkStringCorrect() {
String myString = "The " + "quick " + "brown " + "fox...";
assertEquals("The quick brown fox...", myString);
}
@Test
public void givenMultipleStrings_whenConcatUsingStringFormat_checkStringCorrect() {
String myString = String.format("%s %s %.2f %s %s, %s...", "I",
"ate",
2.5056302,
"blueberry",
"pies",
"oops");
assertEquals("I ate 2.51 blueberry pies, oops...", myString);
}
@Test
public void givenMultipleStrings_whenStringConcatUsed_checkStringCorrect() {
String myString = "Both".concat(" fickle")
.concat(" dwarves")
.concat(" jinx")
.concat(" my")
.concat(" pig")
.concat(" quiz");
assertEquals("Both fickle dwarves jinx my pig quiz", myString);
}
@Test
public void givenMultipleStrings_whenStringJoinUsed_checkStringCorrect() {
String[] strings = {"I'm", "running", "out", "of", "pangrams!"};
String myString = String.join(" ", strings);
assertEquals("I'm running out of pangrams!", myString);
}
@Test
public void givenMultipleStrings_whenStringJoinerUsed_checkStringCorrect() {
StringJoiner fruitJoiner = new StringJoiner(", ");
fruitJoiner.add("Apples");
fruitJoiner.add("Oranges");
fruitJoiner.add("Bananas");
assertEquals("Apples, Oranges, Bananas", fruitJoiner.toString());
}
@Test
public void givenMultipleStrings_whenArrayJoiner_checkStringCorrect() {
String[] myFavouriteLanguages = {"Java", "JavaScript", "Python"};
String toString = Arrays.toString(myFavouriteLanguages);
assertEquals("[Java, JavaScript, Python]", toString);
}
@Test
public void givenArrayListOfStrings_whenCollectorsJoin_checkStringCorrect() {
List<String> awesomeAnimals = Arrays.asList("Shark", "Panda", "Armadillo");
String animalString = awesomeAnimals.stream().collect(Collectors.joining(", "));
assertEquals("Shark, Panda, Armadillo", animalString);
}
}

56
java-strings-2/src/test/java/com/baeldung/base64encodinganddecoding/ApacheCommonsEncodeDecodeUnitTest.java
View File

@@ -1,56 +0,0 @@
package com.baeldung.base64encodinganddecoding;
import org.apache.commons.codec.binary.Base64;
import org.junit.Test;
import java.io.UnsupportedEncodingException;
import static org.junit.Assert.*;
public class ApacheCommonsEncodeDecodeUnitTest {
// tests
@Test
public void whenStringIsEncoded() throws UnsupportedEncodingException {
final String originalInput = "test input";
final Base64 base64 = new Base64();
final String encodedString = new String(base64.encode(originalInput.getBytes()));
assertNotNull(encodedString);
assertNotEquals(originalInput, encodedString);
}
@Test
public void whenStringIsEncoded_thenStringCanBeDecoded() throws UnsupportedEncodingException {
final String originalInput = "test input";
final Base64 base64 = new Base64();
final String encodedString = new String(base64.encode(originalInput.getBytes()));
final String decodedString = new String(base64.decode(encodedString.getBytes()));
assertNotNull(decodedString);
assertEquals(originalInput, decodedString);
}
@Test
public void whenStringIsEncodedUsingStaticMethod() throws UnsupportedEncodingException {
final String originalInput = "test input";
final String encodedString = new String(Base64.encodeBase64(originalInput.getBytes()));
assertNotNull(encodedString);
assertNotEquals(originalInput, encodedString);
}
@Test
public void whenStringIsEncodedUsingStaticMethod_thenStringCanBeDecodedUsingStaticMethod() throws UnsupportedEncodingException {
final String originalInput = "test input";
final String encodedString = new String(Base64.encodeBase64(originalInput.getBytes()));
final String decodedString = new String(Base64.decodeBase64(encodedString.getBytes()));
assertNotNull(decodedString);
assertEquals(originalInput, decodedString);
}
}

109
java-strings-2/src/test/java/com/baeldung/base64encodinganddecoding/Java8EncodeDecodeUnitTest.java
View File

@@ -1,109 +0,0 @@
package com.baeldung.base64encodinganddecoding;
import org.junit.Test;
import java.io.UnsupportedEncodingException;
import java.util.Base64;
import java.util.UUID;
import static org.junit.Assert.*;
public class Java8EncodeDecodeUnitTest {
// tests
@Test
public void whenStringIsEncoded_thenOk() throws UnsupportedEncodingException {
final String originalInput = "test input";
final String encodedString = Base64.getEncoder().encodeToString(originalInput.getBytes());
assertNotNull(encodedString);
assertNotEquals(originalInput, encodedString);
}
@Test
public void whenStringIsEncoded_thenStringCanBeDecoded() throws UnsupportedEncodingException {
final String originalInput = "test input";
final String encodedString = Base64.getEncoder().encodeToString(originalInput.getBytes());
final byte[] decodedBytes = Base64.getDecoder().decode(encodedString);
final String decodedString = new String(decodedBytes);
assertNotNull(decodedString);
assertEquals(originalInput, decodedString);
}
@Test
public void whenStringIsEncodedWithoutPadding_thenOk() throws UnsupportedEncodingException {
final String originalInput = "test input";
final String encodedString = Base64.getEncoder().withoutPadding().encodeToString(originalInput.getBytes());
assertNotNull(encodedString);
assertNotEquals(originalInput, encodedString);
}
@Test
public void whenStringIsEncodedWithoutPadding_thenStringCanBeDecoded() throws UnsupportedEncodingException {
final String originalInput = "test input";
final String encodedString = Base64.getEncoder().withoutPadding().encodeToString(originalInput.getBytes());
final byte[] decodedBytes = Base64.getDecoder().decode(encodedString);
final String decodedString = new String(decodedBytes);
assertNotNull(decodedString);
assertEquals(originalInput, decodedString);
}
@Test
public void whenUrlIsEncoded_thenOk() throws UnsupportedEncodingException {
final String originalUrl = "https://www.google.co.nz/?gfe_rd=cr&ei=dzbFVf&gws_rd=ssl#q=java";
final String encodedUrl = Base64.getUrlEncoder().encodeToString(originalUrl.getBytes());
assertNotNull(encodedUrl);
assertNotEquals(originalUrl, encodedUrl);
}
@Test
public void whenUrlIsEncoded_thenURLCanBeDecoded() throws UnsupportedEncodingException {
final String originalUrl = "https://www.google.co.nz/?gfe_rd=cr&ei=dzbFVf&gws_rd=ssl#q=java";
final String encodedUrl = Base64.getUrlEncoder().encodeToString(originalUrl.getBytes());
final byte[] decodedBytes = Base64.getUrlDecoder().decode(encodedUrl.getBytes());
final String decodedUrl = new String(decodedBytes);
assertNotNull(decodedUrl);
assertEquals(originalUrl, decodedUrl);
}
@Test
public void whenMimeIsEncoded_thenOk() throws UnsupportedEncodingException {
final StringBuilder buffer = getMimeBuffer();
final byte[] forEncode = buffer.toString().getBytes();
final String encodedMime = Base64.getMimeEncoder().encodeToString(forEncode);
assertNotNull(encodedMime);
}
@Test
public void whenMimeIsEncoded_thenItCanBeDecoded() throws UnsupportedEncodingException {
final StringBuilder buffer = getMimeBuffer();
final byte[] forEncode = buffer.toString().getBytes();
final String encodedMime = Base64.getMimeEncoder().encodeToString(forEncode);
final byte[] decodedBytes = Base64.getMimeDecoder().decode(encodedMime);
final String decodedMime = new String(decodedBytes);
assertNotNull(decodedMime);
}
//
private static StringBuilder getMimeBuffer() {
final StringBuilder buffer = new StringBuilder();
for (int count = 0; count < 10; ++count) {
buffer.append(UUID.randomUUID().toString());
}
return buffer;
}
}

59
java-strings-2/src/test/java/com/baeldung/base64encodinganddecoding/StringToByteArrayUnitTest.java
View File

@@ -1,59 +0,0 @@
package com.baeldung.base64encodinganddecoding;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Base64;
import javax.xml.bind.DatatypeConverter;
import org.junit.Test;
public class StringToByteArrayUnitTest {
@Test
public void whenConvertStringToByteArrayUsingStringClass_thenOk() {
final String originalInput = "test input";
byte[] result = originalInput.getBytes();
System.out.println(Arrays.toString(result));
assertEquals(originalInput.length(), result.length);
}
@Test
public void givenCharset_whenConvertStringToByteArrayUsingStringClass_thenOk() throws UnsupportedEncodingException {
final String originalInput = "test input";
byte[] result = originalInput.getBytes(StandardCharsets.UTF_16);
System.out.println(Arrays.toString(result));
assertTrue(originalInput.length() < result.length);
}
@Test
public void whenConvertStringToByteArrayUsingBase64Decoder_thenOk() {
final String originalInput = "dGVzdCBpbnB1dA==";
byte[] result = Base64.getDecoder().decode(originalInput);
assertEquals("test input", new String(result));
}
@Test
public void whenConvertStringToByteArrayUsingDatatypeConverter_thenOk() {
final String originalInput = "dGVzdCBpbnB1dA==";
byte[] result = DatatypeConverter.parseBase64Binary(originalInput);
assertEquals("test input", new String(result));
}
@Test
public void whenConvertStringToByteArray_thenOk(){
String originalInput = "7465737420696E707574";
byte[] result = DatatypeConverter.parseHexBinary(originalInput);
System.out.println(Arrays.toString(result));
assertEquals("test input", new String(result));
}
}

58
java-strings-2/src/test/java/com/baeldung/initialization/StringInitializationUnitTest.java
View File

@@ -1,58 +0,0 @@
package com.baeldung.initialization;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.assertFalse;
import org.junit.Test;
public class StringInitializationUnitTest {
private String fieldString;
void printDeclaredOnlyString() {
String localVarString = null;
System.out.println(localVarString); // compilation error
System.out.println(fieldString);
}
@Test
public void givenDeclaredFeldStringAndNullString_thenCompareEquals() {
String localVarString = null;
assertEquals(fieldString, localVarString);
}
@Test
public void givenTwoStringsWithSameLiteral_thenCompareReferencesEquals() {
String literalOne = "Baeldung";
String literalTwo = "Baeldung";
assertTrue(literalOne == literalTwo);
}
@Test
public void givenTwoStringsUsingNew_thenCompareReferencesNotEquals() {
String newStringOne = new String("Baeldung");
String newStringTwo = new String("Baeldung");
assertFalse(newStringOne == newStringTwo);
}
@Test
public void givenEmptyLiteralStringsAndNewObject_thenCompareEquals() {
String emptyLiteral = "";
String emptyNewString = new String("");
assertEquals(emptyLiteral, emptyNewString);
}
@Test
public void givenEmptyStringObjects_thenCompareEquals() {
String emptyNewString = new String("");
String emptyNewStringTwo = new String();
assertEquals(emptyNewString, emptyNewStringTwo);
}
}

29
java-strings-2/src/test/java/com/baeldung/string/changecase/ToLowerCaseUnitTest.java
View File

@@ -1,29 +0,0 @@
package com.baeldung.string.changecase;
import static org.junit.Assert.assertEquals;
import java.util.Locale;
import org.junit.Test;
public class ToLowerCaseUnitTest {
private static final Locale TURKISH = new Locale("tr");
private String name = "John Doe";
private String foreignUppercase = "\u0049";
@Test
public void givenMixedCaseString_WhenToLowerCase_ThenResultIsLowerCase() {
assertEquals("john doe", name.toLowerCase());
}
@Test
public void givenForeignString_WhenToLowerCaseWithoutLocale_ThenResultIsLowerCase() {
assertEquals("\u0069", foreignUppercase.toLowerCase());
}
@Test
public void givenForeignString_WhenToLowerCaseWithLocale_ThenResultIsLowerCase() {
assertEquals("\u0131", foreignUppercase.toLowerCase(TURKISH));
}
}

29
java-strings-2/src/test/java/com/baeldung/string/changecase/ToUpperCaseUnitTest.java
View File

@@ -1,29 +0,0 @@
package com.baeldung.string.changecase;
import static org.junit.Assert.assertEquals;
import java.util.Locale;
import org.junit.Test;
public class ToUpperCaseUnitTest {
private static final Locale TURKISH = new Locale("tr");
private String name = "John Doe";
private String foreignLowercase = "\u0069";
@Test
public void givenMixedCaseString_WhenToUpperCase_ThenResultIsUpperCase() {
assertEquals("JOHN DOE", name.toUpperCase());
}
@Test
public void givenForeignString_WhenToUpperCaseWithoutLocale_ThenResultIsUpperCase() {
assertEquals("\u0049", foreignLowercase.toUpperCase());
}
@Test
public void givenForeignString_WhenToUpperCaseWithLocale_ThenResultIsUpperCase() {
assertEquals("\u0130", foreignLowercase.toUpperCase(TURKISH));
}
}

142
java-strings-2/src/test/java/com/baeldung/string/emptystrings/EmptyStringsUnitTest.java
View File

@@ -1,142 +0,0 @@
package com.baeldung.string.emptystrings;
import static org.hamcrest.Matchers.iterableWithSize;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import java.util.Set;
import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
import org.apache.commons.lang3.StringUtils;
import org.junit.Test;
import com.google.common.base.Strings;
public class EmptyStringsUnitTest {
private String emptyString = "";
private String blankString = " \n\t ";
private String nonEmptyString = " someString ";
/*
* EmptyStringCheck
*/
@Test
public void givenSomeEmptyString_thenEmptyStringCheckIsEmptyStringReturnsTrue() {
assertTrue(new EmptyStringCheck().isEmptyString(emptyString));
}
@Test
public void givenSomeNonEmptyString_thenEmptyStringCheckIsEmptyStringReturnsFalse() {
assertFalse(new EmptyStringCheck().isEmptyString(nonEmptyString));
}
@Test
public void givenSomeBlankString_thenEmptyStringCheckIsEmptyStringReturnsFalse() {
assertFalse(new EmptyStringCheck().isEmptyString(blankString));
}
/*
* Java5EmptyStringCheck
*/
@Test
public void givenSomeEmptyString_thenJava5EmptyStringCheckIsEmptyStringReturnsTrue() {
assertTrue(new Java5EmptyStringCheck().isEmptyString(emptyString));
}
@Test
public void givenSomeNonEmptyString_thenJava5EmptyStringCheckIsEmptyStringReturnsFalse() {
assertFalse(new Java5EmptyStringCheck().isEmptyString(nonEmptyString));
}
@Test
public void givenSomeBlankString_thenJava5EmptyStringCheckIsEmptyStringReturnsFalse() {
assertFalse(new Java5EmptyStringCheck().isEmptyString(blankString));
}
/*
* PlainJavaBlankStringCheck
*/
@Test
public void givenSomeEmptyString_thenPlainJavaBlankStringCheckIsBlankStringReturnsTrue() {
assertTrue(new PlainJavaBlankStringCheck().isBlankString(emptyString));
}
@Test
public void givenSomeNonEmptyString_thenPlainJavaBlankStringCheckIsBlankStringReturnsFalse() {
assertFalse(new PlainJavaBlankStringCheck().isBlankString(nonEmptyString));
}
@Test
public void givenSomeBlankString_thenPlainJavaBlankStringCheckIsBlankStringReturnsTrue() {
assertTrue(new PlainJavaBlankStringCheck().isBlankString(blankString));
}
/*
* Apache Commons Lang StringUtils
*/
@Test
public void givenSomeEmptyString_thenStringUtilsIsBlankReturnsTrue() {
assertTrue(StringUtils.isBlank(emptyString));
}
@Test
public void givenSomeNonEmptyString_thenStringUtilsIsBlankReturnsFalse() {
assertFalse(StringUtils.isBlank(nonEmptyString));
}
@Test
public void givenSomeBlankString_thenStringUtilsIsBlankReturnsTrue() {
assertTrue(StringUtils.isBlank(blankString));
}
/*
* Google Guava Strings
*/
@Test
public void givenSomeEmptyString_thenStringsIsNullOrEmptyStringReturnsTrue() {
assertTrue(Strings.isNullOrEmpty(emptyString));
}
@Test
public void givenSomeNonEmptyString_thenStringsIsNullOrEmptyStringReturnsFalse() {
assertFalse(Strings.isNullOrEmpty(nonEmptyString));
}
@Test
public void givenSomeBlankString_thenStringsIsNullOrEmptyStringReturnsFalse() {
assertFalse(Strings.isNullOrEmpty(blankString));
}
/*
* Bean Validation
*/
private ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
private Validator validator = factory.getValidator();
@Test
public void givenSomeEmptyString_thenBeanValidationReturnsViolations() {
SomeClassWithValidations someClassWithValidations = new SomeClassWithValidations().setSomeString(emptyString);
Set<ConstraintViolation<SomeClassWithValidations>> violations = validator.validate(someClassWithValidations);
assertThat(violations, iterableWithSize(1));
}
@Test
public void givenSomeNonEmptyString_thenBeanValidationValidatesWithoutViolations() {
SomeClassWithValidations someClassWithValidations = new SomeClassWithValidations().setSomeString(nonEmptyString);
Set<ConstraintViolation<SomeClassWithValidations>> violations = validator.validate(someClassWithValidations);
assertThat(violations, iterableWithSize(0));
}
@Test
public void givenSomeBlankString_thenBeanValidationReturnsViolations() {
SomeClassWithValidations someClassWithValidations = new SomeClassWithValidations().setSomeString(blankString);
Set<ConstraintViolation<SomeClassWithValidations>> violations = validator.validate(someClassWithValidations);
assertThat(violations, iterableWithSize(1));
}
}

70
java-strings-2/src/test/java/com/baeldung/string/search/SubstringSearchUnitTest.java
View File

@@ -1,70 +0,0 @@
package com.baeldung.string.search;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.lang3.StringUtils;
import org.junit.Assert;
import org.junit.Test;
/**
* BAEL-2832: Different ways to check if a Substring could be found in a String.
*/
public class SubstringSearchUnitTest {
@Test
public void searchSubstringWithIndexOf() {
Assert.assertEquals(9, "Bohemian Rhapsodyan".indexOf("Rhap"));
// indexOf will return -1, because it's case sensitive
Assert.assertEquals(-1, "Bohemian Rhapsodyan".indexOf("rhap"));
// indexOf will return 9, because it's all lowercase
Assert.assertEquals(9, "Bohemian Rhapsodyan".toLowerCase()
.indexOf("rhap"));
// it will return 6, because it's the first occurrence. Sorry Queen for being blasphemic
Assert.assertEquals(6, "Bohemian Rhapsodyan".indexOf("an"));
}
@Test
public void searchSubstringWithContains() {
Assert.assertTrue("Hey Ho, let's go".contains("Hey"));
// contains will return false, because it's case sensitive
Assert.assertFalse("Hey Ho, let's go".contains("hey"));
// contains will return true, because it's all lowercase
Assert.assertTrue("Hey Ho, let's go".toLowerCase().contains("hey"));
// contains will return false, because 'jey' can't be found
Assert.assertFalse("Hey Ho, let's go".contains("jey"));
}
@Test
public void searchSubstringWithStringUtils() {
Assert.assertTrue(StringUtils.containsIgnoreCase("Runaway train", "train"));
// it will also be true, because ignores case ;)
Assert.assertTrue(StringUtils.containsIgnoreCase("Runaway train", "Train"));
}
@Test
public void searchUsingPattern() {
// We create the Pattern first
Pattern pattern = Pattern.compile("(?<!\\S)" + "road" + "(?!\\S)");
// We need to create the Matcher after
Matcher matcher = pattern.matcher("Hit the road Jack");
// find will return true when the first match is found
Assert.assertTrue(matcher.find());
// We will create a different matcher with a different text
matcher = pattern.matcher("and don't you come back no more");
// find will return false, because 'road' can't be find as a substring
Assert.assertFalse(matcher.find());
}
}