Java凯撒密码：如何正确处理和保留加密文本中的空格

// 原始代码片段中，处理字符的循环部分
for (int i = 0; i < message.length(); i++) {
    // 如果字符是空格，则直接跳过当前循环的剩余部分，不进行加密处理
    if (message.charAt(i) == ' ') continue;

    int charPos = Alphabet.indexOf(message.charAt(i));
    int encryptPos = (shift + charPos) % 26;
    // ... 后续的字符替换逻辑
}

public class CaesarCipher {
    // 假设 Alphabet 仅包含小写字母，或根据实际需求调整
    // 如果 Alphabet 包含空格，且空格不参与移位，则更应先处理空格
    public static final String Alphabet = "abcdefghijklmnopqrstuvwxyz"; // 修正为只包含字母

    String cipher(String message, int shift) {
        String encryptedMessage = "";

        for (int i = 0; i < message.length(); i++) {
            char currentChar = message.charAt(i);

            // 检查当前字符是否为空格
            if (currentChar == ' ') {
                encryptedMessage += ' '; // 如果是空格，则直接添加到结果字符串
                continue; // 然后继续处理下一个字符，跳过后续的加密逻辑
            }

            // 对于非空格字符，执行凯撒密码的加密逻辑
            int charPos = Alphabet.indexOf(currentChar);

            // 确保字符在 Alphabet 中存在，否则可以保留原字符或抛出错误
            if (charPos == -1) {
                encryptedMessage += currentChar; // 如果字符不在 Alphabet 中，保留原样
                continue;
            }

            // 计算加密后的字符位置
            // 注意：这里使用 Alphabet.length() 来确保模运算的基数与字母表长度匹配
            // 如果 Alphabet 只包含26个字母，则 % 26 是正确的
            int encryptPos = (shift + charPos) % Alphabet.length(); 

            // 处理负数结果（当 shift 为负数时可能出现）
            if (encryptPos < 0) {
                encryptPos = Alphabet.length() + encryptPos;
            }

            char replaceChar = Alphabet.charAt(encryptPos);
            encryptedMessage += replaceChar;
        }

        return encryptedMessage;
    }
}

import java.util.Scanner;

public class CaesarCipherHW {
    // 建议Alphabet只包含需要移位的字符，空格等特殊字符单独处理
    public static final String Alphabet = "abcdefghijklmnopqrstuvwxyz"; 

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter a message: ");
        String message = sc.nextLine();
        message = message.toLowerCase(); // 将消息转换为小写

        System.out.println("Enter shift value (between 0-25): ");
        int shift = sc.nextInt();

        CaesarCipher cipherTool = new CaesarCipher(); // 实例化内部类

        System.out.println("1- Encrypt" +
                            "\n2- Decrypt" +
                            "\n3- Exit" +
                            "\nChoose your option: ");
        int option = sc.nextInt();

        String resultMessage = "";
        if (option == 1) {
            resultMessage = cipherTool.cipher(message, shift);
            System.out.println("Encrypted Message: " + resultMessage);
        } else if (option == 2) {
            // 解密通常是加密的逆操作，即使用负的偏移量
            resultMessage = cipherTool.cipher(message, -shift); 
            System.out.println("Decrypted Message: " + resultMessage);
        } else if (option == 3) {
            System.out.println("Exiting...");
        } else {
            System.out.println("Invalid option.");
        }
        sc.close();
    }

    public static class CaesarCipher {
        String cipher(String message, int shift) {
            String encryptedMessage = "";

            for (int i = 0; i < message.length(); i++) {
                char currentChar = message.charAt(i);

                // 优先处理空格：如果当前字符是空格，直接添加到结果并跳过后续加密逻辑
                if (currentChar == ' ') {
                    encryptedMessage += ' ';
                    continue;
                }

                int charPos = Alphabet.indexOf(currentChar);

                // 如果字符不在定义的字母表中，则保留原字符
                if (charPos == -1) {
                    encryptedMessage += currentChar;
                    continue;
                }

                // 计算加密后的新位置
                // 这里的模运算基数应与Alphabet的实际长度匹配，通常是26个字母
                int encryptPos = (shift + charPos) % Alphabet.length(); 

                // 处理负数结果，确保索引在有效范围内
                if (encryptPos < 0) {
                    encryptPos = Alphabet.length() + encryptPos;
                }

                char replaceChar = Alphabet.charAt(encryptPos);
                encryptedMessage += replaceChar;
            }
            return encryptedMessage;
        }
    }
}