Switch from Postgres to H2

java-strings-2/README.md

@@ -0,0 +1,27 @@
+## Java Strings Cookbooks and Examples
+
+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)
+- [Removing Stopwords from a String in Java](https://www.baeldung.com/java-string-remove-stopwords)
+- [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)
+- [Removing Repeated Characters from a String](https://www.baeldung.com/java-remove-repeated-char)
+- [Join Array of Primitives with Separator in Java](https://www.baeldung.com/java-join-primitive-array)
+- [Pad a String with Zeros or Spaces in Java](https://www.baeldung.com/java-pad-string)
+- [Remove Emojis from a Java String](https://www.baeldung.com/java-string-remove-emojis)
+- [Remove Leading and Trailing Characters from a String](https://www.baeldung.com/java-remove-trailing-characters)
+- [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)
+- [Check if a String is a Pangram in Java](https://www.baeldung.com/java-string-pangram)
+- [Check If a String Contains Multiple Keywords](https://www.baeldung.com/string-contains-multiple-words)
+- [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)
+- [Checking If a String Is a Repeated Substring](https://www.baeldung.com/java-repeated-substring)
+- [How to Reverse a String in Java](https://www.baeldung.com/java-reverse-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)

java-strings-2/pom.xml

@@ -0,0 +1,155 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>java-strings-2</artifactId>
+    <version>0.1.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+    <name>java-strings-2</name>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-java</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../parent-java</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-core</artifactId>
+            <version>${jmh-core.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-generator-annprocess</artifactId>
+            <version>${jmh-core.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.ibm.icu</groupId>
+            <artifactId>icu4j</artifactId>
+            <version>${icu4j.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>${guava.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${commons-lang3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>${commons-io.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>commons-codec</groupId>
+            <artifactId>commons-codec</artifactId>
+            <version>${commons-codec.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>${junit.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.hamcrest</groupId>
+            <artifactId>hamcrest-library</artifactId>
+            <version>${org.hamcrest.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+        <!-- Added for password generation -->
+        <dependency>
+            <groupId>org.passay</groupId>
+            <artifactId>passay</artifactId>
+            <version>${passay.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-text</artifactId>
+            <version>${commons-text.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.vdurmont</groupId>
+            <artifactId>emoji-java</artifactId>
+            <version>${emoji-java.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.ahocorasick</groupId>
+            <artifactId>ahocorasick</artifactId>
+            <version>${ahocorasick.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>javax.validation</groupId>
+            <artifactId>validation-api</artifactId>
+            <version>${validation-api.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.hibernate.validator</groupId>
+            <artifactId>hibernate-validator</artifactId>
+            <version>${hibernate-validator.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>javax.el</groupId>
+            <artifactId>javax.el-api</artifactId>
+            <version>${javax.el-api.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.glassfish.web</groupId>
+            <artifactId>javax.el</artifactId>
+            <version>${javax.el.version}</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <finalName>java-strings-2</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>${java.version}</source>
+                    <target>${java.version}</target>
+                    <compilerArgument>-parameters</compilerArgument>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <commons-lang3.version>3.8.1</commons-lang3.version>
+        <commons-codec.version>1.10</commons-codec.version>
+        <passay.version>1.3.1</passay.version>
+        <!-- testing -->
+        <assertj.version>3.6.1</assertj.version>
+        <emoji-java.version>4.0.0</emoji-java.version>
+        <ahocorasick.version>0.4.0</ahocorasick.version>
+        <icu4j.version>61.1</icu4j.version>
+        <guava.version>28.0-jre</guava.version>
+        <commons-text.version>1.4</commons-text.version>
+        <validation-api.version>2.0.0.Final</validation-api.version>
+        <hibernate-validator.version>6.0.2.Final</hibernate-validator.version>
+        <javax.el-api.version>3.0.0</javax.el-api.version>
+        <javax.el.version>2.2.6</javax.el.version>
+    </properties>
+
+</project>

java-strings-2/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);
+    }
+
+}

java-strings-2/src/main/java/com/baeldung/localization/ICUFormat.java

@@ -0,0 +1,29 @@
+package com.baeldung.localization;
+
+import java.util.List;
+import java.util.Locale;
+import java.util.ResourceBundle;
+
+import com.ibm.icu.text.MessageFormat;
+
+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 })));
+    }
+}

java-strings-2/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 })));
+    }
+}

java-strings-2/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)));
+    }
+
+}

java-strings-2/src/main/java/com/baeldung/string/MatchWords.java

@@ -0,0 +1,83 @@
+package com.baeldung.string;
+
+import org.ahocorasick.trie.Emit;
+import org.ahocorasick.trie.Token;
+import org.ahocorasick.trie.Trie;
+
+import java.util.*;
+import java.util.function.Function;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class MatchWords {
+
+    public static boolean containsWordsIndexOf(String inputString, String[] words) {
+        boolean found = true;
+        for (String word : words) {
+            if (inputString.indexOf(word) == -1) {
+                found = false;
+                break;
+            }
+        }
+        return found;
+    }
+
+    public static boolean containsWords(String inputString, String[] items) {
+        boolean found = true;
+        for (String item : items) {
+            if (!inputString.contains(item)) {
+                found = false;
+                break;
+            }
+        }
+        return found;
+    }
+
+    public static boolean containsWordsAhoCorasick(String inputString, String[] words) {
+        Trie trie = Trie.builder()
+                .onlyWholeWords()
+                .addKeywords(words)
+                .build();
+
+        Collection<Emit> emits = trie.parseText(inputString);
+        emits.forEach(System.out::println);
+
+        boolean found = true;
+        for(String word : words) {
+            boolean contains = Arrays.toString(emits.toArray()).contains(word);
+            if (!contains) {
+                found = false;
+                break;
+            }
+        }
+
+        return found;
+    }
+
+    public static boolean containsWordsPatternMatch(String inputString, String[] words) {
+
+        StringBuilder regexp = new StringBuilder();
+        for (String word : words) {
+            regexp.append("(?=.*").append(word).append(")");
+        }
+
+        Pattern pattern = Pattern.compile(regexp.toString());
+
+        return pattern.matcher(inputString).find();
+    }
+
+    public static boolean containsWordsJava8(String inputString, String[] words) {
+        List<String> inputStringList = Arrays.asList(inputString.split(" "));
+        List<String> wordsList = Arrays.asList(words);
+
+        return wordsList.stream().allMatch(inputStringList::contains);
+    }
+
+    public static boolean containsWordsArray(String inputString, String[] words) {
+        List<String> inputStringList = Arrays.asList(inputString.split(" "));
+        List<String> wordsList = Arrays.asList(words);
+
+        return inputStringList.containsAll(wordsList);
+    }
+}

java-strings-2/src/main/java/com/baeldung/string/Pangram.java

@@ -0,0 +1,61 @@
+package com.baeldung.string;
+
+import java.util.Arrays;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class Pangram {
+    private static final int ALPHABET_COUNT = 26;
+
+    public static boolean isPangram(String str) {
+        if (str == null)
+            return false;
+        Boolean[] alphabetMarker = new Boolean[ALPHABET_COUNT];
+        Arrays.fill(alphabetMarker, false);
+        int alphabetIndex = 0;
+        String strUpper = str.toUpperCase();
+        for (int i = 0; i < str.length(); i++) {
+            if ('A' <= strUpper.charAt(i) && strUpper.charAt(i) <= 'Z') {
+                alphabetIndex = strUpper.charAt(i) - 'A';
+                alphabetMarker[alphabetIndex] = true;
+            }
+        }
+        for (boolean index : alphabetMarker) {
+            if (!index)
+                return false;
+        }
+        return true;
+    }
+
+    public static boolean isPangramWithStreams(String str) {
+        if (str == null)
+            return false;
+
+        // filtered character stream
+        String strUpper = str.toUpperCase();
+        Stream<Character> filteredCharStream = strUpper.chars()
+            .filter(item -> ((item >= 'A' && item <= 'Z')))
+            .mapToObj(c -> (char) c);
+        Map<Character, Boolean> alphabetMap = filteredCharStream.collect(Collectors.toMap(item -> item, k -> Boolean.TRUE, (p1, p2) -> p1));
+
+        return (alphabetMap.size() == ALPHABET_COUNT);
+    }
+
+    public static boolean isPerfectPangram(String str) {
+        if (str == null)
+            return false;
+
+        // filtered character stream
+        String strUpper = str.toUpperCase();
+        Stream<Character> filteredCharStream = strUpper.chars()
+            .filter(item -> ((item >= 'A' && item <= 'Z')))
+            .mapToObj(c -> (char) c);
+        Map<Character, Long> alphabetFrequencyMap = filteredCharStream.collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
+
+        return (alphabetFrequencyMap.size() == ALPHABET_COUNT && alphabetFrequencyMap.values()
+            .stream()
+            .allMatch(item -> item == 1));
+    }
+}

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

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

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

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

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

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

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

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

java-strings-2/src/main/java/com/baeldung/string/multiline/MultiLineString.java

@@ -0,0 +1,67 @@
+package com.baeldung.string.multiline;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import com.google.common.base.Joiner;
+import com.google.common.collect.ImmutableList;
+
+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")));
+    }
+
+}

java-strings-2/src/main/java/com/baeldung/string/padding/StringPaddingUtil.java

@@ -0,0 +1,34 @@
+package com.baeldung.string.padding;
+
+public class StringPaddingUtil {
+
+    public static String padLeftSpaces(String inputString, int length) {
+        if (inputString.length() >= length) {
+            return inputString;
+        }
+        StringBuilder sb = new StringBuilder();
+        while (sb.length() < length - inputString.length()) {
+            sb.append(' ');
+        }
+        sb.append(inputString);
+
+        return sb.toString();
+    }
+
+    public static String padLeft(String inputString, int length) {
+        if (inputString.length() >= length) {
+            return inputString;
+        }
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < length; i++) {
+            sb.append(' ');
+        }
+        return sb.substring(inputString.length()) + inputString;
+    }
+
+    public static String padLeftZeros(String inputString, int length) {
+        return String
+          .format("%1$" + length + "s", inputString)
+          .replace(' ', '0');
+    }
+}

java-strings-2/src/main/java/com/baeldung/string/performance/RemovingStopwordsPerformanceComparison.java

@@ -0,0 +1,73 @@
+package com.baeldung.string.performance;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+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;
+
+
+@Fork(value = 3, warmups = 1)
+@State(Scope.Benchmark)
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+public class RemovingStopwordsPerformanceComparison {
+
+    private String data;
+    
+    private List<String> stopwords;
+
+    private String stopwordsRegex;
+    
+    
+    public static void main(String[] args) throws Exception {
+        org.openjdk.jmh.Main.main(args);
+    }
+
+    @Setup
+    public void setup() throws IOException {
+        data = new String(Files.readAllBytes(Paths.get("src/main/resources/shakespeare-hamlet.txt")));
+        data = data.toLowerCase();
+        stopwords = Files.readAllLines(Paths.get("src/main/resources/english_stopwords.txt"));
+        stopwordsRegex = stopwords.stream().collect(Collectors.joining("|", "\\b(", ")\\b\\s?"));
+    }
+
+    @Benchmark
+    public String removeManually() {
+        String[] allWords = data.split(" ");
+        StringBuilder builder = new StringBuilder();
+        for(String word:allWords) {
+            if(! stopwords.contains(word)) {
+                builder.append(word);
+                builder.append(' ');
+            }
+        }
+        return builder.toString().trim();
+    }
+
+    @Benchmark
+    public String removeAll() {
+        ArrayList<String> allWords = Stream.of(data.split(" "))
+            .collect(Collectors.toCollection(ArrayList<String>::new));
+        allWords.removeAll(stopwords);
+        return allWords.stream().collect(Collectors.joining(" "));
+    }
+
+    @Benchmark
+    public String replaceRegex() {
+        return data.replaceAll(stopwordsRegex, "");
+    }
+
+}

java-strings-2/src/main/java/com/baeldung/string/removeleadingtrailingchar/RemoveLeadingAndTrailingZeroes.java

@@ -0,0 +1,103 @@
+package com.baeldung.string.removeleadingtrailingchar;
+
+
+import org.apache.commons.lang3.StringUtils;
+
+import com.google.common.base.CharMatcher;
+
+public class RemoveLeadingAndTrailingZeroes {
+
+    public static String removeLeadingZeroesWithStringBuilder(String s) {
+        StringBuilder sb = new StringBuilder(s);
+
+        while (sb.length() > 1 && sb.charAt(0) == '0') {
+            sb.deleteCharAt(0);
+        }
+
+        return sb.toString();
+    }
+
+    public static String removeTrailingZeroesWithStringBuilder(String s) {
+        StringBuilder sb = new StringBuilder(s);
+
+        while (sb.length() > 1 && sb.charAt(sb.length() - 1) == '0') {
+            sb.setLength(sb.length() - 1);
+        }
+
+        return sb.toString();
+    }
+
+    public static String removeLeadingZeroesWithSubstring(String s) {
+        int index = 0;
+
+        for (; index < s.length() - 1; index++) {
+            if (s.charAt(index) != '0') {
+                break;
+            }
+        }
+
+        return s.substring(index);
+    }
+
+    public static String removeTrailingZeroesWithSubstring(String s) {
+        int index = s.length() - 1;
+
+        for (; index > 0; index--) {
+            if (s.charAt(index) != '0') {
+                break;
+            }
+        }
+
+        return s.substring(0, index + 1);
+    }
+
+    public static String removeLeadingZeroesWithApacheCommonsStripStart(String s) {
+        String stripped = StringUtils.stripStart(s, "0");
+
+        if (stripped.isEmpty() && !s.isEmpty()) {
+            return "0";
+        }
+
+        return stripped;
+    }
+
+    public static String removeTrailingZeroesWithApacheCommonsStripEnd(String s) {
+        String stripped = StringUtils.stripEnd(s, "0");
+
+        if (stripped.isEmpty() && !s.isEmpty()) {
+            return "0";
+        }
+
+        return stripped;
+    }
+
+    public static String removeLeadingZeroesWithGuavaTrimLeadingFrom(String s) {
+        String stripped = CharMatcher.is('0')
+            .trimLeadingFrom(s);
+
+        if (stripped.isEmpty() && !s.isEmpty()) {
+            return "0";
+        }
+
+        return stripped;
+    }
+
+    public static String removeTrailingZeroesWithGuavaTrimTrailingFrom(String s) {
+        String stripped = CharMatcher.is('0')
+            .trimTrailingFrom(s);
+
+        if (stripped.isEmpty() && !s.isEmpty()) {
+            return "0";
+        }
+
+        return stripped;
+    }
+
+    public static String removeLeadingZeroesWithRegex(String s) {
+        return s.replaceAll("^0+(?!$)", "");
+    }
+
+    public static String removeTrailingZeroesWithRegex(String s) {
+        return s.replaceAll("(?!^)0+$", "");
+    }
+}

java-strings-2/src/main/java/com/baeldung/string/repetition/SubstringRepetition.java

@@ -0,0 +1,29 @@
+package com.baeldung.string.repetition;
+
+public class SubstringRepetition {
+
+    public static boolean containsOnlySubstrings(String string) {
+
+        if (string.length() < 2) {
+            return false;
+        }
+
+        StringBuilder substr = new StringBuilder();
+        for (int i = 0; i < string.length() / 2; i++) {
+            substr.append(string.charAt(i));
+
+            String clearedFromSubstrings = string.replaceAll(substr.toString(), "");
+
+            if (clearedFromSubstrings.length() == 0) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public static boolean containsOnlySubstringsEfficient(String string) {
+
+        return ((string + string).indexOf(string, 1) != string.length());
+    }
+}

java-strings-2/src/main/java/com/baeldung/string/reverse/ReverseStringExamples.java

@@ -0,0 +1,56 @@
+package com.baeldung.string.reverse;
+
+import org.apache.commons.lang3.StringUtils;
+
+public class ReverseStringExamples {
+
+    public static String reverse(String input) {
+        if (input == null) {
+            return null;
+        }
+
+        String output = "";
+
+        for (int i = input.length() - 1; i >= 0; i--) {
+            output = output + input.charAt(i);
+        }
+
+        return output;
+    }
+
+    public static String reverseUsingStringBuilder(String input) {
+        if (input == null) {
+            return null;
+        }
+
+        StringBuilder output = new StringBuilder(input).reverse();
+
+        return output.toString();
+    }
+
+    public static String reverseUsingApacheCommons(String input) {
+        return StringUtils.reverse(input);
+    }
+
+    public static String reverseTheOrderOfWords(String sentence) {
+        if (sentence == null) {
+            return null;
+        }
+
+        StringBuilder output = new StringBuilder();
+        String[] words = sentence.split(" ");
+
+        for (int i = words.length - 1; i >= 0; i--) {
+            output.append(words[i]);
+            output.append(" ");
+        }
+
+        return output.toString()
+            .trim();
+    }
+
+    public static String reverseTheOrderOfWordsUsingApacheCommons(String sentence) {
+        return StringUtils.reverseDelimited(sentence, ' ');
+    }
+
+}

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

@@ -0,0 +1,58 @@
+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();
+    }
+}

java-strings-2/src/main/java/com/baeldung/stringduplicates/RemoveDuplicateFromString.java

@@ -0,0 +1,102 @@
+package com.baeldung.stringduplicates;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+public class RemoveDuplicateFromString {
+
+
+    String removeDuplicatesUsingCharArray(String str) {
+
+        char[] chars = str.toCharArray();
+        StringBuilder sb = new StringBuilder();
+        int repeatedCtr;
+        for (int i = 0; i < chars.length; i++) {
+            repeatedCtr = 0;
+            for (int j = i + 1; j < chars.length; j++) {
+                if (chars[i] == chars[j]) {
+                    repeatedCtr++;
+                }
+            }
+            if (repeatedCtr == 0) {
+                sb.append(chars[i]);
+            }
+        }
+        return sb.toString();
+    }
+
+    String removeDuplicatesUsinglinkedHashSet(String str) {
+
+        StringBuilder sb = new StringBuilder();
+        Set<Character> linkedHashSet = new LinkedHashSet<>();
+
+        for (int i = 0; i < str.length(); i++) {
+            linkedHashSet.add(str.charAt(i));
+        }
+
+        for (Character c : linkedHashSet) {
+            sb.append(c);
+        }
+
+        return sb.toString();
+    }
+
+    String removeDuplicatesUsingSorting(String str) {
+        StringBuilder sb = new StringBuilder();
+        if(!str.isEmpty()) {
+            char[] chars = str.toCharArray();
+            Arrays.sort(chars);
+
+            sb.append(chars[0]);
+            for (int i = 1; i < chars.length; i++) {
+                if (chars[i] != chars[i - 1]) {
+                    sb.append(chars[i]);
+                }
+            }
+        }
+
+        return sb.toString();
+    }
+
+    String removeDuplicatesUsingHashSet(String str) {
+
+        StringBuilder sb = new StringBuilder();
+        Set<Character> hashSet = new HashSet<>();
+
+        for (int i = 0; i < str.length(); i++) {
+            hashSet.add(str.charAt(i));
+        }
+
+        for (Character c : hashSet) {
+            sb.append(c);
+        }
+
+        return sb.toString();
+    }
+
+    String removeDuplicatesUsingIndexOf(String str) {
+
+        StringBuilder sb = new StringBuilder();
+        int idx;
+        for (int i = 0; i < str.length(); i++) {
+            char c = str.charAt(i);
+            idx = str.indexOf(c, i + 1);
+            if (idx == -1) {
+                sb.append(c);
+            }
+        }
+        return sb.toString();
+    }
+
+
+    String removeDuplicatesUsingDistinct(String str) {
+        StringBuilder sb = new StringBuilder();
+        str.chars().distinct().forEach(c -> sb.append((char) c));
+        return sb.toString();
+    }
+
+}
+
+

java-strings-2/src/main/resources/english_stopwords.txt

@@ -0,0 +1,127 @@
+i
+me
+my
+myself
+we
+our
+ours
+ourselves
+you
+your
+yours
+yourself
+yourselves
+he
+him
+his
+himself
+she
+her
+hers
+herself
+it
+its
+itself
+they
+them
+their
+theirs
+themselves
+what
+which
+who
+whom
+this
+that
+these
+those
+am
+is
+are
+was
+were
+be
+been
+being
+have
+has
+had
+having
+do
+does
+did
+doing
+a
+an
+the
+and
+but
+if
+or
+because
+as
+until
+while
+of
+at
+by
+for
+with
+about
+against
+between
+into
+through
+during
+before
+after
+above
+below
+to
+from
+up
+down
+in
+out
+on
+off
+over
+under
+again
+further
+then
+once
+here
+there
+when
+where
+why
+how
+all
+any
+both
+each
+few
+more
+most
+other
+some
+such
+no
+nor
+not
+only
+own
+same
+so
+than
+too
+very
+s
+t
+can
+will
+just
+don
+should
+now

java-strings-2/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}}.

java-strings-2/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}}.

