Java：用于加密的更轻的代码

我正试图得到一个程序，用塞萨尔的密码对消息进行加密，这涉及到用字母替换字符串的每个字符，字母的代码是被替换字母的代码加上3。例如，如果字母是

A

，则必须将其替换为

D

，因为D的代码是A加3的代码。这些字母区分大小写。我想到的代码使用了一个非常重的开关结构，我想知道，您是否可以帮助我使它更直接

以下是我用于加密方法的代码：

public class Util 
{   

  public static String Encript(String stringa)

  {

        char[] stringaArray=stringa.toCharArray();


    for (int i =0; i<stringaArray.length; i++)
    {
        switch (stringaArray[i])
        {
                case 'a':
                        stringaArray[i]=('D');
                        break;
                case 'b':
                    stringaArray[i]='E';
                    break;
                case 'c':
                    stringaArray[i]='F';
                case 'd':
                    stringaArray[i]='G';
                    break;
                case 'e':
                    stringaArray[i]='H';
                    break;
                case 'f':
                    stringaArray[i]='I';
                    break;
                case 'g':
                    stringaArray[i]='J';
                    break;
                case 'h':
                    stringaArray[i]='K';
                    break;
                case 'i':
                    stringaArray[i]='L';
                    break;
                case 'j':
                    stringaArray[i]='M';
                    break;
                case 'k':
                    stringaArray[i]='N';
                    break;
                case 'l':
                    stringaArray[i]='O';
                    break;
                case 'm':
                    stringaArray[i]='P';
                    break;
                case 'n':
                    stringaArray[i]='Q';
                    break;
                case 'o':
                    stringaArray[i]='R';
                    break;
                case 'p':
                    stringaArray[i]='S';
                    break;
                case 'q':
                    stringaArray[i]='T';
                    break;
                case 'r':
                    stringaArray[i]='U';
                    break;
                case 's':
                    stringaArray[i]='V';
                    break;
                case 't':
                    stringaArray[i]='W';
                    break;
                case 'u':
                    stringaArray[i]='X';
                    break;
                case 'v':
                    stringaArray[i]='Y';
                    break;
                case 'w':
                    stringaArray[i]='Z';
                    break;
                case 'x':
                    stringaArray[i]='A';
                    break;
                case 'y':
                    stringaArray[i]='B';
                    break;
                case 'z':
                    stringaArray[i]='C';
                    break;

        }

  }
    String encripted= new String(stringaArray);
    return encripted;


 }

}

下面是一个测试用例的示例：

Test case:
aBxyE    //Input
dEabH    //Output

提前谢谢你

科奥尔/#Zruog 您可以迭代

字符串中的字符

，我还可以传入

键

偏移量。创建一个

StringBuilder

，并在执行整数加法和强制转换后追加每个字符。大概

public static String encrypt(String msg, int key) {
    StringBuilder sb = new StringBuilder();
    for (char ch : msg.toCharArray()) {
        char c = (char) (ch + key);
        sb.append(c);
    }
    return sb.toString();
}

用凯撒密码解密很简单；您可以使用

密钥的负值调用encrypt

public static String decrypt(String msg, int key) {
    return encrypt(msg, -key);
}

我用一个例子来测试我的例子

public static void main(String[] args) {
    String msg = encrypt("Hello, World", 3);
    System.out.println(msg);
    System.out.println(decrypt(msg, 3));
}

---

最后，正如其他人所指出的，Caesar密码是非常不安全的（因为字母频率不受干扰，在现代意义上它是微不足道的）。

此代码将锯切一个字符，另一个字符相隔三个字符，如字母表中所定义：

public class Util
{

    private final static String ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

    public static String encript(String stringa)

    {
        char[] stringaArray = stringa.toCharArray();

        for (int i =0; i<stringaArray.length; i++) {

            char c = stringaArray[i];
            int index = ALPHABET.indexOf(c);

            if(index <0)
             {
                continue ; //if c does not appear in ALPHABET
            }
                                    // for example c is *, leave it unchanged
            if((index +3) >= ALPHABET.length() ) {
                index = index - ALPHABET.length();
            }

            stringaArray[i] = ALPHABET.charAt(index+3);
        }

        String encripted= new String(stringaArray);
        return encripted;
    }

}

