Java实现Excel式索引转列名：优化方法的逻辑问题求助

Let's walk through why your current betterGetColumnName is misbehaving, then fix it while sticking strictly to Java 1.5's rules (no StringBuilder—only char, String, and integers allowed).

What's Breaking Your Current Code? #

You've got two critical logic flaws here:

1. Incorrect index reduction: Instead of properly calculating each "digit" of the Excel column name, you're just subtracting 26 every loop. That's why 258 turns into that long string IHGFEDCBAX—you're looping way too many times, appending a new letter each time instead of moving to the next higher place value.
2. Backwards string building: You're adding each new character to the end of the string, but Excel column names are built from the highest place value to the lowest. Since we calculate the lowest digit first, we need to prepend each new character to the front of the string to get the correct order.

How Excel Column Names Actually Work #

Excel uses a twist on base-26 numbering: there's no zero value. Here's the breakdown:

• 1 → A, 2 → B, ..., 26 → Z
• 27 → AA, 28 → AB, ..., 52 → AZ
• 53 → BA, and so on.

To convert an index correctly, we need to shift the index to a 0-based range first (so 1 becomes 0, 26 becomes 25) to use standard modulus and division operations.

Fixed Code #

Here's the corrected method that passes all your test cases and complies with Java 1.5 constraints:

public String betterGetColumnName(int index) {
    String result = "";
    while (index > 0) {
        // Shift to 0-based to handle Z (26) correctly
        index--;
        // Get the offset for the current character (0 = A, 25 = Z)
        int charOffset = index % 26;
        // Convert offset to the corresponding uppercase letter
        char currentChar = (char) ('A' + charOffset);
        // Prepend the character to build the string in the right order
        result = currentChar + result;
        // Move to the next higher place value
        index = index / 26;
    }
    return result;
}

Let's Test It Against Your Examples #

• 30: 30 → 29 → 29%26=3 → 'D'; index becomes 1. Then 1→0 → 0%26=0→'A'; result is AD ✔️
• 56: 56→55 →55%26=3→'D'; index becomes 2. 2→1→1%26=1→'B'; result is BD ✔️
• 120: 120→119 →119%26=15→'P'; index becomes4.4→3→3%26=3→'D'; result is DP (note: Your original getColumnName has a typo here—standard Excel uses DP for 120, while DR corresponds to 122)
• 258:258→257→257%26=23→'X'; index becomes9.9→8→8%26=8→'I'; result is IX (your original array has a quirk here—standard Excel uses IX for 258, IZ is 260)

Even with the original array's typos, this method correctly implements standard Excel column naming, which is the intended behavior.

Why This Works for Java 1.5 #

• No fancy classes like StringBuilder—just basic String concatenation (even if it's less efficient, it's fully allowed in Java 1.5).
• All operations use only char, String, and integers as required by your environment.
• The loop logic correctly handles multi-letter columns without redundant calculations.

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