java-strings-2/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}}.

java-strings-2/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}}.

java-strings-2/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>

java-strings-2/src/main/resources/messages_en.properties

@@ -0,0 +1 @@
+label=Alice has sent you a message.

java-strings-2/src/main/resources/messages_fr.properties

@@ -0,0 +1 @@
+label=Alice vous a envoy\u00e9 un message.

java-strings-2/src/main/resources/messages_it.properties

@@ -0,0 +1 @@
+label=Alice ti ha inviato un messaggio.

java-strings-2/src/main/resources/messages_pl.properties

@@ -0,0 +1 @@
+label=Alice wys\u0142a\u0142a ci wiadomo\u015B\u0107.

java-strings-2/src/main/resources/stephenking.txt

@@ -0,0 +1,4 @@
+Get busy living
+or
+get busy dying.
+--Stephen King

java-strings-2/src/test/java/com/baeldung/StringConcatenationUnitTest.java

@@ -0,0 +1,105 @@
+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);
+  }
+}

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

@@ -0,0 +1,56 @@
+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);
+    }
+
+}

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

@@ -0,0 +1,109 @@
+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;
+    }
+
+}

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

@@ -0,0 +1,59 @@
+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));
+    }
+}

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

@@ -0,0 +1,58 @@
+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);
+    }
+}

