String Manipulation and Regular Expressions

In this lesson, we’ll explore how Java handles string manipulation and regular expressions, comparing these concepts to their Python counterparts. As a Python developer, you’ll find both similarities and differences in how Java approaches these fundamental programming tasks.

String Class and Immutability

In Java, strings are objects of the String class, which is immutable. This is similar to Python’s strings, which are also immutable. Let’s look at how we create and manipulate strings in Java:

// Java
String greeting = "Hello, World!";
String upperCase = greeting.toUpperCase();
System.out.println(upperCase); // Prints: HELLO, WORLD!
System.out.println(greeting);  // Prints: Hello, World!

As you can see, methods like toUpperCase() return a new string rather than modifying the original. This behavior is consistent with Python’s string methods.

StringBuilder for Efficient String Concatenation

When you need to perform multiple string concatenations, Java provides the StringBuilder class for better performance. This is similar to Python’s io.StringIO or list concatenation for building large strings:

// Java
StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" ");
sb.append("World");
String result = sb.toString();
System.out.println(result); // Prints: Hello World

Common String Methods

Java’s String class offers many methods similar to Python’s string methods. Here’s a comparison of some common operations:

Operation	Java	Python
Length	str.length()	len(str)
Substring	str.substring(start, end)	str[start:end]
Index of	str.indexOf("substring")	str.index("substring")
Replace	str.replace("old", "new")	str.replace("old", "new")
Split	str.split("delimiter")	str.split("delimiter")
Trim whitespace	str.trim()	str.strip()

Example usage in Java:

// Java
String text = "  Hello, Java!  ";
System.out.println(text.trim());                 // Prints: Hello, Java!
System.out.println(text.substring(2, 7));        // Prints: Hello
System.out.println(text.replace("Java", "World"));  // Prints:   Hello, World!  

Regular Expressions

Java uses the java.util.regex package for working with regular expressions. The main classes you’ll use are Pattern and Matcher. This is different from Python’s re module, but the concepts are similar.

Here’s an example of using regex in Java:

// Java
import java.util.regex.*;

String text = "The quick brown fox jumps over the lazy dog";
Pattern pattern = Pattern.compile("\\b\\w{5}\\b");
Matcher matcher = pattern.matcher(text);

while (matcher.find()) {
    System.out.println("Found: " + matcher.group());
}

This code finds all five-letter words in the text. The output would be:

Found: quick
Found: brown
Found: jumps

In Python, you might achieve the same result using:

# Python
import re

text = "The quick brown fox jumps over the lazy dog"
pattern = r"\b\w{5}\b"

for match in re.finditer(pattern, text):
    print(f"Found: {match.group()}")

String Formatting

Java offers multiple ways to format strings, similar to Python:

1. Printf-style formatting:

// Java
String name = "Alice";
int age = 30;
System.out.printf("Name: %s, Age: %d%n", name, age);

2. String.format() method:

// Java
String formatted = String.format("Name: %s, Age: %d", name, age);
System.out.println(formatted);

These are similar to Python’s %-formatting and the format() method, respectively.

3. String templates (introduced in Java 21):

// Java
String template = STR."Name: \{name}, Age: \{age}";
System.out.println(template);

This is similar to Python’s f-strings, but it’s a relatively new feature in Java.

Conclusion

In this lesson, we’ve explored how Java handles string manipulation and regular expressions. While the syntax and specific classes differ from Python, you’ll find that many concepts are similar. Java’s String class provides a rich set of methods for string operations, and the StringBuilder class offers efficient string concatenation. Regular expressions in Java are handled through the Pattern and Matcher classes, which provide powerful text processing capabilities.

In the next lesson, we’ll dive into exception handling and input/output operations in Java, comparing these crucial aspects of programming to their Python counterparts.

---