Java字母升序判断代码BUG排查：特殊输入判断错误求助

Hey there! Let's break down what's causing those two wrong results and fix your code step by step.

The Core Problem: Case Sensitivity & Logic Mix-Up #

Your code compares characters directly using their raw ASCII values, which don't account for case differences. In Java, all uppercase letters have lower ASCII values than lowercase ones (e.g., 'X' is 88, while 'a' is 97). This is why your test cases are failing:

1. Xabcdefg: When comparing 'X' and 'a', 88 < 97, so your code doesn't flag it as out of order. But ignoring case, 'X' is equivalent to 'x', which is way larger than 'a'—so this should be marked as not ascending.
2. abcdefgX: Comparing 'g' (103) and 'X' (88), your code sees 103 > 88 and flags it as out of order. But ignoring case, 'X' is 'x' (120), which is larger than 'g'—so this should be ascending.

On top of that, your loop logic has a small issue: it keeps checking characters even after finding a pair that's out of order, which could lead to duplicate output (though it didn't show up in your test cases).

Fixed Code #

Here's the corrected version with explanations:

public class Main {
    public static void main(String[] args) {
        String word = BIO.getString();
        while (!word.equals("END")) {
            // Convert the entire string to lowercase to ignore case differences
            String lowerCaseWord = word.toLowerCase();
            char[] arr = lowerCaseWord.toCharArray();
            boolean isAscending = true; // Start with the assumption the word is ascending

            for (int i = 0; i < arr.length - 1; i++) {
                // Compare lowercase characters to avoid case bias
                if (arr[i] > arr[i+1]) {
                    isAscending = false;
                    break; // No need to check further once we find a out-of-order pair
                }
            }

            // Print the result based on our check
            if (isAscending) {
                System.out.printf("%-10s letters in ascending order %n", word);
            } else {
                System.out.printf("%-10s letters not in ascending order %n", word);
            }

            word = BIO.getString();
        }
    }
}

Key Changes Explained #

• Unified Case Comparison: Using toLowerCase() ensures we're comparing apples to apples—all characters are evaluated in lowercase, so case no longer affects the result.
• Clearer Logic & Efficiency: We renamed inorder to isAscending (more intuitive naming) and set it to true initially. As soon as we find a pair that breaks the ascending rule, we set it to false and break the loop (no need to check the rest of the characters).
• Cleaner Output: Added %n to the printf statement to ensure each result prints on a new line.

Testing the Fixed Code #

Running your test cases now will give the correct results:

• Xabcdefg → letters not in ascending order
• abcdefgX → letters in ascending order
  All other test cases will also work as expected!

As someone who's been coding Java for 4 months, you're already doing great—catching these edge cases is all part of learning the ins and outs of the language.

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