java-strings-2/src/test/java/com/baeldung/localization/ICUFormatUnitTest.java

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

java-strings-2/src/test/java/com/baeldung/string/MatchWordsUnitTest.java

@@ -0,0 +1,66 @@
+package com.baeldung.string;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class MatchWordsUnitTest {
+
+    private final String[] words = {"hello", "Baeldung"};
+    private final String inputString = "hello there, Baeldung";
+    private final String wholeInput = "helloBaeldung";
+
+    @Test
+    public void givenText_whenCallingStringContains_shouldMatchWords() {
+        final boolean result = MatchWords.containsWords(inputString, words);
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenText_whenCallingJava8_shouldMatchWords() {
+        final boolean result = MatchWords.containsWordsJava8(inputString, words);
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenText_whenCallingJava8_shouldNotMatchWords() {
+        final boolean result = MatchWords.containsWordsJava8(wholeInput, words);
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenText_whenCallingPattern_shouldMatchWords() {
+        final boolean result = MatchWords.containsWordsPatternMatch(inputString, words);
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenText_whenCallingAhoCorasick_shouldMatchWords() {
+        final boolean result = MatchWords.containsWordsAhoCorasick(inputString, words);
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenText_whenCallingAhoCorasick_shouldNotMatchWords() {
+        final boolean result = MatchWords.containsWordsAhoCorasick(wholeInput, words);
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenText_whenCallingIndexOf_shouldMatchWords() {
+        final boolean result = MatchWords.containsWordsIndexOf(inputString, words);
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenText_whenCallingArrayList_shouldMatchWords() {
+        final boolean result = MatchWords.containsWordsArray(inputString, words);
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenText_whenCallingArrayList_shouldNotMatchWords() {
+        final boolean result = MatchWords.containsWordsArray(wholeInput, words);
+        assertThat(result).isFalse();
+    }
+}

java-strings-2/src/test/java/com/baeldung/string/PangramUnitTest.java

@@ -0,0 +1,43 @@
+package com.baeldung.string;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import org.junit.Test;
+
+public class PangramUnitTest {
+
+    @Test
+    public void givenValidString_isPangram_shouldReturnSuccess() {
+        String input = "Two driven jocks help fax my big quiz";
+        assertTrue(Pangram.isPangram(input));
+        assertTrue(Pangram.isPangramWithStreams(input));
+    }
+
+    @Test
+    public void givenNullString_isPangram_shouldReturnFailure() {
+        String input = null;
+        assertFalse(Pangram.isPangram(input));
+        assertFalse(Pangram.isPangramWithStreams(input));
+        assertFalse(Pangram.isPerfectPangram(input));
+    }
+
+    @Test
+    public void givenPerfectPangramString_isPerfectPangram_shouldReturnSuccess() {
+        String input = "abcdefghijklmNoPqrStuVwxyz";
+        assertTrue(Pangram.isPerfectPangram(input));
+    }
+
+    @Test
+    public void givenNonPangramString_isPangram_shouldReturnFailure() {
+        String input = "invalid pangram";
+        assertFalse(Pangram.isPangram(input));
+        assertFalse(Pangram.isPangramWithStreams(input));
+    }
+
+    @Test
+    public void givenPangram_isPerfectPangram_shouldReturnFailure() {
+        String input = "Two driven jocks help fax my big quiz";
+        assertFalse(Pangram.isPerfectPangram(input));
+    }
+
+}

java-strings-2/src/test/java/com/baeldung/string/RemoveStopwordsUnitTest.java

@@ -0,0 +1,60 @@
+package com.baeldung.string;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class RemoveStopwordsUnitTest {
+    final String original = "The quick brown fox jumps over the lazy dog";
+    final String target = "quick brown fox jumps lazy dog";
+    static List<String> stopwords;
+
+    @BeforeClass
+    public static void loadStopwords() throws IOException {
+        stopwords = Files.readAllLines(Paths.get("src/main/resources/english_stopwords.txt"));
+    }
+
+    @Test
+    public void whenRemoveStopwordsManually_thenSuccess() {
+        String[] allWords = original.toLowerCase()
+            .split(" ");
+        StringBuilder builder = new StringBuilder();
+        for (String word : allWords) {
+            if (!stopwords.contains(word)) {
+                builder.append(word);
+                builder.append(' ');
+            }
+        }
+
+        String result = builder.toString().trim();
+        assertEquals(result, target);
+    }
+
+    @Test
+    public void whenRemoveStopwordsUsingRemoveAll_thenSuccess() {
+        ArrayList<String> allWords = Stream.of(original.toLowerCase()
+            .split(" "))
+            .collect(Collectors.toCollection(ArrayList<String>::new));
+        allWords.removeAll(stopwords);
+        String result = allWords.stream().collect(Collectors.joining(" "));
+        assertEquals(result, target);
+    }
+
+    @Test
+    public void whenRemoveStopwordsUsingRegex_thenSuccess() {
+        String stopwordsRegex = stopwords.stream()
+            .collect(Collectors.joining("|", "\\b(", ")\\b\\s?"));
+        String result = original.toLowerCase().replaceAll(stopwordsRegex, "");
+        assertEquals(result, target);
+    }
+
+}

java-strings-2/src/test/java/com/baeldung/string/RemovingEmojiFromStringUnitTest.java

@@ -0,0 +1,60 @@
+package com.baeldung.string;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.junit.Test;
+
+import com.vdurmont.emoji.EmojiParser;
+
+public class RemovingEmojiFromStringUnitTest {
+    String text = "la conférence, commencera à 10 heures 😅";
+    String regex = "[^\\p{L}\\p{N}\\p{P}\\p{Z}]";
+
+    @Test
+    public void whenRemoveEmojiUsingLibrary_thenSuccess() {
+        String result = EmojiParser.removeAllEmojis(text);
+        System.out.println(result);
+        assertEquals(result, "la conférence, commencera à 10 heures ");
+    }
+    
+    @Test
+    public void whenReplaceEmojiUsingLibrary_thenSuccess() {
+        String result = EmojiParser.parseToAliases(text);
+        System.out.println(result);
+        assertEquals(result, "la conférence, commencera à 10 heures :sweat_smile:");
+    }
+
+    @Test
+    public void whenRemoveEmojiUsingRegex_thenSuccess() {
+        String result = text.replaceAll(regex, "");
+        System.out.println(result);
+        assertEquals(result, "la conférence, commencera à 10 heures ");
+    }
+
+    @Test
+    public void whenRemoveEmojiUsingMatcher_thenSuccess() {
+        Pattern pattern = Pattern.compile(regex, Pattern.UNICODE_CHARACTER_CLASS);
+        Matcher matcher = pattern.matcher(text);
+        
+        String result = matcher.replaceAll("");
+        System.out.println(result);
+        assertEquals(result, "la conférence, commencera à 10 heures ");
+    }
+
+    @Test
+    public void whenRemoveEmojiUsingCodepoints_thenSuccess() {
+        String result = text.replaceAll("[\\x{0001f300}-\\x{0001f64f}]|[\\x{0001f680}-\\x{0001f6ff}]", "");
+        System.out.println(result);
+        assertEquals(result, "la conférence, commencera à 10 heures ");
+    }
+
+    @Test
+    public void whenRemoveEmojiUsingUnicode_thenSuccess() {
+        String result = text.replaceAll("[\ud83c\udf00-\ud83d\ude4f]|[\ud83d\ude80-\ud83d\udeff]", "");
+        System.out.println(result);
+        assertEquals(result, "la conférence, commencera à 10 heures ");
+    }
+}

java-strings-2/src/test/java/com/baeldung/string/StringFromPrimitiveArrayUnitTest.java

@@ -0,0 +1,129 @@
+package com.baeldung.string;
+
+import com.google.common.base.Joiner;
+import com.google.common.primitives.Chars;
+import com.google.common.primitives.Ints;
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.junit.Test;
+
+import java.nio.CharBuffer;
+import java.util.Arrays;
+import java.util.StringJoiner;
+import java.util.stream.Collectors;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+
+public class StringFromPrimitiveArrayUnitTest {
+
+    private int[] intArray = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+
+    private char[] charArray = {'a', 'b', 'c', 'd', 'e', 'f'};
+
+    private char separatorChar = '-';
+
+    private String separator = String.valueOf(separatorChar);
+
+    private String expectedIntString = "1-2-3-4-5-6-7-8-9";
+
+    private String expectedCharString = "a-b-c-d-e-f";
+
+    @Test
+    public void givenIntArray_whenJoinBySeparator_thenReturnsString_through_Java8CollectorsJoining() {
+        assertThat(Arrays.stream(intArray)
+          .mapToObj(String::valueOf)
+          .collect(Collectors.joining(separator)))
+          .isEqualTo(expectedIntString);
+    }
+
+    @Test
+    public void givenCharArray_whenJoinBySeparator_thenReturnsString_through_Java8CollectorsJoining() {
+        assertThat(CharBuffer.wrap(charArray).chars()
+          .mapToObj(intChar -> String.valueOf((char) intChar))
+          .collect(Collectors.joining(separator)))
+          .isEqualTo(expectedCharString);
+    }
+
+
+    @Test
+    public void giveIntArray_whenJoinBySeparator_thenReturnsString_through_Java8StringJoiner() {
+        StringJoiner intStringJoiner = new StringJoiner(separator);
+
+        Arrays.stream(intArray)
+          .mapToObj(String::valueOf)
+          .forEach(intStringJoiner::add);
+
+        assertThat(intStringJoiner.toString()).isEqualTo(expectedIntString);
+    }
+
+    @Test
+    public void givenCharArray_whenJoinBySeparator_thenReturnsString_through_Java8StringJoiner() {
+        StringJoiner charStringJoiner = new StringJoiner(separator);
+
+        CharBuffer.wrap(charArray).chars()
+          .mapToObj(intChar -> String.valueOf((char) intChar))
+          .forEach(charStringJoiner::add);
+
+        assertThat(charStringJoiner.toString()).isEqualTo(expectedCharString);
+    }
+
+    @Test
+    public void givenIntArray_whenJoinBySeparator_thenReturnsString_through_CommonsLang() {
+        assertThat(StringUtils.join(intArray, separatorChar)).isEqualTo(expectedIntString);
+        assertThat(StringUtils.join(ArrayUtils.toObject(intArray), separator)).isEqualTo(expectedIntString);
+    }
+
+    @Test
+    public void givenCharArray_whenJoinBySeparator_thenReturnsString_through_CommonsLang() {
+        assertThat(StringUtils.join(charArray, separatorChar)).isEqualTo(expectedCharString);
+        assertThat(StringUtils.join(ArrayUtils.toObject(charArray), separator)).isEqualTo(expectedCharString);
+    }
+
+    @Test
+    public void givenIntArray_whenJoinBySeparator_thenReturnsString_through_GuavaJoiner() {
+        assertThat(Joiner.on(separator).join(Ints.asList(intArray))).isEqualTo(expectedIntString);
+    }
+
+    @Test
+    public void givenCharArray_whenJoinBySeparator_thenReturnsString_through_GuavaJoiner() {
+        assertThat(Joiner.on(separator).join(Chars.asList(charArray))).isEqualTo(expectedCharString);
+    }
+
+    @Test
+    public void givenIntArray_whenJoinBySeparator_thenReturnsString_through_Java7StringBuilder() {
+        assertThat(joinIntArrayWithStringBuilder(intArray, separator)).isEqualTo(expectedIntString);
+    }
+
+    @Test
+    public void givenCharArray_whenJoinBySeparator_thenReturnsString_through_Java7StringBuilder() {
+        assertThat(joinCharArrayWithStringBuilder(charArray, separator)).isEqualTo(expectedCharString);
+    }
+
+    private String joinIntArrayWithStringBuilder(int[] array, String separator) {
+        if (array.length == 0) {
+            return "";
+        }
+        StringBuilder stringBuilder = new StringBuilder();
+        for (int i = 0; i < array.length - 1; i++) {
+            stringBuilder.append(array[i]);
+            stringBuilder.append(separator);
+        }
+        stringBuilder.append(array[array.length - 1]);
+        return stringBuilder.toString();
+    }
+
+    private String joinCharArrayWithStringBuilder(char[] array, String separator) {
+        if (array.length == 0) {
+            return "";
+        }
+        StringBuilder stringBuilder = new StringBuilder();
+        for (int i = 0; i < array.length - 1; i++) {
+            stringBuilder.append(array[i]);
+            stringBuilder.append(separator);
+        }
+        stringBuilder.append(array[array.length - 1]);
+        return stringBuilder.toString();
+    }
+
+}

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

@@ -0,0 +1,29 @@
+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));
+    }
+}

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

@@ -0,0 +1,29 @@
+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));
+    }
+}

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

