Comprehensive Analysis of Specific Word Detection in Java Strings: From Basic Methods to Best Practices

Core Methods for String Detection

In Java programming, detecting whether a string contains a specific substring is a common operational requirement. Developers typically face multiple choices, each with its unique implementation mechanism and applicable scenarios. Understanding these differences is crucial for writing efficient and robust code.

Deep Analysis of the indexOf() Method

According to the best practice answer, using the indexOf() method with case conversion is a reliable and flexible strategy. The core principle of this method involves traversing the source string to find the first occurrence of the target substring. When indexOf() returns -1, it indicates no match was found; otherwise, it returns the starting index of the match.

String sentence = "Check this answer and you can find the keyword with this code";
String search = "keyword";

if (sentence.toLowerCase().indexOf(search.toLowerCase()) != -1) {
    System.out.println("I found the keyword");
} else {
    System.out.println("not found");
}

The key advantage of this implementation is achieving case-insensitive matching through the toLowerCase() method. Developers can adjust case handling strategies based on specific requirements, such as using toUpperCase() or maintaining original case for exact matching.

Application Scenarios of the contains() Method

Although the contains() method is syntactically more concise, its internal implementation actually calls the indexOf() method. As seen from Java documentation, the contains() method encapsulates indexOf(), providing a more intuitive boolean return interface.

In Android development environments, special attention must be paid to variable scope when using contains(). Particularly when referencing external variables within anonymous inner classes, these variables must be declared as final or exist as class member variables. Here is a corrected example:

// Proper variable declaration
final String d = getInputString();
final TextView c = findViewById(R.id.output_text);

a.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View arg0) {
        if (d != null && d.contains("Hey")) {
            c.setText("OUTPUT: SUCCESS!");
        } else {
            c.setText("OUTPUT: FAIL!");
        }
    }
});

Performance and Robustness Considerations

In practical applications, beyond functional correctness, performance and exception handling must also be considered. For large strings or high-frequency call scenarios, directly using indexOf() may offer slight performance advantages over contains(), as it avoids additional object encapsulation overhead.

More importantly, null value checking is essential to prevent NullPointerException. Regardless of the method used, input strings should be verified as non-null before invocation:

public boolean containsWord(String source, String word) {
    if (source == null || word == null) {
        return false;
    }
    return source.toLowerCase().contains(word.toLowerCase());
}

Advanced Application Scenarios

For more complex matching requirements, such as word boundary detection or regular expression matching, consider using Pattern and Matcher classes. These classes provide more powerful pattern matching capabilities, but with correspondingly greater performance overhead.

When processing user input or external data, character encoding and special character handling must also be considered. For example, HTML entities like <br> appearing as literals in text require proper escaping to avoid being parsed as HTML tags.

Conclusion and Best Practices

When selecting string detection methods, readability, performance, and specific requirements should be comprehensively considered. For most cases, using the contains() method with appropriate case handling and null value checking is the optimal choice. In scenarios requiring finer control or performance optimization, directly using the indexOf() method may be more suitable.

Regardless of the method chosen, clear documentation and comprehensive test cases should be written to ensure code runs correctly under various boundary conditions. By understanding the underlying implementations and applicable scenarios of these methods, developers can make more informed technical choices and write more robust and efficient Java applications.