Java Programming Common String Manipulations Complete Guide

Java Programming Common String Manipulations

1. Creating Strings

Strings can be created in various ways in Java, using either object literal syntax or the new keyword. Here’s an example:

• Object Literal: String str1 = "Hello";
• Using new: String str2 = new String("World");

Important Info:

• Object literals are interned by default. This means that if two string literals have the same sequence of characters, they actually refer to the same memory location.
• Using the new keyword explicitly creates a new string object in heap memory, which can be useful if you need a mutable string.

2. Concatenation

Concatenating strings combines two or more strings into one. This can be done using the + operator or the concat() method.

String str1 = "Hello";
String str2 = "World";
String result = str1 + " " + str2; // Result: Hello World
String resultConcat = str1.concat(str2); // Result: HelloWorld (no space)

Important Info:

• The + operator is generally more readable and easier to use.
• concat() does not accept null values and will throw a NullPointerException. Always ensure all concatenated strings are non-null.

3. Substring Extraction

Extracting substrings from within a string is achieved using the substring() method. It comes in two forms: substring(int beginIndex) and substring(int beginIndex, int endIndex).

String message = "Hello World";
String subMessage1 = message.substring(6);      // Result: World
String subMessage2 = message.substring(0, 5);    // Result: Hello

Important Info:

• The endIndex parameter is exclusive. message.substring(beginIndex, endIndex) captures characters from beginIndex to endIndex - 1.
• Index values should not exceed the length of the string to prevent StringIndexOutOfBoundsException.

4. Length Calculation

The length() method returns the number of characters in the string.

String message = "Hello World";
int length = message.length();   // Result: 11

Important Info:

• length() method returns a primitive int, not Integer. Avoid unnecessary autoboxing for performance.

5. Case Conversion

Java provides toLowerCase() and toUpperCase() methods to convert the case of strings.

String message = "Hello World";
String lowerCase = message.toLowerCase();    // Result: hello world
String upperCase = message.toUpperCase();    // Result: HELLO WORLD

Important Info:

• Consider locale when performing case conversions with special characters or accented letters, e.g., str.toLowerCase(Locale.ENGLISH).

6. Trim Whitespace

The trim() method removes leading and trailing white spaces (spaces, tabs, newlines).

String messageWithPadding = "   Hello World   ";
String trimmedMessage = messageWithPadding.trim();   // Result: Hello World

Important Info:

• trim() does not affect internal white spaces. Use regex-based manipulation for such cases, e.g., str.replaceAll("\\s+", "") to remove all whitespaces.

7. Comparison

Strings can be compared lexicographically using the equals(), equalsIgnoreCase(), compareTo(), and compareToIgnoreCase() methods.

String str1 = "Hello";
String str2 = "hello";
boolean equalsCase = str1.equals(str2);                // Result: false
boolean equalsNoCase = str1.equalsIgnoreCase(str2);    // Result: true
int compare = str1.compareTo(str2);                    // Result: -32 (negative because H < h in ASCII)
int compareCaseInsensitive = str1.compareToIgnoreCase(str2); // Result: 0

Important Info:

• equals() considers case.
• compareTo() and compareToIgnoreCase() return an integer indicating the relationship between the compared strings.

8. Replacement

Replacing parts of a string is handled by the replace(), replaceAll(), and replaceFirst() methods. replaceAll() and replaceFirst() use regex.

String message = "Hello World";
String replaced = message.replace('l', 'a');         // Result: Heao Worad
String replacedAll = message.replaceAll("l", "a");     // Result: Heao Worad
String replacedFirst = message.replaceFirst("l", "a"); // Result: Heao World

Important Info:

• replaceAll() and replaceFirst() offer more flexibility but can be slower due to regex processing.
• Use replace() for simple character replacements unless patterns are required.

9. Searching for Substrings

Searching for substrings is performed using indexOf(), lastIndexOf(), contains(), startsWith(), and endsWith() methods.

String message = "Hello World";
int index1 = message.indexOf('o');                // Returns index of first occurrence: 4
int index2 = message.lastIndexOf('o');            // Returns index of last occurrence: 7
boolean containsO = message.contains("o");        // Result: true
boolean startsWithHello = message.startsWith("Hello"); // Result: true
boolean endsWithWorld = message.endsWith("World");   // Result: true

