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
core-java-modules/core-java-string-operations-2/src/main/java/com/baeldung/emptystrings/EmptyStringCheck.java Normal file
View File

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

8
core-java-modules/core-java-string-operations-2/src/main/java/com/baeldung/emptystrings/Java5EmptyStringCheck.java Normal file
View File

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

8
core-java-modules/core-java-string-operations-2/src/main/java/com/baeldung/emptystrings/PlainJavaBlankStringCheck.java Normal file
View File

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

14
core-java-modules/core-java-string-operations-2/src/main/java/com/baeldung/emptystrings/SomeClassWithValidations.java Normal file
View File

@@ -0,0 +1,14 @@
package com.baeldung.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;
}
}

29
core-java-modules/core-java-string-operations-2/src/test/java/com/baeldung/changecase/ToLowerCaseUnitTest.java Normal file
View File

@@ -0,0 +1,29 @@
package com.baeldung.changecase;
import org.junit.Test;
import java.util.Locale;
import static org.junit.Assert.assertEquals;
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
core-java-modules/core-java-string-operations-2/src/test/java/com/baeldung/changecase/ToUpperCaseUnitTest.java Normal file
View File

@@ -0,0 +1,29 @@
package com.baeldung.changecase;
import org.junit.Test;
import java.util.Locale;
import static org.junit.Assert.assertEquals;
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));
}
}

138
core-java-modules/core-java-string-operations-2/src/test/java/com/baeldung/emptystrings/EmptyStringsUnitTest.java Normal file
View File

@@ -0,0 +1,138 @@
package com.baeldung.emptystrings;
import com.google.common.base.Strings;
import org.apache.commons.lang3.StringUtils;
import org.junit.Test;
import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
import java.util.Set;
import static org.hamcrest.Matchers.iterableWithSize;
import static org.junit.Assert.*;
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));
}
}

26
core-java-modules/core-java-string-operations-2/src/test/java/com/baeldung/equalsIgnoreCase/StringEqualsIgnoreCaseUnitTest.java Normal file
View File

@@ -0,0 +1,26 @@
package com.baeldung.equalsIgnoreCase;
import org.apache.commons.lang3.StringUtils;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
public class StringEqualsIgnoreCaseUnitTest {
private String string1 = "equals ignore case";
private String string2 = "EQUALS IGNORE CASE";
@Test
public void givenEqualStringsWithDifferentCase_whenUsingEqualsIgnoreCase_ThenTheyAreEqual() {
assertThat(string1.equalsIgnoreCase(string2)).isTrue();
}
@Test
public void givenEqualStringsWithDifferentCase_whenUsingApacheCommonsEqualsIgnoreCase_ThenTheyAreEqual() {
assertThat(StringUtils.equalsIgnoreCase(string1, string2)).isTrue();
}
@Test
public void givenAStringAndNullValue_whenUsingApacheCommonsEqualsIgnoreCase_ThenTheyAreNotEqual() {
assertThat(StringUtils.equalsIgnoreCase(string1, null)).isFalse();
}
}

56
core-java-modules/core-java-string-operations-2/src/test/java/com/baeldung/initialization/StringInitializationUnitTest.java Normal file
View File

@@ -0,0 +1,56 @@
package com.baeldung.initialization;
import org.junit.Test;
import static org.junit.Assert.*;
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);
}
}

105
core-java-modules/core-java-string-operations-2/src/test/java/com/baeldung/stringconcatenation/StringConcatenationUnitTest.java Normal file
View File

@@ -0,0 +1,105 @@
package com.baeldung.stringconcatenation;
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);
}
}