Java String Processing: Multiple Approaches to Efficiently Extract the Last Word

Core Method: Combining substring and lastIndexOf

In Java string manipulation, extracting the last word is a common requirement. The simplest and most direct approach involves combining the substring() and lastIndexOf() methods. The core concept is to locate the position of the last space character in the string and then extract all characters following that position.

Implementation Principle and Code Example

The following code demonstrates the complete implementation of this method:

String test = "This is a sentence";
String lastWord = test.substring(test.lastIndexOf(" ") + 1);

This code operates as follows: First, the lastIndexOf(" ") method returns the index position of the last space character in the string. If no space exists, the method returns -1. Then, by adding +1, we skip the space character itself and point to the first character after the space. Finally, the substring() method extracts from that position to the end of the string, yielding the last word.

Handling Edge Cases

In practical applications, several edge cases must be considered:

1. Trailing spaces in the string: If the string ends with a space, lastIndexOf(" ") returns the index of the last space, but substring() may produce an empty string. It is advisable to use the trim() method first to remove leading and trailing spaces.
2. No spaces in the string: When lastIndexOf(" ") returns -1, substring(0) returns the entire string. This is logical, as the entire string constitutes a single word.
3. Multiple consecutive spaces: This method remains effective even if there are multiple spaces between words, since lastIndexOf(" ") only locates the last space position.

Alternative Approach: Using the split Function

An alternative method involves using the split() function:

String test = "This is a sentence";
String[] words = test.split("\\s+");
String lastWord = words.length > 0 ? words[words.length - 1] : "";

This approach splits the string into an array of words using the regular expression \\s+, then retrieves the last element of the array. While more readable, this method may be slightly less performant than the substring approach due to the creation of an array object.

Performance Comparison and Optimization Suggestions

In performance-sensitive scenarios, the combination of substring and lastIndexOf is generally more efficient, as it avoids unnecessary object creation. Some optimization recommendations include:

• Prefer the substring method for strings with known formats
• Clean the string first if it may contain punctuation
• Consider using StringBuilder for multiple string operations

Practical Application Scenarios

The technique of extracting the last word has wide applications in various fields:

1. Log Analysis: Extracting the final error code or status information from log lines
2. Text Processing: Obtaining the last word of a sentence in natural language processing
3. File Parsing: Processing data files separated by spaces

Extended Considerations

While this article primarily addresses scenarios without punctuation, real-world strings may include various punctuation marks. In such cases, regular expressions can be used for more precise matching:

String test = "This is a sentence!";
Pattern pattern = Pattern.compile("\\b\\w+\\b");
Matcher matcher = pattern.matcher(test);
String lastWord = "";
while (matcher.find()) {
    lastWord = matcher.group();
}

This method correctly identifies word boundaries, ignoring the effects of punctuation.