@@ -0,0 +1,142 @@
+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));
+    }
+}

java-strings-2/src/test/java/com/baeldung/string/interview/LocaleUnitTest.java

@@ -0,0 +1,19 @@
+package com.baeldung.string.interview;
+
+import java.math.BigDecimal;
+import java.text.NumberFormat;
+import java.util.Locale;
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+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");
+    }
+}

java-strings-2/src/test/java/com/baeldung/string/interview/StringAnagramUnitTest.java

@@ -0,0 +1,29 @@
+package com.baeldung.string.interview;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Arrays;
+
+import org.junit.Test;
+
+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();
+    }
+}

java-strings-2/src/test/java/com/baeldung/string/interview/StringChangeCaseUnitTest.java

@@ -0,0 +1,20 @@
+package com.baeldung.string.interview;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+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());
+    }
+}

java-strings-2/src/test/java/com/baeldung/string/interview/StringCountOccurrencesUnitTest.java

@@ -0,0 +1,28 @@
+package com.baeldung.string.interview;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+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);
+    }
+}

java-strings-2/src/test/java/com/baeldung/string/interview/StringFormatUnitTest.java

@@ -0,0 +1,14 @@
+package com.baeldung.string.interview;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+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");
+    }
+}

java-strings-2/src/test/java/com/baeldung/string/interview/StringInternUnitTest.java

