如何编写Java方法跳过所有空白符、换行符及注释？

Hey there! Let's refine your code for skipping whitespace and comments—your current implementation works, but we can make it cleaner, more readable, and easier to maintain by breaking the logic into focused, sequential steps.

First, let's look at the key improvements we can make:

• Split the logic into distinct phases: skip whitespace first, then handle comments (instead of mixing all conditions in one loop)
• Avoid unnecessary string concatenation (judging individual chars is more efficient and clear)
• Make EOF checks more explicit at each step
• Use more intuitive method naming and modular logic

Here's an optimized version:

private void skipWhitespaceAndComments() {
    char currentChar;
    final char EOF_CHAR = (char) 65535;

    while (true) {
        // Phase 1: Skip all consecutive whitespace characters
        currentChar = reader.charPrefetch();
        if (currentChar == EOF_CHAR) {
            return;
        }
        
        // Add '\t' or '\r' to this condition if you need to handle more whitespace types
        if (currentChar == ' ' || currentChar == '\n') {
            reader.readChar(); // Advance past the whitespace
            continue;
        }

        // Phase 2: Check for comment starts
        if (currentChar == '/') {
            char nextChar = reader.charPrefetch(2);
            
            // Handle single-line comment (//)
            if (nextChar == '/') {
                // Advance past both '/' characters
                reader.readChar();
                reader.readChar();
                
                // Skip until newline or EOF
                while (true) {
                    currentChar = reader.charPrefetch();
                    if (currentChar == EOF_CHAR || currentChar == '\n') {
                        break;
                    }
                    reader.readChar();
                }
            } 
            // Handle multi-line comment (/* ... */)
            else if (nextChar == '*') {
                // Advance past both '/' and '*'
                reader.readChar();
                reader.readChar();
                
                // Skip until we hit "*/"
                while (true) {
                    currentChar = reader.charPrefetch();
                    if (currentChar == EOF_CHAR) {
                        return; // Per your note: no syntax errors, so this won't trigger
                    }
                    
                    // Check if we've reached the comment end
                    if (currentChar == '*' && reader.charPrefetch(2) == '/') {
                        reader.readChar(); // Advance past '*'
                        reader.readChar(); // Advance past '/'
                        break;
                    }
                    
                    reader.readChar();
                }
            } 
            // Not a comment—exit the loop
            else {
                break;
            }
        } 
        // Not whitespace or comment—exit the loop
        else {
            break;
        }
    }
}

Why this works better: #

1. Clear separation of concerns: We first eliminate all whitespace, then check for and handle comments. This linear flow is much easier to follow and debug.
2. No unnecessary string operations: Instead of pre-fetching two chars into a string, we check individual characters directly—this is more efficient and avoids edge cases with string handling.
3. Explicit control flow: Each comment type has its own dedicated block, making it simple to modify or extend (e.g., adding support for other comment styles later).
4. Robust EOF handling: We check for EOF at critical points to ensure we don't process invalid characters.

Quick extra tips: #

• If you need to handle more whitespace types (like tabs or carriage returns), just add them to the initial whitespace check condition.
• You could extract the whitespace check into a tiny helper method (e.g., private boolean isWhitespace(char c)) to make the main loop even cleaner.
• Renaming the method to skipWhitespaceAndComments follows common naming conventions for parser utilities, making its purpose instantly clear to other developers.

内容的提问来源于stack exchange，提问作者Gor