Important Info:

• indexOf() and lastIndexOf() return -1 if the substring is not found.
• contains(), startsWith(), and endsWith() return boolean values based on substring presence.

10. Splitting Strings

Splitting a string into an array of substrings is accomplished with the split() method which uses regex.

String message = "Hello World";
String[] words = message.split(" ");    // Splits on spaces, Result: ["Hello", "World"]

Important Info:

• The split() method uses regex, so be cautious when using special characters.
• Handle edge cases like multiple consecutive delimiters or strings starting/ending with delimiters.

11. Reversing Strings

Reversing a string requires converting it to a StringBuilder or StringBuffer and then utilizing the reverse() method.

String message = "Hello World";
StringBuilder sb = new StringBuilder(message);
String reversed = sb.reverse().toString();    // Result: dlroW olleH

Important Info:

• StringBuilder is preferred over StringBuffer due to better performance since StringBuilder is not thread-safe.
• Use toString() to convert StringBuilder back to a regular string after manipulation.

12. Formatted Strings

Creating formatted strings is done with String.format() or using formatted literals (%s %d...).

String name = "Alice";
int age = 25;
String formatted = String.format("Name: %s, Age: %d", name, age); // Result: Name: Alice, Age: 25
// Alternately with formatted literals in Java 15+
String anotherFormatted = "Name: %s, Age: %d".formatted(name, age); // Result: Name: Alice, Age: 25

Important Info:

• %s stands for string, %d for decimal, %f for floating-point numbers, etc.
• Be consistent with argument types passed to the format specifiers.

13. Empty and Null Checks

Null-safe checks involve verifying whether a string is either null or empty.

String str1 = null;
String str2 = "";
boolean isEmpty = str1 == null || str1.isEmpty(); // Safe check for null and empty: true
boolean isEmpty2 = str2.isEmpty();                 // Check only for empty: true

Important Info:

• Regular str.isEmpty() throws NullPointerException if str is null. Always check for nullity before checking emptiness.
• Utilize libraries like Apache Commons Lang which provide convenient StringUtils class functions for such checks.

14. Checking Patterns

Pattern matching with strings utilizes matches(), startsWith(), and endsWith() methods or regular expressions.

String dateStr = "2024-01-01";
boolean isValidDate = dateStr.matches("\\d{4}-\\d{2}-\\d{2}"); // Check if matches YYYY-MM-DD pattern: true

Important Info:

• Regular expressions are powerful but can become complex. Write clear and maintainable patterns.
• Use online tools or libraries for advanced pattern analysis and debugging.

15. Joining Strings

Joining multiple strings into one can be done efficiently using String.join() or Collectors.joining() in Java Streams.

List<String> fruits = Arrays.asList("Apple", "Banana", "Cherry");
String joinedFruits1 = String.join(", ", fruits); // Result: Apple, Banana, Cherry
String joinedFruits2 = fruits.stream().collect(Collectors.joining("; ")); // Result: Apple; Banana; Cherry

Important Info:

• String.join() is straightforward and easy to use.
• Streams provide greater flexibility when joining with other data transformations.

16. Padding Strings

Padding strings involves adding spaces (or any specified character) to make their length uniform. While there's no direct method, this can be achieved using loops or third-party libraries.

String message = "Hi";
String paddedMessage = String.format("%5s", message); // Right padded, Result:     Hi
String leftPaddedMessage = String.format("%-5s", message); // Left padded, Result: Hi    

Important Info:

• Use String.format() or libraries like Apache Commons Lang for padding.
• Consider whether padding should happen at the beginning (left) or the end (right).

17. Removing Specific Characters

Removing specific characters from strings involves using replaceAll() with appropriate regex patterns or loops.

String message = "Hello123";
String cleanedMessage = message.replaceAll("\\d", ""); // Remove digits, Result: Hello

Important Info:

• replaceAll("\\d", "") effectively removes all digits from a string.
• Regular expressions provide flexibility but can be costly in terms of performance for large-scale operations.

18. Repeating Strings

To repeat a string multiple times, consider using String.repeat() added in Java 11.

String symbol = "*";
String repeatedSymbol = symbol.repeat(5); // Repeat '*' 5 times, Result: *****

Important Info:

• String.repeat() makes code concise and readable.
• Avoid excessive repetition which may lead to memory issues.