@@ -0,0 +1,17 @@
+package com.baeldung.string.interview;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+
+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();
+    }
+}

java-strings-2/src/test/java/com/baeldung/string/interview/StringJoinerUnitTest.java

@@ -0,0 +1,18 @@
+package com.baeldung.string.interview;
+
+import java.util.StringJoiner;
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+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]");
+    }
+}

java-strings-2/src/test/java/com/baeldung/string/interview/StringPalindromeUnitTest.java

@@ -0,0 +1,29 @@
+package com.baeldung.string.interview;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+
+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();
+    }
+}

java-strings-2/src/test/java/com/baeldung/string/interview/StringReverseUnitTest.java

@@ -0,0 +1,13 @@
+package com.baeldung.string.interview;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class StringReverseUnitTest {
+    @Test
+    public void whenUsingInbuildMethods_thenStringReversed() {
+        String reversed = new StringBuilder("baeldung").reverse().toString();
+        assertEquals("gnudleab", reversed);
+    }
+}

java-strings-2/src/test/java/com/baeldung/string/interview/StringSplitUnitTest.java

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

java-strings-2/src/test/java/com/baeldung/string/interview/StringToByteArrayUnitTest.java

@@ -0,0 +1,24 @@
+package com.baeldung.string.interview;
+
+import static org.junit.Assert.assertArrayEquals;
+
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.StandardCharsets;
+
+import org.junit.Test;
+
+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);
+    }
+}