公共类Util
{
私有最终静态字符串字母表=“abcdefghijklmnopqrstuvxyzabcdefghijklmnopqrstuvxyz”；
公共静态字符串encript（字符串stringa）
{
char[]stringaArray=stringa.toCharArray（）；
对于（int i=0；i，以下是我为您的程序编写的简短而高效的代码：

import java.io.*;
import java.util.*;

public class Solution {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //N is length of string
        int N = Integer.parseInt(br.readLine());
        //Reading string Input
        String str = br.readLine();
        //K is the key to rotate characters in the string
        //In your case K = 3
        int K = Integer.parseInt(br.readLine());
        K %= 26;    //Incase K is greater than 25
        //Main [tag:algorithm]
        for(int i = 0; i < N; i++){
            char c = str.charAt(i);
            if(c >= 65 && c <= 90){
                c += K;
                if(c > 90){
                    c = (char)(c - 90 + 64);
                }
            }
            if(c >= 97 && c <= 122){
                c += K;
                if(c > 122){
                    c = (char)(c - 122 + 96);
                }
            }
            System.out.print(c);
        }
    }
}

import java.io.*；
导入java.util.*；
公共类解决方案{
公共静态void main（字符串[]args）引发IOException{
BufferedReader br=新的BufferedReader（新的InputStreamReader（System.in））；
//N是字符串的长度
int N=Integer.parseInt（br.readLine（））；
//读取字符串输入
字符串str=br.readLine（）；
//K是在字符串中旋转字符的键
//在你的例子中，K=3
int K=Integer.parseInt（br.readLine（））；
K%=26；//如果K大于25
//Main[标记：算法]
对于（int i=0；i=65&&c 90）{
c=（字符）（c-90+64）；
}
}
如果（c>=97&&c 122）{
c=（字符）（c-122+96）；
}
}
系统输出打印（c）；
}
}
}

我在做
k=k%26
因为如果
k=26
它会打印同一个字母，如果
k=27
角色只会旋转
1
时间等等。
是的，这样做很糟糕。你的问题是什么？你刚刚发布了一堆代码，然后感谢了我们？@LukePark我想知道你能不能请告诉我一种写itA
HashMap
的更轻松的方法是一种快速的方法。循环遍历每个字符并检索与该字符对应的值作为密钥。此外，我相信你已经知道了这一点，但在生产中使用此密码是一个很大的禁忌。不要这样做。@LukePark是的，我只是在玩，看看它有多有效cient它可以得到，谢谢你的想法，我是一个新手，所以我没有想到这一点，说实话…是的，当然，但我不是要在未来的项目中使用它，我只是想让它尽可能有效地工作。非常感谢！这是一个优雅的解决方案。但它并没有限制字母表使用字符的范围。this可以是优点也可以是缺点，这取决于OP的需要。你认为使用ASCII码是一种有效的方法吗？比如用int替换c，然后再减法29（我需要交换的字母位置之间的差异），然后返回设置
stringaArray[I]=（char）的值c
？看看Elliott Frisch的解决方案。你可以做char+int。如果需要的话，最好试着发布另一个问题。
import java.io.*;
import java.util.*;

public class Solution {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //N is length of string
        int N = Integer.parseInt(br.readLine());
        //Reading string Input
        String str = br.readLine();
        //K is the key to rotate characters in the string
        //In your case K = 3
        int K = Integer.parseInt(br.readLine());
        K %= 26;    //Incase K is greater than 25
        //Main [tag:algorithm]
        for(int i = 0; i < N; i++){
            char c = str.charAt(i);
            if(c >= 65 && c <= 90){
                c += K;
                if(c > 90){
                    c = (char)(c - 90 + 64);
                }
            }
            if(c >= 97 && c <= 122){
                c += K;
                if(c > 122){
                    c = (char)(c - 122 + 96);
                }
            }
            System.out.print(c);
        }
    }
}