Essential Java String Operations and Methods Guide

Java String Reverse

Reversing a string in Java can be done in several ways. Here are a few common methods:

Method 1: Using `StringBuilder`

The simplest way to reverse a string in Java is by using the StringBuilder class, which has a built-in reverse() method.

public class StringReverse {
    public static void main(String[] args) {
        String original = "Hello, World!";
        String reversed = new StringBuilder(original).reverse().toString();
        System.out.println("Reversed String: " + reversed);
    }
}

Method 2: Using a Loop

You can manually reverse a string by iterating through it from the end to the beginning.

public class StringReverse {
    public static void main(String[] args) {
        String original = "Hello, World!";
        String reversed = "";

        for (int i = original.length() - 1; i >= 0; i--) {
            reversed += original.charAt(i);
        }

        System.out.println("Reversed String: " + reversed);
    }
}

Method 3: Using Recursion

You can also reverse a string using a recursive function.

public class StringReverse {
    public static void main(String[] args) {
        String original = "Hello, World!";
        String reversed = reverse(original);
        System.out.println("Reversed String: " + reversed);
    }

    public static String reverse(String str) {
        if (str.isEmpty()) {
            return str;
        }
        return reverse(str.substring(1)) + str.charAt(0);
    }
}

Method 4: Using Character Array

You can convert the string into a character array, reverse the array, and then create a new string from it.

public class StringReverse {
    public static void main(String[] args) {
        String original = "Hello, World!";
        char[] charArray = original.toCharArray();
        int left = 0;
        int right = charArray.length - 1;

        while (left < right) {
            char temp = charArray[left];
            charArray[left] = charArray[right];
            charArray[right] = temp;
            left++;
            right--;
        }

        String reversed = new String(charArray);
        System.out.println("Reversed String: " + reversed);
    }
}

Summary

You can choose any of the above methods based on your preference or specific requirements. The StringBuilder approach is the most concise and efficient for reversing strings in Java.

Java String Split

In Java, you can split a string into an array of substrings using the split() method from the String class. This method takes a regular expression as an argument and divides the string based on matches of that regular expression.

Basic Syntax

String[] split(String regex)

Example Usage

Here’s a simple example to demonstrate how to use the split() method:

public class Main {
    public static void main(String[] args) {
        String text = "apple,banana,cherry,date";
        
        // Split the string by comma
        String[] fruits = text.split(",");
        
        // Print the resulting array
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

Output

apple
banana
cherry
date

Using Limit Parameter

You can also specify a limit on the number of substrings to be returned. The syntax for this is:

String[] split(String regex, int limit)

If limit is positive, the resulting array will have at most limit elements.
If limit is zero, the resulting array can have any number of elements, but trailing empty strings will be discarded.
If limit is negative, there is no limit on the number of elements.

Example with Limit

public class Main {
    public static void main(String[] args) {
        String text = "apple,banana,cherry,date";
        
        // Split the string by comma with a limit of 3
        String[] fruits = text.split(",", 3);
        
        // Print the resulting array
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

Output

apple
banana
cherry,date

Notes

Regular Expressions: The split() method uses regular expressions, so if you need to split by special characters (like ., ?, *, etc.), you need to escape them.

For example, to split by a period:

String text = "one.two.three";
String[] parts = text.split("\\.");

Performance: Be aware that using regex can be less efficient than other string manipulation methods if you're dealing with simple delimiters.
Empty Strings: If the string starts or ends with the delimiter, the resulting array may contain empty strings.

By understanding these aspects, you can effectively split strings in Java according to your needs.

Java String length

In Java, you can determine the length of a string using the length() method from the String class. This method returns an integer representing the number of characters in the string.

Syntax

int length()

Example Usage

Here’s a simple example to demonstrate how to use the length() method:

public class Main {
    public static void main(String[] args) {
        String text = "Hello, World!";
        
        // Get the length of the string
        int length = text.length();
        
        // Print the length
        System.out.println("The length of the string is: " + length);
    }
}

Output

The length of the string is: 13

Important Notes

Character Count: The length() method counts all characters, including spaces and punctuation. For example, in the string "Hello, World!", the space and the punctuation mark are included in the count.
Unicode Characters: The length() method counts the number of char values in the string, which may not always correspond to the number of Unicode characters. For example, some Unicode characters (like emoji) may be represented by multiple char values. To handle such cases, you can use the codePointCount() method.
```
int codePointCount = text.codePointCount(0, text.length());
```
Null Strings: If you try to call length() on a null string reference, it will throw a NullPointerException. Always ensure that the string is not null before calling methods on it.

Example with Null Check

public class Main {
    public static void main(String[] args) {
        String text = null;

        // Check if the string is null before getting the length
        if (text != null) {
            System.out.println("The length of the string is: " + text.length());
        } else {
            System.out.println("The string is null.");
        }
    }
}

Output

The string is null.

Using the length() method is straightforward and essential for many string operations in Java.

StringBuilder and StringBuffer

StringBuilder and StringBuffer are both classes in Java that are used to create mutable strings, which means you can modify the contents of the string without creating a new object. However, they have some key differences:

StringBuilder

Performance: StringBuilder is faster than StringBuffer because it is not synchronized. This makes it suitable for use in a single-threaded environment where thread safety is not a concern.
Usage: Ideal for scenarios where you need to manipulate strings frequently and do not require thread safety.

StringBuffer

Thread Safety: StringBuffer is synchronized, meaning it is thread-safe and can be used safely in multi-threaded environments. However, this synchronization comes with a performance cost.
Usage: Best for scenarios where multiple threads might be accessing and modifying the same string.

Example Usage

// Using StringBuilder
StringBuilder sb = new StringBuilder("Hello");
sb.append(" World");
System.out.println(sb.toString()); // Output: Hello World

// Using StringBuffer
StringBuffer sbf = new StringBuffer("Hello");
sbf.append(" World");
System.out.println(sbf.toString()); // Output: Hello World

Summary

Use StringBuilder for better performance in single-threaded applications.
Use StringBuffer when you need thread safety.

Choosing between the two depends on your specific requirements regarding performance and thread safety.

Java String Comparable

In Java, the Comparable interface is used to define a natural ordering for objects of a class. When it comes to strings, the String class already implements the Comparable<String> interface. This allows you to compare two strings based on their lexicographical order.

Implementing Comparable

If you want to create your own class that implements Comparable, you need to override the compareTo method. Here's a simple example:

class Person implements Comparable<Person> {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public int compareTo(Person other) {
        // Compare by name
        return this.name.compareTo(other.name);
        // If you want to compare by age, you could use:
        // return Integer.compare(this.age, other.age);
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

Using Comparable with Strings

Here's how you can compare strings using the compareTo method:

public class StringComparison {
    public static void main(String[] args) {
        String str1 = "Apple";
        String str2 = "Banana";

        int result = str1.compareTo(str2);

        if (result < 0) {
            System.out.println(str1 + " comes before " + str2);
        } else if (result > 0) {
            System.out.println(str1 + " comes after " + str2);
        } else {
            System.out.println(str1 + " is equal to " + str2);
        }
    }
}

Explanation of `compareTo`

The compareTo method returns:
- A negative integer if the calling string is lexicographically less than the argument string.
- Zero if the calling string is equal to the argument string.
- A positive integer if the calling string is lexicographically greater than the argument string.

Example Output

For the example above, the output will be:

Apple comes before Banana

Summary

Strings in Java implement Comparable<String>, allowing for natural ordering.
You can create your own classes that implement Comparable to define custom ordering.
The compareTo method is central to this functionality, providing a way to compare objects.

Java String Concat

In Java, you can concatenate strings in several ways. Here are some common methods:

1. Using the `+` Operator

The simplest way to concatenate strings is to use the + operator.

String str1 = "Hello, ";
String str2 = "World!";
String result = str1 + str2; // "Hello, World!"

2. Using `concat()` Method

The String class has a concat() method that can also be used to concatenate strings.

String str1 = "Hello, ";
String str2 = "World!";
String result = str1.concat(str2); // "Hello, World!"

3. Using `StringBuilder`

For more efficient concatenation, especially in loops, you can use StringBuilder.

StringBuilder sb = new StringBuilder();
sb.append("Hello, ");
sb.append("World!");
String result = sb.toString(); // "Hello, World!"

4. Using `StringBuffer`

Similar to StringBuilder, but StringBuffer is synchronized and thread-safe.

StringBuffer sb = new StringBuffer();
sb.append("Hello, ");
sb.append("World!");
String result = sb.toString(); // "Hello, World!"

5. Using `String.join()`

If you have an array or a collection of strings, you can use String.join().

String[] words = {"Hello", "World"};
String result = String.join(", ", words); // "Hello, World"

6. Using `String.format()`

You can use String.format() for formatted concatenation.

String str1 = "Hello";
String str2 = "World";
String result = String.format("%s, %s!", str1, str2); // "Hello, World!"

Example Program

Here’s a simple example demonstrating some of these methods:

public class StringConcatExample {
    public static void main(String[] args) {
        String str1 = "Hello, ";
        String str2 = "World!";

        // Using +
        String result1 = str1 + str2;

        // Using concat()
        String result2 = str1.concat(str2);

        // Using StringBuilder
        StringBuilder sb = new StringBuilder();
        sb.append(str1).append(str2);
        String result3 = sb.toString();

        // Printing results
        System.out.println(result1);
        System.out.println(result2);
        System.out.println(result3);
    }
}

Summary

Use + for simple concatenations.
Use concat() for a method-based approach.
Use StringBuilder or StringBuffer for performance in loops.
Use String.join() for joining multiple strings.
Use String.format() for formatted strings.

Choose the method based on your specific use case!

Java String Substring

In Java, the String class provides a method called substring() that allows you to extract a portion of a string. There are two main overloads of this method:

substring(int beginIndex): This method returns a new string that starts from the specified beginIndex to the end of the string.
substring(int beginIndex, int endIndex): This method returns a new string that starts from the beginIndex and extends to the character at endIndex - 1. The character at endIndex is not included.

Examples

Here are some examples to illustrate how to use the substring() method:

public class SubstringExample {
    public static void main(String[] args) {
        String originalString = "Hello, World!";

        // Using substring(int beginIndex)
        String sub1 = originalString.substring(7);
        System.out.println(sub1); // Output: World!

        // Using substring(int beginIndex, int endIndex)
        String sub2 = originalString.substring(0, 5);
        System.out.println(sub2); // Output: Hello

        // Edge cases
        String sub3 = originalString.substring(0, 0);
        System.out.println(sub3); // Output: (empty string)

        // Using substring with the same begin and end index
        String sub4 = originalString.substring(5, 5);
        System.out.println(sub4); // Output: (empty string)

        // Attempting to use indices out of bounds will throw an exception
        // Uncommenting the following line will cause a StringIndexOutOfBoundsException
        // String sub5 = originalString.substring(0, 20);
    }
}

Important Notes

Indexing: The indices are zero-based. This means the first character of the string is at index 0.
Out of Bounds: If you provide an index that is out of bounds (negative or greater than the string length), a StringIndexOutOfBoundsException will be thrown.
Empty Strings: Calling substring() with the same beginIndex and endIndex will return an empty string.

Feel free to ask if you have any more questions or need further examples!

Java String Replace ReplaceAll

In Java, the String class provides two methods for replacing characters or substrings: replace() and replaceAll(). Here's a brief overview of each method:

`replace()`

Usage: Replaces each occurrence of a specified character or substring with a new character or substring.

Signature:

String replace(CharSequence target, CharSequence replacement)

Example:

String original = "Hello World";
String modified = original.replace("World", "Java");
System.out.println(modified); // Output: Hello Java

`replaceAll()`

Usage: Replaces each substring of the string that matches the given regular expression with a new substring.

Signature:

String replaceAll(String regex, String replacement)

Example:

String original = "Hello 123, hello 456";
String modified = original.replaceAll("\\d+", "number");
System.out.println(modified); // Output: Hello number, hello number

Key Differences

Functionality:
- replace() is used for literal replacements (character or substring).
- replaceAll() is used when you need to replace based on a regular expression pattern.
Performance:
- replace() can be more efficient for simple replacements since it does not involve regex processing.

Example of Both

Here’s a combined example to illustrate both methods:

public class StringReplaceExample {
    public static void main(String[] args) {
        String original = "Java is fun. Java is powerful.";

        // Using replace()
        String replaced = original.replace("Java", "Python");
        System.out.println(replaced); // Output: Python is fun. Python is powerful.

        // Using replaceAll()
        String replacedAll = original.replaceAll("Java", "C++");
        System.out.println(replacedAll); // Output: C++ is fun. C++ is powerful.
    }
}

Summary

Use replace() for straightforward character or substring replacements.
Use replaceAll() when you need to match patterns using regular expressions.

Java String to Numeric

In Java, you can convert a String to a numeric type (like int, double, etc.) using various methods. Here are some common ways to do this:

1. Converting to `int`

You can use Integer.parseInt() for converting a String to an int:

String numberString = "123";
int number = Integer.parseInt(numberString);
System.out.println(number); // Output: 123

2. Converting to `double`

For converting a String to a double, use Double.parseDouble():

String doubleString = "123.45";
double doubleValue = Double.parseDouble(doubleString);
System.out.println(doubleValue); // Output: 123.45

3. Converting to `float`

For converting to a float, use Float.parseFloat():

String floatString = "123.45";
float floatValue = Float.parseFloat(floatString);
System.out.println(floatValue); // Output: 123.45

4. Handling Exceptions

When converting, it’s a good practice to handle possible exceptions that may arise if the string is not a valid number:

String invalidNumberString = "abc";

try {
    int number = Integer.parseInt(invalidNumberString);
} catch (NumberFormatException e) {
    System.out.println("Invalid number format: " + e.getMessage());
}

5. Using `BigInteger` and `BigDecimal`

For very large numbers or precise decimal values, use BigInteger or BigDecimal:

import java.math.BigInteger;
import java.math.BigDecimal;

String bigIntString = "12345678901234567890";
BigInteger bigInteger = new BigInteger(bigIntString);
System.out.println(bigInteger); // Output: 12345678901234567890

String bigDecimalString = "12345.67890";
BigDecimal bigDecimal = new BigDecimal(bigDecimalString);
System.out.println(bigDecimal); // Output: 12345.67890

Summary

Use Integer.parseInt() for integers.
Use Double.parseDouble() for doubles.
Use Float.parseFloat() for floats.
Use BigInteger or BigDecimal for larger or more precise numbers.
Always handle NumberFormatException to manage invalid formats.

Java String Format

In Java, the String.format() method is used to create formatted strings. It allows you to format strings in a way similar to printf in C or other languages. The method takes a format string and a variable number of arguments, allowing you to embed values into the string.

Basic Syntax

String formattedString = String.format(format, arguments);

Format Specifiers

Here are some common format specifiers:

%s: String
%d: Integer
%f: Floating-point number
%x: Hexadecimal integer
%t: Date/Time
%%: Literal percent sign

Examples

Formatting Strings

String name = "Alice";
int age = 30;
String formatted = String.format("My name is %s and I am %d years old.", name, age);
System.out.println(formatted);  // Output: My name is Alice and I am 30 years old.

Formatting Floating-Point Numbers

double pi = Math.PI;
String formattedPi = String.format("Value of pi: %.2f", pi);
System.out.println(formattedPi);  // Output: Value of pi: 3.14

Padding and Alignment

int number = 42;
String padded = String.format("|%10d|%-10d|", number, number);
System.out.println(padded);  // Output: |        42|42        |

Formatting Dates

import java.util.Date;

Date now = new Date();
String formattedDate = String.format("Current date: %tF", now);
System.out.println(formattedDate);  // Output: Current date: 2024-09-13 (or current date)

Locale-Specific Formatting

You can also format strings based on a specific locale:

import java.util.Locale;

double amount = 12345.6789;
String formattedAmount = String.format(Locale.US, "Amount: $%,.2f", amount);
System.out.println(formattedAmount);  // Output: Amount: $12,345.68

Conclusion

The String.format() method is a powerful tool for creating formatted strings in Java. It provides flexibility and control over how data is presented, making it useful for creating user-friendly output.

Java String Contains

In Java, you can check if a string contains a specific sequence of characters using the contains() method from the String class. This method returns true if the specified sequence of characters is found within the string, and false otherwise.

Syntax

boolean contains(CharSequence sequence)

Example

Here's a simple example to illustrate how to use the contains() method:

public class Main {
    public static void main(String[] args) {
        String str = "Hello, welcome to the world of Java!";
        
        // Check if the string contains "Java"
        if (str.contains("Java")) {
            System.out.println("The string contains 'Java'.");
        } else {
            System.out.println("The string does not contain 'Java'.");
        }

        // Check for a substring that does not exist
        if (str.contains("Python")) {
            System.out.println("The string contains 'Python'.");
        } else {
            System.out.println("The string does not contain 'Python'.");
        }
    }
}

Output

The string contains 'Java'.
The string does not contain 'Python'.

Notes

The contains() method is case-sensitive. For example, "hello".contains("Hello") will return false.
If you need a case-insensitive check, you can convert both strings to the same case (e.g., using toLowerCase() or toUpperCase()), like this:

if (str.toLowerCase().contains("java")) {
    // ...
}

This method is straightforward and efficient for checking the presence of substrings in Java strings.

Java String IndexOf

In Java, the indexOf method is used to find the index of a specified character or substring within a string. It returns the index of the first occurrence of the specified value, or -1 if the value is not found.

Syntax

Finding a character:

int index = string.indexOf(char ch);

Finding a substring:

int index = string.indexOf(String str);

Finding a substring starting from a specific index:

int index = string.indexOf(String str, int fromIndex);

Finding a character starting from a specific index:

int index = string.indexOf(char ch, int fromIndex);

Example

Here's a simple example demonstrating the use of indexOf:

public class IndexOfExample {
    public static void main(String[] args) {
        String str = "Hello, world!";

        // Finding the index of a character
        int indexChar = str.indexOf('o');
        System.out.println("Index of 'o': " + indexChar); // Output: 4

        // Finding the index of a substring
        int indexSubstring = str.indexOf("world");
        System.out.println("Index of 'world': " + indexSubstring); // Output: 7

        // Finding the index of a substring starting from a specific index
        int indexFrom = str.indexOf("o", 5);
        System.out.println("Index of 'o' starting from index 5: " + indexFrom); // Output: 8

        // If the character or substring is not found
        int notFound = str.indexOf("Java");
        System.out.println("Index of 'Java': " + notFound); // Output: -1
    }
}

Notes

The index is zero-based, meaning the first character of the string is at index 0.
If the specified character or substring is not found, indexOf returns -1.
You can use lastIndexOf to find the last occurrence of a character or substring.

Java String null, Empty, Blank

In Java, understanding the differences between null, empty strings, and blank strings is crucial for effective string handling. Here's a breakdown of each:

1. `null`

A null string means that the string reference does not point to any object. It indicates the absence of a value.

Example:

String str = null;

2. Empty String

An empty string is a valid string object that contains no characters. Its length is zero.
It is represented as "".

Example:

String str = "";
System.out.println(str.length()); // Outputs: 0

3. Blank String

A blank string is a string that may contain whitespace characters (spaces, tabs, etc.) but has no visible characters. It is not the same as an empty string.

Example:

String str = "   "; // Contains spaces
System.out.println(str.length()); // Outputs: 3

Checking for Null, Empty, or Blank

You can use the following methods to check for these conditions:

Null Check:

if (str == null) {
    System.out.println("String is null");
}

Empty Check:

if (str != null && str.isEmpty()) {
    System.out.println("String is empty");
}

Blank Check:

if (str != null && str.trim().isEmpty()) {
    System.out.println("String is blank");
}

Using `StringUtils` from Apache Commons Lang

If you're using the Apache Commons Lang library, you can simplify checks for empty or blank strings:

Check for Empty:

StringUtils.isEmpty(str); // Returns true if str is null or empty

Check for Blank:

StringUtils.isBlank(str); // Returns true if str is null, empty, or only whitespace

Summary

null: No reference to a string object.
Empty: A string object with zero length ("").
Blank: A string that may contain only whitespace characters.

Understanding these distinctions helps in writing robust Java applications, especially when dealing with user input or data parsing.

Java String As Array

In Java, you can treat a String as an array of characters. Each character in the string can be accessed using its index, similar to how you would access elements in an array. Here’s how you can do it:

Converting a String to a Character Array

You can convert a String to a character array using the toCharArray() method:

public class StringAsArray {
    public static void main(String[] args) {
        String str = "Hello, World!";
        
        // Convert String to char array
        char[] charArray = str.toCharArray();
        
        // Print each character
        for (char c : charArray) {
            System.out.println(c);
        }
    }
}

Accessing Characters by Index

You can also access individual characters in a String using the charAt() method:

public class StringIndexAccess {
    public static void main(String[] args) {
        String str = "Hello, World!";
        
        // Accessing characters by index
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            System.out.println("Character at index " + i + ": " + c);
        }
    }
}

Example: Modifying a String as an Array

Keep in mind that String objects in Java are immutable, meaning you cannot change them directly. However, you can create a new String based on modifications to a character array:

public class ModifyString {
    public static void main(String[] args) {
        String str = "Hello, World!";
        
        // Convert to char array
        char[] charArray = str.toCharArray();
        
        // Modify the character array
        charArray[7] = 'J';  // Change 'W' to 'J'
        
        // Create a new String from the modified char array
        String modifiedStr = new String(charArray);
        
        System.out.println("Modified String: " + modifiedStr);
    }
}

Summary

Use toCharArray() to convert a String to a character array.
Use charAt(index) to access individual characters.
Remember that String is immutable, so modifications require creating a new String.

Java String Method

Here are some common Java String methods:

length() - Returns the length of the string.
charAt(int index) - Returns the character at the specified index.
substring(int beginIndex) - Returns a substring from the specified index to the end.
substring(int beginIndex, int endIndex) - Returns a substring from the specified beginIndex to endIndex.
indexOf(String str) - Returns the index of the first occurrence of the specified substring.
lastIndexOf(String str) - Returns the index of the last occurrence of the specified substring.
equals(Object obj) - Compares two strings for content equality.
equalsIgnoreCase(String anotherString) - Compares two strings, ignoring case considerations.
toLowerCase() - Converts all characters in the string to lowercase.
toUpperCase() - Converts all characters in the string to uppercase.
trim() - Removes leading and trailing whitespace.
replace(char oldChar, char newChar) - Replaces occurrences of a specified character with a new character.
replaceAll(String regex, String replacement) - Replaces each substring of the string that matches the given regular expression with the given replacement.
split(String regex) - Splits the string around matches of the given regular expression.
contains(CharSequence sequence) - Checks if the string contains the specified sequence of characters.
startsWith(String prefix) - Checks if the string starts with the specified prefix.
endsWith(String suffix) - Checks if the string ends with the specified suffix.
isEmpty() - Checks if the string is empty (length is 0).
valueOf(Object obj) - Returns the string representation of the specified object.

These methods provide a wide range of functionalities for string manipulation in Java.

Java String Guide

Comprehensive guide on Java String operations and methods

Table of Contents

Java String Reverse

Method 1: Using StringBuilder

Method 2: Using a Loop

Method 3: Using Recursion

Method 4: Using Character Array

Summary

Java String Split

Basic Syntax

Example Usage

Output

Using Limit Parameter

Example with Limit

Output

Notes

Java String length

Syntax

Example Usage

Output

Important Notes

Example with Null Check

Output

StringBuilder and StringBuffer

StringBuilder

StringBuffer

Example Usage

Summary

Java String Comparable

Implementing Comparable

Using Comparable with Strings

Explanation of compareTo

Example Output

Summary

Java String Concat

1. Using the + Operator

2. Using concat() Method

3. Using StringBuilder

4. Using StringBuffer

5. Using String.join()

6. Using String.format()

Example Program

Summary

Java String Substring

Examples

Important Notes

Java String Replace ReplaceAll

replace()

replaceAll()

Key Differences

Example of Both

Summary

Java String to Numeric

1. Converting to int

2. Converting to double

3. Converting to float

4. Handling Exceptions

5. Using BigInteger and BigDecimal

Summary

Java String Format

Basic Syntax

Format Specifiers

Examples

Locale-Specific Formatting

Conclusion

Java String Contains

Syntax

Example

Output

Notes

Java String IndexOf

Syntax

Example

Notes

Java String null, Empty, Blank

1. null

2. Empty String

3. Blank String

Checking for Null, Empty, or Blank

Method 1: Using `StringBuilder`

Explanation of `compareTo`

1. Using the `+` Operator

2. Using `concat()` Method

3. Using `StringBuilder`

4. Using `StringBuffer`

5. Using `String.join()`

6. Using `String.format()`

`replace()`

`replaceAll()`

1. Converting to `int`

2. Converting to `double`

3. Converting to `float`

5. Using `BigInteger` and `BigDecimal`

1. `null`

Using `StringUtils` from Apache Commons Lang