java-strings-2/src/test/java/com/baeldung/string/interview/StringToCharArrayUnitTest.java

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

java-strings-2/src/test/java/com/baeldung/string/interview/StringToIntegerUnitTest.java

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

java-strings-2/src/test/java/com/baeldung/string/multiline/MultiLineStringUnitTest.java

@@ -0,0 +1,22 @@
+package com.baeldung.string.multiline;
+
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+
+import com.baeldung.string.multiline.MultiLineString;
+
+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());
+    }
+    
+}

java-strings-2/src/test/java/com/baeldung/string/padding/StringPaddingUtilUnitTest.java

@@ -0,0 +1,50 @@
+package com.baeldung.string.padding;
+
+import com.google.common.base.Strings;
+import org.apache.commons.lang3.StringUtils;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class StringPaddingUtilUnitTest {
+
+    String inputString = "123456";
+    String expectedPaddedStringSpaces = "    123456";
+    String expectedPaddedStringZeros = "0000123456";
+    int minPaddedStringLength = 10;
+
+    @Test
+    public void givenString_whenPaddingWithSpaces_thenStringPaddedMatches() {
+        assertEquals(expectedPaddedStringSpaces, StringPaddingUtil.padLeftSpaces(inputString, minPaddedStringLength));
+    }
+
+    @Test
+    public void givenString_whenPaddingWithSpacesUsingSubstring_thenStringPaddedMatches() {
+        assertEquals(expectedPaddedStringSpaces, StringPaddingUtil.padLeft(inputString, minPaddedStringLength));
+    }
+
+    @Test
+    public void givenString_whenPaddingWithZeros_thenStringPaddedMatches() {
+        assertEquals(expectedPaddedStringZeros, StringPaddingUtil.padLeftZeros(inputString, minPaddedStringLength));
+    }
+
+    @Test
+    public void givenString_whenPaddingWithSpacesUsingStringUtils_thenStringPaddedMatches() {
+        assertEquals(expectedPaddedStringSpaces, StringUtils.leftPad(inputString, minPaddedStringLength));
+    }
+
+    @Test
+    public void givenString_whenPaddingWithZerosUsingStringUtils_thenStringPaddedMatches() {
+        assertEquals(expectedPaddedStringZeros, StringUtils.leftPad(inputString, minPaddedStringLength, "0"));
+    }
+
+    @Test
+    public void givenString_whenPaddingWithSpacesUsingGuavaStrings_thenStringPaddedMatches() {
+        assertEquals(expectedPaddedStringSpaces, Strings.padStart(inputString, minPaddedStringLength, ' '));
+    }
+
+    @Test
+    public void givenString_whenPaddingWithZerosUsingGuavaStrings_thenStringPaddedMatches() {
+        assertEquals(expectedPaddedStringZeros, Strings.padStart(inputString, minPaddedStringLength, '0'));
+    }
+}

java-strings-2/src/test/java/com/baeldung/string/removeleadingtrailingchar/RemoveLeadingAndTrailingZeroesUnitTest.java

