Research on Methods for Checking if a String Starts with One of Multiple Prefixes in Java

Problem Background and Requirement Analysis

In practical Java development, there is often a need to determine whether a string starts with one of multiple possible prefixes. This requirement is common in text processing, data filtering, and business logic judgments. For example, when processing date strings, it may be necessary to check if a string starts with abbreviations of weekdays such as "Mon", "Tues", "Wed", etc.

Basic Method: Chained startsWith() Calls

The most straightforward approach is to use chained logical judgments with the startsWith() method of the String class. This method is simple and intuitive, suitable for situations with a small number of prefixes.

String newStr4 = strr.split("2012")[0];
if (newStr4.startsWith("Mon") || newStr4.startsWith("Tues") || 
    newStr4.startsWith("Wed") || newStr4.startsWith("Thurs") || 
    newStr4.startsWith("Fri")) {
    str4.add(newStr4);
}

The advantage of this method lies in its clear code logic, making it easy to understand and maintain. When the number of prefixes to check is limited, this is the optimal choice. However, when there are many prefixes, the code becomes verbose and difficult to maintain.

Regular Expression Solution

Using regular expressions can handle multiple prefix matching more concisely. Java's matches() method, combined with regular expressions, provides powerful pattern matching capabilities.

if (newStr4.matches("(Mon|Tues|Wed|Thurs|Fri).*")) {
    str4.add(newStr4);
}

The regular expression (Mon|Tues|Wed|Thurs|Fri).* means: match strings that start with "Mon", "Tues", "Wed", "Thurs", or "Fri", followed by any characters. The .* indicates matching zero or more arbitrary characters.

The advantage of this method is concise code, particularly suitable for scenarios with complex prefix patterns or requiring flexible matching. However, attention should be paid to the performance overhead of regular expressions, which should be used cautiously in performance-sensitive scenarios.

Modern Programming: Stream API Application

The Stream API introduced in Java 8 provides support for functional programming and can elegantly handle collection operations. In scenarios checking multiple prefixes, Stream's anyMatch() method is very applicable.

import java.util.stream.Stream;

if (Stream.of("Mon", "Tues", "Wed", "Thurs", "Fri")
         .anyMatch(s -> newStr4.startsWith(s))) {
    str4.add(newStr4);
}

This method converts the prefix collection into a Stream, then uses the anyMatch() method to check if any prefix matches. The code is more functional, easy to extend and maintain. This approach is particularly applicable when prefixes need to be dynamically generated or modified at runtime.

Performance Analysis and Best Practices

Different methods vary in performance:

• Chained startsWith() calls: Best performance, as it directly calls native methods without additional object creation overhead
• Regular expressions: Relatively poor performance, as it requires compiling regular expression patterns and performing pattern matching
• Stream API: Moderate performance, creates Stream objects but is well-optimized on modern JVMs

In actual development, it is recommended to choose the appropriate method based on specific scenarios:

• Use chained startsWith() calls when the number of prefixes is small and fixed
• Use regular expressions when complex pattern matching is needed
• Use Stream API when prefix lists need dynamic generation or functional programming style is preferred

Extended Applications and Considerations

Beyond basic string prefix checking, these methods can be extended to more complex scenarios:

// Handle case-insensitive matching
if (Stream.of("mon", "tues", "wed", "thurs", "fri")
         .anyMatch(s -> newStr4.toLowerCase().startsWith(s))) {
    str4.add(newStr4);
}

// Handle empty strings and edge cases
if (newStr4 != null && !newStr4.isEmpty() && 
    Stream.of("Mon", "Tues", "Wed", "Thurs", "Fri")
          .anyMatch(s -> newStr4.startsWith(s))) {
    str4.add(newStr4);
}

In practical applications, it is also necessary to consider edge cases such as null pointer exceptions and string length to ensure code robustness.