更新 Java 字符串相关的内容和使用的版本

2022-05-26 15:28:21 -04:00 · 2022-05-26 15:28:21 -04:00 · ab380580e7
parent 31d47be06c
commit ab380580e7
40 changed files with 1112 additions and 0 deletions
--- a/core-java-modules/core-java-strings/README.md
+++ b/core-java-modules/core-java-strings/README.md
@ -0,0 +1,15 @@
+## Java Strings
+
+This module contains articles about strings in Java.
+
+### Relevant Articles:
+- [Use char[] Array over a String for Manipulating Passwords in Java?](https://www.baeldung.com/java-storing-passwords)
+- [Compact Strings in Java 9](https://www.baeldung.com/java-9-compact-string)
+- [String Not Empty Test Assertions in Java](https://www.baeldung.com/java-assert-string-not-empty)
+- [String Performance Hints](https://www.baeldung.com/java-string-performance)
+- [Java Localization – Formatting Messages](https://www.baeldung.com/java-localization-messages-formatting)
+- [Java – Generate Random String](https://www.baeldung.com/java-random-string)
+- [Java String Interview Questions and Answers](https://www.baeldung.com/java-string-interview-questions)
+- [Java Multi-line String](https://www.baeldung.com/java-multiline-string)
+- [Guide to Java String Pool](https://www.baeldung.com/java-string-pool)
+- [Fixing “constant string too long” Build Error](https://www.baeldung.com/java-constant-string-too-long-error)
--- a/core-java-modules/core-java-strings/src/main/java/com/baeldung/java9/compactstring/CompactStringDemo.java
+++ b/core-java-modules/core-java-strings/src/main/java/com/baeldung/java9/compactstring/CompactStringDemo.java
@ -0,0 +1,25 @@
+package com.baeldung.java9.compactstring;
+
+import java.util.List;
+import java.util.stream.IntStream;
+
+import static java.util.stream.Collectors.toList;
+
+public class CompactStringDemo {
+
+    public static void main(String[] args) {
+        long startTime = System.currentTimeMillis();
+        List strings = IntStream.rangeClosed(1, 10_000_000)
+          .mapToObj(Integer::toString).collect(toList());
+        long totalTime = System.currentTimeMillis() - startTime;
+        System.out.println("Generated " + strings.size() + " strings in "
+          + totalTime + " ms.");
+
+        startTime = System.currentTimeMillis();
+        String appended = (String) strings.stream().limit(100_000)
+          .reduce("", (left, right) -> left.toString() + right.toString());
+        totalTime = System.currentTimeMillis() - startTime;
+        System.out.println("Created string of length " + appended.length()
+          + " in " + totalTime + " ms.");
+    }
+}
--- a/core-java-modules/core-java-strings/src/main/java/com/baeldung/localization/App.java
+++ b/core-java-modules/core-java-strings/src/main/java/com/baeldung/localization/App.java
@ -0,0 +1,21 @@
+package com.baeldung.localization;
+
+import java.text.ParseException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Locale;
+
+public class App {
+
+    /**
+     * Runs all available formatter
+     * @throws ParseException 
+     */
+    public static void main(String[] args) {
+        List<Locale> locales = Arrays.asList(new Locale[] { Locale.UK, Locale.ITALY, Locale.FRANCE, Locale.forLanguageTag("pl-PL") });
+        Localization.run(locales);
+        JavaSEFormat.run(locales);
+        ICUFormat.run(locales);
+    }
+
+}
--- a/core-java-modules/core-java-strings/src/main/java/com/baeldung/localization/ICUFormat.java
+++ b/core-java-modules/core-java-strings/src/main/java/com/baeldung/localization/ICUFormat.java
@ -0,0 +1,29 @@
+package com.baeldung.localization;
+
+import com.ibm.icu.text.MessageFormat;
+
+import java.util.List;
+import java.util.Locale;
+import java.util.ResourceBundle;
+
+public class ICUFormat {
+
+    public static String getLabel(Locale locale, Object[] data) {
+        ResourceBundle bundle = ResourceBundle.getBundle("formats", locale);
+        String format = bundle.getString("label-icu");
+        MessageFormat formatter = new MessageFormat(format, locale);
+        return formatter.format(data);
+    }
+
+    public static void run(List<Locale> locales) {
+        System.out.println("ICU formatter");
+        locales.forEach(locale -> System.out.println(getLabel(locale, new Object[] { "Alice", "female", 0 })));
+        locales.forEach(locale -> System.out.println(getLabel(locale, new Object[] { "Alice", "female", 1 })));
+        locales.forEach(locale -> System.out.println(getLabel(locale, new Object[] { "Alice", "female", 2 })));
+        locales.forEach(locale -> System.out.println(getLabel(locale, new Object[] { "Alice", "female", 3 })));
+        locales.forEach(locale -> System.out.println(getLabel(locale, new Object[] { "Bob", "male", 0 })));
+        locales.forEach(locale -> System.out.println(getLabel(locale, new Object[] { "Bob", "male", 1 })));
+        locales.forEach(locale -> System.out.println(getLabel(locale, new Object[] { "Bob", "male", 2 })));
+        locales.forEach(locale -> System.out.println(getLabel(locale, new Object[] { "Bob", "male", 3 })));
+    }
+}
--- a/core-java-modules/core-java-strings/src/main/java/com/baeldung/localization/JavaSEFormat.java
+++ b/core-java-modules/core-java-strings/src/main/java/com/baeldung/localization/JavaSEFormat.java
@ -0,0 +1,24 @@
+package com.baeldung.localization;
+
+import java.text.MessageFormat;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+import java.util.ResourceBundle;
+
+public class JavaSEFormat {
+
+    public static String getLabel(Locale locale, Object[] data) {
+        ResourceBundle bundle = ResourceBundle.getBundle("formats", locale);
+        final String pattern = bundle.getString("label");
+        final MessageFormat formatter = new MessageFormat(pattern, locale);
+        return formatter.format(data);
+    }
+
+    public static void run(List<Locale> locales) {
+        System.out.println("Java formatter");
+        final Date date = new Date(System.currentTimeMillis());
+        locales.forEach(locale -> System.out.println(getLabel(locale, new Object[] { date, "Alice", 0 })));
+        locales.forEach(locale -> System.out.println(getLabel(locale, new Object[] { date, "Alice", 2 })));
+    }
+}
--- a/core-java-modules/core-java-strings/src/main/java/com/baeldung/localization/Localization.java
+++ b/core-java-modules/core-java-strings/src/main/java/com/baeldung/localization/Localization.java
@ -0,0 +1,18 @@
+package com.baeldung.localization;
+
+import java.util.List;
+import java.util.Locale;
+import java.util.ResourceBundle;
+
+public class Localization {
+
+    public static String getLabel(Locale locale) {
+        final ResourceBundle bundle = ResourceBundle.getBundle("messages", locale);
+        return bundle.getString("label");
+    }
+
+    public static void run(List<Locale> locales) {
+        locales.forEach(locale -> System.out.println(getLabel(locale)));
+    }
+
+}
--- a/core-java-modules/core-java-strings/src/main/java/com/baeldung/multiline/MultiLineString.java
+++ b/core-java-modules/core-java-strings/src/main/java/com/baeldung/multiline/MultiLineString.java
@ -0,0 +1,77 @@
+package com.baeldung.multiline;
+
+import com.google.common.base.Joiner;
+import com.google.common.collect.ImmutableList;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+public class MultiLineString {
+
+    String newLine = System.getProperty("line.separator");
+
+    public String stringConcatenation() {
+        return "Get busy living"
+                .concat(newLine)
+                .concat("or")
+                .concat(newLine)
+                .concat("get busy dying.")
+                .concat(newLine)
+                .concat("--Stephen King");
+    }
+
+    public String stringJoin() {
+        return String.join(newLine,
+                           "Get busy living",
+                           "or",
+                           "get busy dying.",
+                           "--Stephen King");
+    }
+
+    public String stringBuilder() {
+        return new StringBuilder()
+                .append("Get busy living")
+                .append(newLine)
+                .append("or")
+                .append(newLine)
+                .append("get busy dying.")
+                .append(newLine)
+                .append("--Stephen King")
+                .toString();
+    }
+
+    public String stringWriter() {
+        StringWriter stringWriter = new StringWriter();
+        PrintWriter printWriter = new PrintWriter(stringWriter);
+        printWriter.println("Get busy living");
+        printWriter.println("or");
+        printWriter.println("get busy dying.");
+        printWriter.println("--Stephen King");
+        return stringWriter.toString();
+    }
+
+    public String guavaJoiner() {
+        return Joiner.on(newLine).join(ImmutableList.of("Get busy living",
+            "or",
+            "get busy dying.",
+            "--Stephen King"));
+    }
+
+    public String loadFromFile() throws IOException {
+        return new String(Files.readAllBytes(Paths.get("src/main/resources/stephenking.txt")));
+    }
+
+
+//    public String textBlocks() {
+//
+//        // THIS ONLY FOR JDK 15
+//        return """
+//            Get busy living
+//            or
+//            get busy dying.
+//            --Stephen King""";
+//    }
+}
--- a/core-java-modules/core-java-strings/src/main/java/com/baeldung/stringperformance/StringPerformance.java
+++ b/core-java-modules/core-java-strings/src/main/java/com/baeldung/stringperformance/StringPerformance.java
@ -0,0 +1,198 @@
+package com.baeldung.stringperformance;
+
+import com.google.common.base.Splitter;
+import org.apache.commons.lang3.StringUtils;
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.StringTokenizer;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Pattern;
+
+@BenchmarkMode(Mode.SingleShotTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@Measurement(batchSize = 100000, iterations = 10)
+@Warmup(batchSize = 100000, iterations = 10)
+@State(Scope.Thread)
+public class StringPerformance {
+
+    protected String baeldung = "baeldung";
+    protected String longString = "Hello baeldung, I am a bit longer than other Strings";
+    protected String formatString = "hello %s, nice to meet you";
+    protected String formatDigit = "%d";
+    protected String emptyString = " ";
+    protected String result = "";
+
+    protected int sampleNumber = 100;
+
+    protected Pattern spacePattern = Pattern.compile(emptyString);
+    protected Pattern longPattern = Pattern.compile(longString);
+    protected List<String> stringSplit = new ArrayList<>();
+    protected List<String> stringTokenizer = new ArrayList<>();
+
+    @Benchmark
+    public String benchmarkStringDynamicConcat() {
+        result += baeldung;
+        return result;
+    }
+
+    @Benchmark
+    public StringBuilder  benchmarkStringBuilder() {
+        StringBuilder stringBuilder = new StringBuilder(result);
+        stringBuilder.append(baeldung);
+        return stringBuilder;
+    }
+
+    @Benchmark
+    public StringBuffer benchmarkStringBuffer() {
+        StringBuffer stringBuffer = new StringBuffer(result);
+        stringBuffer.append(baeldung);
+        return stringBuffer;
+    }
+
+    @Benchmark
+    public String benchmarkStringConstructor() {
+        String result = new String("baeldung");
+        return result;
+    }
+
+    @Benchmark
+    public String benchmarkStringLiteral() {
+        String result = "baeldung";
+        return result;
+    }
+
+    @Benchmark
+    public String benchmarkStringFormat_s() {
+        return String.format(formatString, baeldung);
+    }
+
+    @Benchmark
+    public String benchmarkStringConcat() {
+        result = result.concat(baeldung);
+        return result;
+    }
+
+    @Benchmark
+    public String benchmarkStringIntern() {
+        return baeldung.intern();
+    }
+
+    @Benchmark
+    public String benchmarkStringReplace() {
+        return longString.replace("average", " average !!!");
+    }
+
+    @Benchmark
+    public String benchmarkStringUtilsReplace() {
+        return StringUtils.replace(longString, "average", " average !!!");
+    }
+
+    @Benchmark
+    public List<String> benchmarkGuavaSplitter() {
+        return Splitter.on(" ").trimResults()
+                .omitEmptyStrings()
+                .splitToList(longString);
+    }
+
+    @Benchmark
+    public String [] benchmarkStringSplit() {
+        return longString.split(emptyString);
+    }
+
+    @Benchmark
+    public String [] benchmarkStringSplitPattern() {
+        return spacePattern.split(longString, 0);
+    }
+
+    @Benchmark
+    public List benchmarkStringTokenizer() {
+        StringTokenizer st = new StringTokenizer(longString);
+        while (st.hasMoreTokens()) {
+            stringTokenizer.add(st.nextToken());
+        }
+        return stringTokenizer;
+    }
+
+    @Benchmark
+    public List benchmarkStringIndexOf() {
+        int pos = 0, end;
+        while ((end = longString.indexOf(' ', pos)) >= 0) {
+            stringSplit.add(longString.substring(pos, end));
+            pos = end + 1;
+        }
+        //Add last token of string
+        stringSplit.add(longString.substring(pos));
+        return stringSplit;
+    }
+
+    @Benchmark
+    public String benchmarkIntegerToString() {
+        return Integer.toString(sampleNumber);
+    }
+
+    @Benchmark
+    public String benchmarkStringValueOf() {
+        return String.valueOf(sampleNumber);
+    }
+
+
+    @Benchmark
+    public String benchmarkStringConvertPlus() {
+        return sampleNumber + "";
+    }
+
+        @Benchmark
+    public String benchmarkStringFormat_d() {
+        return String.format(formatDigit, sampleNumber);
+    }
+
+    @Benchmark
+    public boolean benchmarkStringEquals() {
+        return longString.equals(baeldung);
+    }
+
+
+    @Benchmark
+    public boolean benchmarkStringEqualsIgnoreCase() {
+        return longString.equalsIgnoreCase(baeldung);
+    }
+
+    @Benchmark
+    public boolean benchmarkStringMatches() {
+        return longString.matches(baeldung);
+    }
+
+    @Benchmark
+    public boolean benchmarkPrecompiledMatches() {
+        return longPattern.matcher(baeldung).matches();
+    }
+
+    @Benchmark
+    public int benchmarkStringCompareTo() {
+        return longString.compareTo(baeldung);
+    }
+
+    @Benchmark
+    public boolean benchmarkStringIsEmpty() {
+        return longString.isEmpty();
+    }
+
+    @Benchmark
+    public boolean benchmarkStringLengthZero() {
+        return longString.length() == 0;
+    }
+
+    public static void main(String[] args) throws Exception {
+        Options options = new OptionsBuilder()
+                .include(StringPerformance.class.getSimpleName()).threads(1)
+                .forks(1).shouldFailOnError(true)
+                .shouldDoGC(true)
+                .jvmArgs("-server").build();
+        new Runner(options).run();
+    }
+}
--- a/core-java-modules/core-java-strings/src/main/resources/config.properties
+++ b/core-java-modules/core-java-strings/src/main/resources/config.properties
--- a/core-java-modules/core-java-strings/src/main/resources/formats_en.properties
+++ b/core-java-modules/core-java-strings/src/main/resources/formats_en.properties
@ -0,0 +1,2 @@
+label=On {0, date, short} {1} has sent you {2, choice, 0#no messages|1#a message|2#two messages|2<{2,number,integer} messages}.
+label-icu={0} has sent you {2, plural, =0 {no messages} =1 {a message} other {{2, number, integer} messages}}.
--- a/core-java-modules/core-java-strings/src/main/resources/formats_fr.properties
+++ b/core-java-modules/core-java-strings/src/main/resources/formats_fr.properties
@ -0,0 +1,2 @@
+label={0, date, short}, {1}{2, choice, 0# ne|0<} vous a envoy\u00e9 {2, choice, 0#aucun message|1#un message|2#deux messages|2<{2,number,integer} messages}.
+label-icu={0} {2, plural, =0 {ne } other {}}vous a envoy\u00e9 {2, plural, =0 {aucun message} =1 {un message} other {{2, number, integer} messages}}.
--- a/core-java-modules/core-java-strings/src/main/resources/formats_it.properties
+++ b/core-java-modules/core-java-strings/src/main/resources/formats_it.properties
@ -0,0 +1,2 @@
+label={0, date, short} {1} ti ha inviato {2, choice, 0#nessun messagio|1#un messaggio|2#due messaggi|2<{2, number, integer} messaggi}.
+label-icu={0} {2, plural, =0 {non } other {}}ti ha inviato {2, plural, =0 {nessun messaggio} =1 {un messaggio} other {{2, number, integer} messaggi}}.
--- a/core-java-modules/core-java-strings/src/main/resources/formats_pl.properties
+++ b/core-java-modules/core-java-strings/src/main/resources/formats_pl.properties
@ -0,0 +1,2 @@
+label=W {0, date, short} {1}{2, choice, 0# nie|0<} wys\u0142a\u0142a ci {2, choice, 0#\u017Cadnych wiadomo\u015Bci|1#wiadomo\u015B\u0107|2#dwie wiadomo\u015Bci|2<{2, number, integer} wiadomo\u015Bci}.
+label-icu={0} {2, plural, =0 {nie } other {}}{1, select, male {wys\u0142a\u0142} female {wys\u0142a\u0142a} other {wys\u0142a\u0142o}} ci {2, plural, =0 {\u017Cadnej wiadomo\u015Bci} =1 {wiadomo\u015B\u0107} other {{2, number, integer} wiadomo\u015Bci}}.
--- a/core-java-modules/core-java-strings/src/main/resources/logback.xml
+++ b/core-java-modules/core-java-strings/src/main/resources/logback.xml
@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>
--- a/core-java-modules/core-java-strings/src/main/resources/messages_en.properties
+++ b/core-java-modules/core-java-strings/src/main/resources/messages_en.properties
@ -0,0 +1 @@
+label=Alice has sent you a message.
--- a/core-java-modules/core-java-strings/src/main/resources/messages_fr.properties
+++ b/core-java-modules/core-java-strings/src/main/resources/messages_fr.properties
@ -0,0 +1 @@
+label=Alice vous a envoy\u00e9 un message.
--- a/core-java-modules/core-java-strings/src/main/resources/messages_it.properties
+++ b/core-java-modules/core-java-strings/src/main/resources/messages_it.properties
@ -0,0 +1 @@
+label=Alice ti ha inviato un messaggio.
--- a/core-java-modules/core-java-strings/src/main/resources/messages_pl.properties
+++ b/core-java-modules/core-java-strings/src/main/resources/messages_pl.properties
@ -0,0 +1 @@
+label=Alice wys\u0142a\u0142a ci wiadomo\u015B\u0107.
--- a/core-java-modules/core-java-strings/src/main/resources/stephenking.txt
+++ b/core-java-modules/core-java-strings/src/main/resources/stephenking.txt
@ -0,0 +1,4 @@
+Get busy living
+or
+get busy dying.
+--Stephen King
--- a/core-java-modules/core-java-strings/src/test/java/com/baeldung/chararraypassword/PasswordStoreExamplesUnitTest.java
+++ b/core-java-modules/core-java-strings/src/test/java/com/baeldung/chararraypassword/PasswordStoreExamplesUnitTest.java
@ -0,0 +1,70 @@
+package com.baeldung.chararraypassword;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class PasswordStoreExamplesUnitTest {
+
+	String stringPassword = "password";
+	char[] charPassword = new char[]{'p', 'a', 's', 's', 'w', 'o', 'r', 'd'};
+
+	@Test
+	public void givenStringHashCode_WhenStringValueChanged_ThenHashCodesNotEqualAndValesNotEqual() {
+		String originalHashCode = Integer.toHexString(stringPassword.hashCode());
+
+		stringPassword = "********";
+		String changedHashCode = Integer.toHexString(stringPassword.hashCode());
+
+		assertThat(originalHashCode).isNotEqualTo(changedHashCode);
+		assertThat(stringPassword).isNotEqualTo("password");
+	}
+
+	@Test
+	public void givenStringHashCode_WhenStringValueChangedAndStringValueReassigned_ThenHashCodesEqualAndValesEqual() {
+		String originalHashCode = Integer.toHexString(stringPassword.hashCode());
+
+		stringPassword = "********";
+		stringPassword = "password";
+		String reassignedHashCode = Integer.toHexString(stringPassword.hashCode());
+
+		assertThat(originalHashCode).isEqualTo(reassignedHashCode);
+		assertThat(stringPassword).isEqualTo("password");
+	}
+
+	@Test
+	public void givenStringHashCode_WhenStringValueReplaced_ThenHashCodesEqualAndValesEqual() {
+		String originalHashCode = Integer.toHexString(stringPassword.hashCode());
+
+		String newString = "********";
+		stringPassword.replace(stringPassword, newString);
+
+		String hashCodeAfterReplace = Integer.toHexString(stringPassword.hashCode());
+
+		assertThat(originalHashCode).isEqualTo(hashCodeAfterReplace);
+		assertThat(stringPassword).isEqualTo("password");
+	}
+
+	@Test
+	public void givenCharArrayHashCode_WhenArrayElementsValueChanged_ThenHashCodesEqualAndValesNotEqual() {
+		String originalHashCode = Integer.toHexString(charPassword.hashCode());
+
+		Arrays.fill(charPassword, '*');
+		String changedHashCode = Integer.toHexString(charPassword.hashCode());
+
+		assertThat(originalHashCode).isEqualTo(changedHashCode);
+		assertThat(charPassword).isNotEqualTo(new char[]{'p', 'a', 's', 's', 'w', 'o', 'r', 'd'});
+	}
+
+	@Test
+	public void whenCallingToStringOfString_ThenValuesEqual() {
+		assertThat(stringPassword.toString()).isEqualTo("password");
+	}
+
+	@Test
+	public void whenCallingToStringOfCharArray_ThenValuesNotEqual() {
+		assertThat(charPassword.toString()).isNotEqualTo("password");
+	}
+}
--- a/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/LocaleUnitTest.java
+++ b/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/LocaleUnitTest.java
@ -0,0 +1,20 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import java.math.BigDecimal;
+import java.text.NumberFormat;
+import java.util.Locale;
+
+import static org.junit.Assert.assertEquals;
+
+public class LocaleUnitTest {
+    @Test
+    public void whenUsingLocal_thenCorrectResultsForDifferentLocale() {
+        Locale usLocale = Locale.US;
+        BigDecimal number = new BigDecimal(102_300.456d);
+         
+        NumberFormat usNumberFormat = NumberFormat.getCurrencyInstance(usLocale); 
+        assertEquals(usNumberFormat.format(number), "$102,300.46");
+    }
+}
--- a/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringAnagramUnitTest.java
+++ b/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringAnagramUnitTest.java
@ -0,0 +1,29 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class StringAnagramUnitTest {
+    public boolean isAnagram(String s1, String s2) {
+        if(s1.length() != s2.length())
+            return false;
+            
+        char[] arr1 = s1.toCharArray();
+        char[] arr2 = s2.toCharArray();
+        
+        Arrays.sort(arr1);
+        Arrays.sort(arr2);
+        
+        return Arrays.equals(arr1, arr2);
+    }
+    
+    @Test
+    public void whenTestAnagrams_thenTestingCorrectly() {
+        assertThat(isAnagram("car", "arc")).isTrue();
+        assertThat(isAnagram("west", "stew")).isTrue();
+        assertThat(isAnagram("west", "east")).isFalse();
+    }
+}
--- a/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringChangeCaseUnitTest.java
+++ b/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringChangeCaseUnitTest.java
@ -0,0 +1,20 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class StringChangeCaseUnitTest {
+    @Test
+    public void givenString_whenChangingToUppercase_thenCaseChanged() {
+        String s = "Welcome to Baeldung!";
+        assertEquals("WELCOME TO BAELDUNG!", s.toUpperCase());
+    }
+    
+
+    @Test
+    public void givenString_whenChangingToLowerrcase_thenCaseChanged() {
+        String s = "Welcome to Baeldung!";
+        assertEquals("welcome to baeldung!", s.toLowerCase());
+    }
+}
--- a/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringCountOccurrencesUnitTest.java
+++ b/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringCountOccurrencesUnitTest.java
@ -0,0 +1,28 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class StringCountOccurrencesUnitTest {
+    public int countOccurrences(String s, char c) {
+        int count = 0;
+        for (int i = 0; i < s.length(); i++) {
+            if (s.charAt(i) == c) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    @Test
+    public void givenString_whenCountingFrequencyOfChar_thenCountCorrect() {
+        assertEquals(3, countOccurrences("united states", 't'));
+    }
+
+    public void givenString_whenUsingJava8_thenCountingOfCharCorrect() {
+        String str = "united states";
+        long count = str.chars().filter(ch -> (char)ch == 't').count();
+        assertEquals(3, count);
+    }
+}
--- a/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringFormatUnitTest.java
+++ b/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringFormatUnitTest.java
@ -0,0 +1,14 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class StringFormatUnitTest {
+    @Test
+    public void givenString_whenUsingStringFormat_thenStringFormatted() {
+        String title = "Baeldung"; 
+        String formatted = String.format("Title is %s", title);
+        assertEquals(formatted, "Title is Baeldung");
+    }
+}
--- a/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringInternUnitTest.java
+++ b/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringInternUnitTest.java
@ -0,0 +1,17 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class StringInternUnitTest {
+    @Test
+    public void whenCallingStringIntern_thenStringsInterned() {
+        String s1 = "Baeldung";
+        String s2 = new String("Baeldung");
+        String s3 = new String("Baeldung").intern();
+         
+        assertThat(s1 == s2).isFalse();
+        assertThat(s1 == s3).isTrue();
+    }
+}
--- a/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringJoinerUnitTest.java
+++ b/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringJoinerUnitTest.java
@ -0,0 +1,19 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import java.util.StringJoiner;
+
+import static org.junit.Assert.assertEquals;
+
+public class StringJoinerUnitTest {
+    @Test
+    public void whenUsingStringJoiner_thenStringsJoined() {
+        StringJoiner joiner = new StringJoiner(",", "[", "]");
+        joiner.add("Red")
+          .add("Green")
+          .add("Blue");
+         
+        assertEquals(joiner.toString(), "[Red,Green,Blue]");
+    }
+}
--- a/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringPalindromeUnitTest.java
+++ b/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringPalindromeUnitTest.java
@ -0,0 +1,29 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class StringPalindromeUnitTest {
+    
+    public boolean isPalindrome(String text) {
+        int forward = 0;
+        int backward = text.length() - 1;
+        while (backward > forward) {
+            char forwardChar = text.charAt(forward++);
+            char backwardChar = text.charAt(backward--);
+            if (forwardChar != backwardChar)
+                return false;
+        }
+        return true;
+    }
+    
+    @Test
+    public void givenIsPalindromeMethod_whenCheckingString_thenFindIfPalindrome() {
+        assertThat(isPalindrome("madam")).isTrue();
+        assertThat(isPalindrome("radar")).isTrue();
+        assertThat(isPalindrome("level")).isTrue();
+
+        assertThat(isPalindrome("baeldung")).isFalse();
+    }
+}
--- a/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringReverseUnitTest.java
+++ b/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringReverseUnitTest.java
@ -0,0 +1,13 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class StringReverseUnitTest {
+    @Test
+    public void whenUsingInbuildMethods_thenStringReversed() {
+        String reversed = new StringBuilder("baeldung").reverse().toString();
+        assertEquals("gnudleab", reversed);
+    }
+}
--- a/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringSplitUnitTest.java
+++ b/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringSplitUnitTest.java
@ -0,0 +1,33 @@
+package com.baeldung.interview;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+
+public class StringSplitUnitTest {
+    @Test
+    public void givenCoreJava_whenSplittingStrings_thenSplitted() {
+        String expected[] = {
+          "john",
+          "peter",
+          "mary"
+        };
+        
+        String[] splitted = "john,peter,mary".split(",");
+        assertArrayEquals( expected, splitted );
+    }
+    
+    @Test
+    public void givenApacheCommons_whenSplittingStrings_thenSplitted() {
+        String expected[] = {
+          "john",
+          "peter",
+          "mary"
+        };
+        String[] splitted = StringUtils.split("john peter mary");
+        assertArrayEquals( expected, splitted );
+    }
+    
+    
+}
--- a/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringToByteArrayUnitTest.java
+++ b/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringToByteArrayUnitTest.java
@ -0,0 +1,24 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.StandardCharsets;
+
+import static org.junit.Assert.assertArrayEquals;
+
+public class StringToByteArrayUnitTest {
+    @Test
+    public void whenGetBytes_thenCorrect() throws UnsupportedEncodingException {
+        byte[] byteArray1 = "abcd".getBytes();
+        byte[] byteArray2 = "efgh".getBytes(StandardCharsets.US_ASCII);
+        byte[] byteArray3 = "ijkl".getBytes("UTF-8");
+        byte[] expected1 = new byte[] { 97, 98, 99, 100 };
+        byte[] expected2 = new byte[] { 101, 102, 103, 104 };
+        byte[] expected3 = new byte[] { 105, 106, 107, 108 };
+         
+        assertArrayEquals(expected1, byteArray1);
+        assertArrayEquals(expected2, byteArray2);
+        assertArrayEquals(expected3, byteArray3);
+    }
+}
--- a/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringToCharArrayUnitTest.java
+++ b/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringToCharArrayUnitTest.java
@ -0,0 +1,17 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.assertEquals;
+
+public class StringToCharArrayUnitTest {
+    @Test
+    public void whenConvertingStringToCharArray_thenConversionSuccessful() {
+        String beforeConvStr = "hello";
+        char[] afterConvCharArr = { 'h', 'e', 'l', 'l', 'o' };
+      
+        assertEquals(Arrays.equals(beforeConvStr.toCharArray(), afterConvCharArr), true);
+    }
+}
--- a/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringToIntegerUnitTest.java
+++ b/core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringToIntegerUnitTest.java
@ -0,0 +1,16 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class StringToIntegerUnitTest {
+    @Test
+    public void givenString_whenParsingInt_shouldConvertToInt() {
+        String givenString = "42";
+
+        int result = Integer.parseInt(givenString);
+
+        assertThat(result).isEqualTo(42);
+    }
+}
--- a/core-java-modules/core-java-strings/src/test/java/com/baeldung/localization/ICUFormatUnitTest.java
+++ b/core-java-modules/core-java-strings/src/test/java/com/baeldung/localization/ICUFormatUnitTest.java
@ -0,0 +1,72 @@
+package com.baeldung.localization;
+
+import org.junit.Test;
+
+import java.util.Locale;
+
+import static org.junit.Assert.assertEquals;
+
+public class ICUFormatUnitTest {
+
+    @Test
+    public void givenInUK_whenAliceSendsNothing_thenCorrectMessage() {
+        assertEquals("Alice has sent you no messages.", ICUFormat.getLabel(Locale.UK, new Object[] { "Alice", "female", 0 }));
+    }
+
+    @Test
+    public void givenInUK_whenAliceSendsOneMessage_thenCorrectMessage() {
+        assertEquals("Alice has sent you a message.", ICUFormat.getLabel(Locale.UK, new Object[] { "Alice", "female", 1 }));
+    }
+
+    @Test
+    public void givenInUK_whenBobSendsSixMessages_thenCorrectMessage() {
+        assertEquals("Bob has sent you 6 messages.", ICUFormat.getLabel(Locale.UK, new Object[] { "Bob", "male", 6 }));
+    }
+
+    @Test
+    public void givenInItaly_whenAliceSendsNothing_thenCorrectMessage() {
+        assertEquals("Alice non ti ha inviato nessun messaggio.", ICUFormat.getLabel(Locale.ITALY, new Object[] { "Alice", "female", 0 }));
+    }
+
+    @Test
+    public void givenInItaly_whenAliceSendsOneMessage_thenCorrectMessage() {
+        assertEquals("Alice ti ha inviato un messaggio.", ICUFormat.getLabel(Locale.ITALY, new Object[] { "Alice", "female", 1 }));
+    }
+
+    @Test
+    public void givenInItaly_whenBobSendsSixMessages_thenCorrectMessage() {
+        assertEquals("Bob ti ha inviato 6 messaggi.", ICUFormat.getLabel(Locale.ITALY, new Object[] { "Bob", "male", 6 }));
+    }
+
+    @Test
+    public void givenInFrance_whenAliceSendsNothing_thenCorrectMessage() {
+        assertEquals("Alice ne vous a envoyé aucun message.", ICUFormat.getLabel(Locale.FRANCE, new Object[] { "Alice", "female", 0 }));
+    }
+    
+    @Test
+    public void givenInFrance_whenAliceSendsOneMessage_thenCorrectMessage() {
+        assertEquals("Alice vous a envoyé un message.", ICUFormat.getLabel(Locale.FRANCE, new Object[] { "Alice", "female", 1 }));
+    }
+
+    @Test
+    public void givenInFrance_whenBobSendsSixMessages_thenCorrectMessage() {
+        assertEquals("Bob vous a envoyé 6 messages.", ICUFormat.getLabel(Locale.FRANCE, new Object[] { "Bob", "male", 6 }));
+    }
+
+
+    @Test
+    public void givenInPoland_whenAliceSendsNothing_thenCorrectMessage() {
+        assertEquals("Alice nie wysłała ci żadnej wiadomości.", ICUFormat.getLabel(Locale.forLanguageTag("pl-PL"), new Object[] { "Alice", "female", 0 }));
+    }
+    
+    @Test
+    public void givenInPoland_whenAliceSendsOneMessage_thenCorrectMessage() {
+        assertEquals("Alice wysłała ci wiadomość.", ICUFormat.getLabel(Locale.forLanguageTag("pl-PL"), new Object[] { "Alice", "female", 1 }));
+    }
+    
+    @Test
+    public void givenInPoland_whenBobSendsSixMessages_thenCorrectMessage() {
+        assertEquals("Bob wysłał ci 6 wiadomości.", ICUFormat.getLabel(Locale.forLanguageTag("pl-PL"), new Object[] { "Bob", "male", 6 }));
+    }
+
+}
--- a/core-java-modules/core-java-strings/src/test/java/com/baeldung/multiline/MultiLineStringUnitTest.java
+++ b/core-java-modules/core-java-strings/src/test/java/com/baeldung/multiline/MultiLineStringUnitTest.java
@ -0,0 +1,22 @@
+package com.baeldung.multiline;
+
+import org.junit.Test;
+
+import java.io.IOException;
+
+import static org.junit.Assert.assertEquals;
+
+public class MultiLineStringUnitTest {
+
+    
+    @Test
+    public void whenCompareMultiLineStrings_thenTheyAreAllTheSame() throws IOException {
+        MultiLineString ms = new MultiLineString();
+        assertEquals(ms.stringConcatenation(), ms.stringJoin());
+        assertEquals(ms.stringJoin(), ms.stringBuilder());
+        assertEquals(ms.stringBuilder(), ms.guavaJoiner());
+        assertEquals(ms.guavaJoiner(), ms.loadFromFile());
+//        assertEquals(ms.loadFromFile(), ms.textBlocks());
+    }
+    
+}
--- a/core-java-modules/core-java-strings/src/test/java/com/baeldung/randomstrings/RandomStringsUnitTest.java
+++ b/core-java-modules/core-java-strings/src/test/java/com/baeldung/randomstrings/RandomStringsUnitTest.java
@ -0,0 +1,103 @@
+package com.baeldung.randomstrings;
+
+import org.apache.commons.lang3.RandomStringUtils;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.charset.Charset;
+import java.util.Random;
+
+public class RandomStringsUnitTest {
+
+    private static final Logger LOG = LoggerFactory.getLogger(RandomStringsUnitTest.class);
+
+    @Test
+    public void givenUsingPlainJava_whenGeneratingRandomStringUnbounded_thenCorrect() {
+        byte[] array = new byte[7]; // length is bounded by 7
+        new Random().nextBytes(array);
+        String generatedString = new String(array, Charset.forName("UTF-8"));
+
+        LOG.debug(generatedString);
+    }
+
+    @Test
+    public void givenUsingPlainJava_whenGeneratingRandomStringBounded_thenCorrect() {
+        int leftLimit = 97; // letter 'a'
+        int rightLimit = 122; // letter 'z'
+        int targetStringLength = 10;
+        Random random = new Random();
+        StringBuilder buffer = new StringBuilder(targetStringLength);
+
+        for (int i = 0; i < targetStringLength; i++) {
+            int randomLimitedInt = leftLimit + (int) (random.nextFloat() * (rightLimit - leftLimit + 1));
+            buffer.append((char) randomLimitedInt);
+        }
+        String generatedString = buffer.toString();
+
+        LOG.debug(generatedString);
+    }
+
+    @Test
+    public void givenUsingJava8_whenGeneratingRandomAlphabeticString_thenCorrect() {
+        int leftLimit = 97; // letter 'a'
+        int rightLimit = 122; // letter 'z'
+        int targetStringLength = 10;
+        Random random = new Random();
+
+        String generatedString = random.ints(leftLimit, rightLimit + 1)
+            .limit(targetStringLength)
+            .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
+            .toString();
+
+        LOG.debug(generatedString);
+    }
+
+    @Test
+    public void givenUsingJava8_whenGeneratingRandomAlphanumericString_thenCorrect() {
+        int leftLimit = 48; // numeral '0'
+        int rightLimit = 122; // letter 'z'
+        int targetStringLength = 10;
+        Random random = new Random();
+
+        String generatedString = random.ints(leftLimit, rightLimit + 1)
+            .filter(i -> (i <= 57 || i >= 65) && (i <= 90 || i >= 97))
+            .limit(targetStringLength)
+            .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
+            .toString();
+
+        LOG.debug(generatedString);
+    }
+
+    @Test
+    public void givenUsingApache_whenGeneratingRandomString_thenCorrect() {
+        String generatedString = RandomStringUtils.random(10);
+
+        LOG.debug(generatedString);
+    }
+
+    @Test
+    public void givenUsingApache_whenGeneratingRandomAlphabeticString_thenCorrect() {
+        String generatedString = RandomStringUtils.randomAlphabetic(10);
+
+        LOG.debug(generatedString);
+    }
+
+    @Test
+    public void givenUsingApache_whenGeneratingRandomAlphanumericString_thenCorrect() {
+        String generatedString = RandomStringUtils.randomAlphanumeric(10);
+
+        LOG.debug(generatedString);
+    }
+
+    @Test
+    public void givenUsingApache_whenGeneratingRandomStringBounded_thenCorrect() {
+        int length = 10;
+        boolean useLetters = true;
+        boolean useNumbers = false;
+        String generatedString = RandomStringUtils.random(length, useLetters, useNumbers);
+
+        LOG.debug(generatedString);
+    }
+
+}
--- a/core-java-modules/core-java-strings/src/test/java/com/baeldung/stringnotempty/StringNotEmptyUnitTest.java
+++ b/core-java-modules/core-java-strings/src/test/java/com/baeldung/stringnotempty/StringNotEmptyUnitTest.java
@ -0,0 +1,46 @@
+package com.baeldung.stringnotempty;
+
+import com.google.common.base.Strings;
+import org.apache.commons.lang3.StringUtils;
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.text.IsEmptyString.isEmptyOrNullString;
+import static org.hamcrest.text.IsEmptyString.isEmptyString;
+import static org.junit.Assert.*;
+
+public class StringNotEmptyUnitTest {
+
+    private String text = "baeldung";
+
+    @Test
+    public void givenAString_whenCheckedForEmptyUsingJunit_shouldAssertSuccessfully() {
+        assertTrue(!text.isEmpty());
+        assertFalse(text.isEmpty());
+        assertNotEquals("", text);
+        assertNotSame("", text);
+    }
+
+    @Test
+    public void givenAString_whenCheckedForEmptyUsingHamcrest_shouldAssertSuccessfully() {
+        assertThat(text, not(isEmptyString()));
+        assertThat(text, not(isEmptyOrNullString()));
+    }
+
+    @Test
+    public void givenAString_whenCheckedForEmptyUsingCommonsLang_shouldAssertSuccessfully() {
+        assertTrue(StringUtils.isNotBlank(text));
+    }
+
+    @Test
+    public void givenAString_whenCheckedForEmptyUsingAssertJ_shouldAssertSuccessfully() {
+        Assertions.assertThat(text).isNotEmpty();
+    }
+
+    @Test
+    public void givenAString_whenCheckedForEmptyUsingGuava_shouldAssertSuccessfully() {
+        assertFalse(Strings.isNullOrEmpty(text));
+    }
+
+}
--- a/core-java-modules/core-java-strings/src/test/java/com/baeldung/stringpool/StringPoolUnitTest.java
+++ b/core-java-modules/core-java-strings/src/test/java/com/baeldung/stringpool/StringPoolUnitTest.java
@ -0,0 +1,44 @@
+package com.baeldung.stringpool;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+
+public class StringPoolUnitTest {
+
+    @Test
+    public void whenCreatingConstantStrings_thenTheirAddressesAreEqual() {
+        String constantString1 = "Baeldung";
+        String constantString2 = "Baeldung";
+
+        assertThat(constantString1).isSameAs(constantString2);
+    }
+
+    @Test
+    public void whenCreatingStringsWithTheNewOperator_thenTheirAddressesAreDifferent() {
+        String newString1 = new String("Baeldung");
+        String newString2 = new String("Baeldung");
+
+        assertThat(newString1).isNotSameAs(newString2);
+    }
+
+    @Test
+    public void whenComparingConstantAndNewStrings_thenTheirAddressesAreDifferent() {
+        String constantString = "Baeldung";
+        String newString = new String("Baeldung");
+
+        assertThat(constantString).isNotSameAs(newString);
+    }
+
+    @Test
+    public void whenInterningAStringWithIdenticalValueToAnother_thenTheirAddressesAreEqual() {
+        String constantString = "interned Baeldung";
+        String newString = new String("interned Baeldung");
+
+        assertThat(constantString).isNotSameAs(newString);
+
+        String internedString = newString.intern();
+
+        assertThat(constantString).isSameAs(internedString);
+    }
+}
--- a/core-java-modules/core-java-strings/src/test/java/com/baeldung/stringtoolong/StringTooLongUnitTest.java
+++ b/core-java-modules/core-java-strings/src/test/java/com/baeldung/stringtoolong/StringTooLongUnitTest.java
@ -0,0 +1,38 @@
+package com.baeldung.stringtoolong;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Properties;
+
+import org.apache.commons.io.IOUtils;
+import org.junit.Test;
+
+public class StringTooLongUnitTest {
+    @Test
+    public void whenDeclaringTooLongString_thenCompilationError() {
+        String stringTooLong = "<string too long>";  
+        assertThat(stringTooLong).isNotEmpty();
+    }
+    
+    @Test
+    public void whenStoringInFileTooLongString_thenNoCompilationError() throws IOException {
+        FileInputStream fis = new FileInputStream("src/test/resources/stringtoolong.txt");
+        String stringTooLong = IOUtils.toString(fis, "UTF-8");
+        assertThat(stringTooLong).isNotEmpty();
+    }
+    
+    @Test
+    public void whenStoringInPropertiesString_thenNoCompilationError() throws IOException {
+        String sValue = null;
+        try (InputStream input = new FileInputStream("src/main/resources/config.properties")) {
+            Properties prop = new Properties();
+            prop.load(input);
+            sValue = prop.getProperty("string.too.long");
+        }
+        assertThat(sValue).isNotEmpty();
+    }
+}
+    
--- a/core-java-modules/core-java-strings/src/test/resources/stringtoolong.txt
+++ b/core-java-modules/core-java-strings/src/test/resources/stringtoolong.txt
				`@ -0,0 +1 @@`
				`label=Alice wys\u0142a\u0142a ci wiadomo\u015B\u0107.`