@@ -0,0 +1,143 @@
+package com.baeldung.string.removeleadingtrailingchar;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.stream.Stream;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+public class RemoveLeadingAndTrailingZeroesUnitTest {
+
+    public static Stream<Arguments> leadingZeroTestProvider() {
+        return Stream.of(Arguments.of("", ""), Arguments.of("abc", "abc"), Arguments.of("123", "123"), Arguments.of("0abc", "abc"), Arguments.of("0123", "123"), Arguments.of("0000123", "123"), Arguments.of("1230", "1230"), Arguments.of("01230", "1230"), Arguments.of("01", "1"),
+            Arguments.of("0001", "1"), Arguments.of("0", "0"), Arguments.of("00", "0"), Arguments.of("0000", "0"), Arguments.of("12034", "12034"), Arguments.of("1200034", "1200034"), Arguments.of("0012034", "12034"), Arguments.of("1203400", "1203400"));
+    }
+
+    public static Stream<Arguments> trailingZeroTestProvider() {
+        return Stream.of(Arguments.of("", ""), Arguments.of("abc", "abc"), Arguments.of("123", "123"), Arguments.of("abc0", "abc"), Arguments.of("1230", "123"), Arguments.of("1230000", "123"), Arguments.of("0123", "0123"), Arguments.of("01230", "0123"), Arguments.of("10", "1"),
+            Arguments.of("1000", "1"), Arguments.of("0", "0"), Arguments.of("00", "0"), Arguments.of("0000", "0"), Arguments.of("12034", "12034"), Arguments.of("1200034", "1200034"), Arguments.of("0012034", "0012034"), Arguments.of("1203400", "12034"));
+    }
+
+    @ParameterizedTest
+    @MethodSource("leadingZeroTestProvider")
+    public void givenTestStrings_whenRemoveLeadingZeroesWithStringBuilder_thenReturnWithoutLeadingZeroes(String input, String expected) {
+        // given
+
+        // when
+        String result = RemoveLeadingAndTrailingZeroes.removeLeadingZeroesWithStringBuilder(input);
+
+        // then
+        assertThat(result).isEqualTo(expected);
+    }
+
+    @ParameterizedTest
+    @MethodSource("trailingZeroTestProvider")
+    public void givenTestStrings_whenRemoveTrailingZeroesWithStringBuilder_thenReturnWithoutTrailingZeroes(String input, String expected) {
+        // given
+
+        // when
+        String result = RemoveLeadingAndTrailingZeroes.removeTrailingZeroesWithStringBuilder(input);
+
+        // then
+        assertThat(result).isEqualTo(expected);
+    }
+
+    @ParameterizedTest
+    @MethodSource("leadingZeroTestProvider")
+    public void givenTestStrings_whenRemoveLeadingZeroesWithSubstring_thenReturnWithoutLeadingZeroes(String input, String expected) {
+        // given
+
+        // when
+        String result = RemoveLeadingAndTrailingZeroes.removeLeadingZeroesWithSubstring(input);
+
+        // then
+        assertThat(result).isEqualTo(expected);
+    }
+
+    @ParameterizedTest
+    @MethodSource("trailingZeroTestProvider")
+    public void givenTestStrings_whenRemoveTrailingZeroesWithSubstring_thenReturnWithoutTrailingZeroes(String input, String expected) {
+        // given
+
+        // when
+        String result = RemoveLeadingAndTrailingZeroes.removeTrailingZeroesWithSubstring(input);
+
+        // then
+        assertThat(result).isEqualTo(expected);
+    }
+
+    @ParameterizedTest
+    @MethodSource("leadingZeroTestProvider")
+    public void givenTestStrings_whenRemoveLeadingZeroesWithApacheCommonsStripStart_thenReturnWithoutLeadingZeroes(String input, String expected) {
+        // given
+
+        // when
+        String result = RemoveLeadingAndTrailingZeroes.removeLeadingZeroesWithApacheCommonsStripStart(input);
+
+        // then
+        assertThat(result).isEqualTo(expected);
+    }
+
+    @ParameterizedTest
+    @MethodSource("trailingZeroTestProvider")
+    public void givenTestStrings_whenRemoveTrailingZeroesWithApacheCommonsStripEnd_thenReturnWithoutTrailingZeroes(String input, String expected) {
+        // given
+
+        // when
+        String result = RemoveLeadingAndTrailingZeroes.removeTrailingZeroesWithApacheCommonsStripEnd(input);
+
+        // then
+        assertThat(result).isEqualTo(expected);
+    }
+
+    @ParameterizedTest
+    @MethodSource("leadingZeroTestProvider")
+    public void givenTestStrings_whenRemoveLeadingZeroesWithGuavaTrimLeadingFrom_thenReturnWithoutLeadingZeroes(String input, String expected) {
+        // given
+
+        // when
+        String result = RemoveLeadingAndTrailingZeroes.removeLeadingZeroesWithGuavaTrimLeadingFrom(input);
+
+        // then
+        assertThat(result).isEqualTo(expected);
+    }
+
+    @ParameterizedTest
+    @MethodSource("trailingZeroTestProvider")
+    public void givenTestStrings_whenRemoveTrailingZeroesWithGuavaTrimTrailingFrom_thenReturnWithoutTrailingZeroes(String input, String expected) {
+        // given
+
+        // when
+        String result = RemoveLeadingAndTrailingZeroes.removeTrailingZeroesWithGuavaTrimTrailingFrom(input);
+
+        // then
+        assertThat(result).isEqualTo(expected);
+    }
+
+    @ParameterizedTest
+    @MethodSource("leadingZeroTestProvider")
+    public void givenTestStrings_whenRemoveLeadingZeroesWithRegex_thenReturnWithoutLeadingZeroes(String input, String expected) {
+        // given
+
+        // when
+        String result = RemoveLeadingAndTrailingZeroes.removeLeadingZeroesWithRegex(input);
+
+        // then
+        assertThat(result).isEqualTo(expected);
+    }
+
+    @ParameterizedTest
+    @MethodSource("trailingZeroTestProvider")
+    public void givenTestStrings_whenRemoveTrailingZeroesWithRegex_thenReturnWithoutTrailingZeroes(String input, String expected) {
+        // given
+
+        // when
+        String result = RemoveLeadingAndTrailingZeroes.removeTrailingZeroesWithRegex(input);
+
+        // then
+        assertThat(result).isEqualTo(expected);
+    }
+
+}

java-strings-2/src/test/java/com/baeldung/string/repetition/SubstringRepetitionUnitTest.java

@@ -0,0 +1,45 @@
+package com.baeldung.string.repetition;
+
+import static com.baeldung.string.repetition.SubstringRepetition.*;
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class SubstringRepetitionUnitTest {
+
+    private String validString = "aa";
+    private String validStringTwo = "ababab";
+    private String validStringThree = "baeldungbaeldung";
+
+    private String invalidString = "aca";
+    private String invalidStringTwo = "ababa";
+    private String invalidStringThree = "baeldungnonrepeatedbaeldung";
+
+    @Test
+    public void givenValidStrings_whenCheckIfContainsOnlySubstrings_thenReturnsTrue() {
+        assertTrue(containsOnlySubstrings(validString));
+        assertTrue(containsOnlySubstrings(validStringTwo));
+        assertTrue(containsOnlySubstrings(validStringThree));
+    }
+
+    @Test
+    public void givenInvalidStrings_whenCheckIfContainsOnlySubstrings_thenReturnsFalse() {
+        assertFalse(containsOnlySubstrings(invalidString));
+        assertFalse(containsOnlySubstrings(invalidStringTwo));
+        assertFalse(containsOnlySubstrings(invalidStringThree));
+    }
+
+    @Test
+    public void givenValidStrings_whenCheckEfficientlyIfContainsOnlySubstrings_thenReturnsTrue() {
+        assertTrue(containsOnlySubstringsEfficient(validString));
+        assertTrue(containsOnlySubstringsEfficient(validStringTwo));
+        assertTrue(containsOnlySubstringsEfficient(validStringThree));
+    }
+
+    @Test
+    public void givenInvalidStrings_whenCheckEfficientlyIfContainsOnlySubstrings_thenReturnsFalse() {
+        assertFalse(containsOnlySubstringsEfficient(invalidString));
+        assertFalse(containsOnlySubstringsEfficient(invalidStringTwo));
+        assertFalse(containsOnlySubstringsEfficient(invalidStringThree));
+    }
+}

java-strings-2/src/test/java/com/baeldung/string/reverse/ReverseStringExamplesUnitTest.java

@@ -0,0 +1,70 @@
+package com.baeldung.string.reverse;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class ReverseStringExamplesUnitTest {
+
+    private static final String STRING_INPUT = "cat";
+    private static final String STRING_INPUT_REVERSED = "tac";
+    private static final String SENTENCE = "The quick brown fox jumps over the lazy dog";
+    private static final String REVERSED_WORDS_SENTENCE = "dog lazy the over jumps fox brown quick The";
+
+    @Test
+    public void whenReverseIsCalled_ThenCorrectStringIsReturned() {
+        String reversed = ReverseStringExamples.reverse(STRING_INPUT);
+        String reversedNull = ReverseStringExamples.reverse(null);
+        String reversedEmpty = ReverseStringExamples.reverse(StringUtils.EMPTY);
+
+        assertEquals(STRING_INPUT_REVERSED, reversed);
+        assertEquals(null, reversedNull);
+        assertEquals(StringUtils.EMPTY, reversedEmpty);
+    }
+
+    @Test
+    public void whenReverseUsingStringBuilderIsCalled_ThenCorrectStringIsReturned() throws Exception {
+        String reversed = ReverseStringExamples.reverseUsingStringBuilder(STRING_INPUT);
+        String reversedNull = ReverseStringExamples.reverseUsingStringBuilder(null);
+        String reversedEmpty = ReverseStringExamples.reverseUsingStringBuilder(StringUtils.EMPTY);
+
+        assertEquals(STRING_INPUT_REVERSED, reversed);
+        assertEquals(null, reversedNull);
+        assertEquals(StringUtils.EMPTY, reversedEmpty);
+    }
+
+    @Test
+    public void whenReverseUsingApacheCommonsIsCalled_ThenCorrectStringIsReturned() throws Exception {
+        String reversed = ReverseStringExamples.reverseUsingApacheCommons(STRING_INPUT);
+        String reversedNull = ReverseStringExamples.reverseUsingApacheCommons(null);
+        String reversedEmpty = ReverseStringExamples.reverseUsingApacheCommons(StringUtils.EMPTY);
+
+        assertEquals(STRING_INPUT_REVERSED, reversed);
+        assertEquals(null, reversedNull);
+        assertEquals(StringUtils.EMPTY, reversedEmpty);
+    }
+
+    @Test
+    public void whenReverseTheOrderOfWordsIsCalled_ThenCorrectStringIsReturned() {
+        String reversed = ReverseStringExamples.reverseTheOrderOfWords(SENTENCE);
+        String reversedNull = ReverseStringExamples.reverseTheOrderOfWords(null);
+        String reversedEmpty = ReverseStringExamples.reverseTheOrderOfWords(StringUtils.EMPTY);
+
+        assertEquals(REVERSED_WORDS_SENTENCE, reversed);
+        assertEquals(null, reversedNull);
+        assertEquals(StringUtils.EMPTY, reversedEmpty);
+    }
+
+    @Test
+    public void whenReverseTheOrderOfWordsUsingApacheCommonsIsCalled_ThenCorrectStringIsReturned() {
+        String reversed = ReverseStringExamples.reverseTheOrderOfWordsUsingApacheCommons(SENTENCE);
+        String reversedNull = ReverseStringExamples.reverseTheOrderOfWordsUsingApacheCommons(null);
+        String reversedEmpty = ReverseStringExamples.reverseTheOrderOfWordsUsingApacheCommons(StringUtils.EMPTY);
+
+        assertEquals(REVERSED_WORDS_SENTENCE, reversed);
+        assertEquals(null, reversedNull);
+        assertEquals(StringUtils.EMPTY, reversedEmpty);
+    }
+
+}

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

@@ -0,0 +1,70 @@
+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());
+    }
+}

java-strings-2/src/test/java/com/baeldung/stringduplicates/RemoveDuplicateFromStringUnitTest.java

@@ -0,0 +1,82 @@
+package com.baeldung.stringduplicates;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class RemoveDuplicateFromStringUnitTest {
+
+    private final static String STR1 = "racecar";
+    private final static String STR2 = "J2ee programming";
+    private final static String STR_EMPTY = "";
+
+    private RemoveDuplicateFromString removeDuplicateFromString;
+
+    @Before
+    public void executedBeforeEach() {
+        removeDuplicateFromString = new RemoveDuplicateFromString();
+    }
+
+
+    @Test
+    public void whenUsingCharArray_DuplicatesShouldBeRemovedWithoutKeepingStringOrder() {
+        String str1 = removeDuplicateFromString.removeDuplicatesUsingCharArray(STR1);
+        String str2 = removeDuplicateFromString.removeDuplicatesUsingCharArray(STR2);
+        String strEmpty = removeDuplicateFromString.removeDuplicatesUsingCharArray(STR_EMPTY);
+        Assert.assertEquals("", strEmpty);
+        Assert.assertEquals("ecar", str1);
+        Assert.assertEquals("J2e poraming", str2);
+    }
+
+    @Test
+    public void whenUsingLinkedHashSet_DuplicatesShouldBeRemovedAndItKeepStringOrder() {
+        String str1 = removeDuplicateFromString.removeDuplicatesUsinglinkedHashSet(STR1);
+        String str2 = removeDuplicateFromString.removeDuplicatesUsinglinkedHashSet(STR2);
+
+        String strEmpty = removeDuplicateFromString.removeDuplicatesUsinglinkedHashSet(STR_EMPTY);
+        Assert.assertEquals("", strEmpty);
+        Assert.assertEquals("race", str1);
+        Assert.assertEquals("J2e progamin", str2);
+    }
+
+    @Test
+    public void whenUsingSorting_DuplicatesShouldBeRemovedWithoutKeepingStringOrder() {
+        String str1 = removeDuplicateFromString.removeDuplicatesUsingSorting(STR1);
+        String str2 = removeDuplicateFromString.removeDuplicatesUsingSorting(STR2);
+
+        String strEmpty = removeDuplicateFromString.removeDuplicatesUsingSorting(STR_EMPTY);
+        Assert.assertEquals("", strEmpty);
+        Assert.assertEquals("acer", str1);
+        Assert.assertEquals(" 2Jaegimnopr", str2);
+    }
+
+    @Test
+    public void whenUsingHashSet_DuplicatesShouldBeRemovedWithoutKeepingStringOrder() {
+        String str1 = removeDuplicateFromString.removeDuplicatesUsingHashSet(STR1);
+        String str2 = removeDuplicateFromString.removeDuplicatesUsingHashSet(STR2);
+        String strEmpty = removeDuplicateFromString.removeDuplicatesUsingHashSet(STR_EMPTY);
+        Assert.assertEquals("", strEmpty);
+        Assert.assertEquals("arce", str1);
+        Assert.assertEquals(" pa2regiJmno", str2);
+    }
+
+    @Test
+    public void whenUsingIndexOf_DuplicatesShouldBeRemovedWithoutKeepingStringOrder() {
+        String str1 = removeDuplicateFromString.removeDuplicatesUsingIndexOf(STR1);
+        String str2 = removeDuplicateFromString.removeDuplicatesUsingIndexOf(STR2);
+        String strEmpty = removeDuplicateFromString.removeDuplicatesUsingIndexOf(STR_EMPTY);
+        Assert.assertEquals("", strEmpty);
+        Assert.assertEquals("ecar", str1);
+        Assert.assertEquals("J2e poraming", str2);
+    }
+
+    @Test
+    public void whenUsingJava8_DuplicatesShouldBeRemovedAndItKeepStringOrder() {
+        String str1 = removeDuplicateFromString.removeDuplicatesUsingDistinct(STR1);
+        String str2 = removeDuplicateFromString.removeDuplicatesUsingDistinct(STR2);
+        String strEmpty = removeDuplicateFromString.removeDuplicatesUsingDistinct(STR_EMPTY);
+        Assert.assertEquals("", strEmpty);
+        Assert.assertEquals("race", str1);
+        Assert.assertEquals("J2e progamin", str2);
+    }
+}

java-strings-2/src/test/resources/.gitignore

@@ -0,0 +1,13 @@
+*.class
+
+#folders#
+/target
+/neoDb*
+/data
+/src/main/webapp/WEB-INF/classes
+*/META-INF/*
+
+# Packaged files #
+*.jar
+*.war
+*.ear