Java字符串实现简单加密解密

提示信息

默默无语-◎

10月09日发表在 Java 编程语言阅读 236 评论 20 | 免费使用 “AI大模型GPT4.0” 提问

以下是一个简单的Java字符串加密解密的实现：

public class StringEncryptorDecryptor {  
    public static String encrypt(String s) {  
        StringBuilder encrypted = new StringBuilder();  
        for (int i = 0; i < s.length(); i++) {  
            char c = s.charAt(i);  
            c += 1; // 将字符的ASCII码值加1  
            encrypted.append(c);  
        }  
        return encrypted.toString();  
    }  
    public static String decrypt(String s) {  
        StringBuilder decrypted = new StringBuilder();  
        for (int i = 0; i < s.length(); i++) {  
            char c = s.charAt(i);  
            c -= 1; // 将字符的ASCII码值减1  
            decrypted.append(c);  
        }  
        return decrypted.toString();  
    }  
    public static void main(String[] args) {  
        String originalString = "Hello World!";  
        String encryptedString = encrypt(originalString);  
        String decryptedString = decrypt(encryptedString);  
        System.out.println("Original string: " + originalString);  
        System.out.println("Encrypted string: " + encryptedString);  
        System.out.println("Decrypted string: " + decryptedString);  
    }  
}

该代码通过将字符串中每个字符的ASCII码值加1来加密字符串，解密则是将ASCII码值减1。运行示例代码会输出以下结果：

Original string: Hello World!  
Encrypted string: Ifmmp!Xpsme"  
Decrypted string: Hello World!

请注意，这只是一个简单的字符串加密解密算法，不适用于真正的安全需求。

遇到难题？ "AI大模型GPT4.0、GPT" 是你的私人解答专家！点击按钮去提问......

默默无语-◎ 赞 | 0

最近一次登录：2024-11-20 22:33:16

暂时还没有签名，请关注我或评论我的文章

20条评论

按时间正序按时间倒序按喜欢排序

流绪

10月14日

这种加密方法仅适用于基本需求，不适合严密的安全场景。

赞 0 回复举报

承诺： @流绪

对于基本的字符串加密需求，确实不容忽视简易方法的局限性。比如，可以考虑使用简单的凯撒密码：

public class CaesarCipher {
    public static String encrypt(String text, int shift) {
        StringBuilder result = new StringBuilder();

        for (char ch : text.toCharArray()) {
            // Encrypt uppercase characters
            if (Character.isUpperCase(ch)) {
                result.append((char) ((ch + shift - 'A') % 26 + 'A'));
            }
            // Encrypt lowercase characters
            else if (Character.isLowerCase(ch)) {
                result.append((char) ((ch + shift - 'a') % 26 + 'a'));
            } else {
                result.append(ch); // Non-alphabetic characters are not changed
            }
        }
        return result.toString();
    }

    public static String decrypt(String text, int shift) {
        return encrypt(text, 26 - shift); // Decrypt is just encrypt with reversed shift
    }

    public static void main(String[] args) {
        String original = "HelloWorld";
        int shift = 3;
        String encrypted = encrypt(original, shift);
        System.out.println("Encrypted: " + encrypted);
        System.out.println("Decrypted: " + decrypt(encrypted, shift));
    }
}

虽然这个方法简单易懂，但是在面对更复杂的安全需求时，可能需要采用更强大的加密算法，如 AES。Java 提供了 javax.crypto 包，可以用于实现更安全的加密方式。有关这些更复杂方案的学习，或者选择合适加密库，可以参考 Java Cryptography Architecture (JCA)。这样可以确保在处理敏感信息时，保障数据的安全性和隐私性。

11月10日回复举报

添加新评论

小铁塔

10月16日

代码样本对初学者非常友好，展示了基本的字符操作。

赞 0 回复举报

无奈对白： @小铁塔

在处理简单的字符串加密与解密时，可以考虑使用字符替换的方法，这样可以有效地展示基本的字符操作。例如，思考利用ASCII码偏移来实现一个简单的凯撒加密。这个方法不仅简单易懂，而且对初学者来说能够增强对字符串操作的理解。

下面是一个简单的示例代码，可以实现字符的加密和解密：

public class SimpleCipher {
    private static final int SHIFT = 3;

    public static String encrypt(String input) {
        StringBuilder encrypted = new StringBuilder();
        for (char c : input.toCharArray()) {
            encrypted.append((char) (c + SHIFT));
        }
        return encrypted.toString();
    }

    public static String decrypt(String encrypted) {
        StringBuilder decrypted = new StringBuilder();
        for (char c : encrypted.toCharArray()) {
            decrypted.append((char) (c - SHIFT));
        }
        return decrypted.toString();
    }

    public static void main(String[] args) {
        String original = "Hello, World!";
        String encrypted = encrypt(original);
        String decrypted = decrypt(encrypted);

        System.out.println("Original: " + original);
        System.out.println("Encrypted: " + encrypted);
        System.out.println("Decrypted: " + decrypted);
    }
}

在这个例子中，encrypt 方法将每个字符的ASCII值偏移3，而 decrypt 方法则将字符偏移回来。初学者可以通过这种简单的加密方式，理解字符编码和解码的原理。同时，这也鼓励探索更复杂的加密算法，如AES或RSA等。

如果想深入了解字符编码与加密的更多内容，可以访问 Java加密/解密教程。这样的学习资源能够提供更广阔的视野和深入的理解。

11月20日回复举报

添加新评论

天之饺子

10月19日

考虑实现简单的加密技术时，理解字符转换和ASCII操作非常重要。

赞 0 回复举报

三日： @天之饺子

理解字符转换和ASCII操作确实是实现简单加密的关键部分。常见的方法包括对字符进行位移，例如使用凯撒密码（Caesar Cipher），这是一种经典的加密技术。以下是一个简单的实现示例：

public class SimpleEncryption {
    public static String encrypt(String input, int shift) {
        StringBuilder result = new StringBuilder();

        for (char i : input.toCharArray()) {
            char shiftedChar = (char) (i + shift);
            result.append(shiftedChar);
        }

        return result.toString();
    }

    public static String decrypt(String input, int shift) {
        StringBuilder result = new StringBuilder();

        for (char i : input.toCharArray()) {
            char shiftedChar = (char) (i - shift);
            result.append(shiftedChar);
        }

        return result.toString();
    }

    public static void main(String[] args) {
        String original = "Hello World!";
        int shift = 3;

        String encrypted = encrypt(original, shift);
        String decrypted = decrypt(encrypted, shift);

        System.out.println("Original: " + original);
        System.out.println("Encrypted: " + encrypted);
        System.out.println("Decrypted: " + decrypted);
    }
}

在这个示例中，字符通过简单的加法和减法进行加密和解密。可以尝试不同的 shift 值来提高加密强度。同时，可以用于学习的资料也值得一看，像关于加密基础知识的网页 GeeksforGeeks 会提供更多的背景信息和示例。

11月20日回复举报

添加新评论

我心有泪

10月28日

只改ASCII值的加密手段太简单，无法抵挡潜在的攻击。可以考虑使用AES或RSA等更安全的加密算法。

赞 0 回复举报

韦雨苗： @我心有泪

虽然简单的ASCII值加密提供了一种基础的保护方式，但对于需要更高安全性的场景，确实应当考虑使用更为复杂和安全的加密算法，比如AES或RSA。对于AES，提供了对称加密的高效性，而RSA则适用于非对称加密的场景。

例如，使用Java实现AES加密解密的基本示例：

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

public class AESCrypto {
    private static final String ALGORITHM = "AES";

    public static String encrypt(String data, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] encrypted = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encrypted);
    }

    public static String decrypt(String encryptedData, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] decoded = Base64.getDecoder().decode(encryptedData);
        byte[] decrypted = cipher.doFinal(decoded);
        return new String(decrypted);
    }

    public static void main(String[] args) throws Exception {
        KeyGenerator keyGen = KeyGenerator.getInstance(ALGORITHM);
        keyGen.init(128); // 可以选择128, 192, 256位
        SecretKey secretKey = keyGen.generateKey();

        String originalData = "Hello, secure world!";
        String encryptedData = encrypt(originalData, secretKey);
        String decryptedData = decrypt(encryptedData, secretKey);

        System.out.println("Original: " + originalData);
        System.out.println("Encrypted: " + encryptedData);
        System.out.println("Decrypted: " + decryptedData);
    }
}

在上面的代码中，利用AES进行字符串的加密与解密，展示了如何生成密钥、加密数据以及解密数据的过程。可以为需要保护的敏感信息提供较强的安全性。

此外，对于非对称加密，如RSA，适合传输密钥等敏感信息。可以寻找相关资料进行深入学习，比如在Oracle的Java Cryptography Architecture Documentation上会有更多的详细信息与示例。

11月17日回复举报

添加新评论

冒险

10月30日

加密和解密函数清晰可读，非常适合作为编程基础练习。

赞 0 回复举报

温存不散： @冒险

在实现简单的加密解密功能时，维持代码的清晰和可读性是至关重要的。例如，可以通过使用基本的ASCII码偏移来实现加密解密，下面是一个简单的实现示例：

public class SimpleEncryption {
    private static final int SHIFT = 3; // 偏移量

    public static String encrypt(String input) {
        StringBuilder encrypted = new StringBuilder();
        for (char c : input.toCharArray()) {
            encrypted.append((char) (c + SHIFT));
        }
        return encrypted.toString();
    }

    public static String decrypt(String input) {
        StringBuilder decrypted = new StringBuilder();
        for (char c : input.toCharArray()) {
            decrypted.append((char) (c - SHIFT));
        }
        return decrypted.toString();
    }

    public static void main(String[] args) {
        String original = "Hello, World!";
        String encrypted = encrypt(original);
        String decrypted = decrypt(encrypted);

        System.out.println("Original: " + original);
        System.out.println("Encrypted: " + encrypted);
        System.out.println("Decrypted: " + decrypted);
    }
}

通过这种方法，代码既简单明了，又能帮助初学者理解加密的基本原理。如果对加密算法有更深入的兴趣，可以参考 Java Cryptography Architecture 这样的网站，以了解更多复杂的加密技术和应用。

11月13日回复举报

添加新评论

倚天剑

11月02日

建议查看OWASP加密指南，以了解安全加密的基本原则。

赞 0 回复举报

晃晃悠悠： @倚天剑

对于有效的加密解密方法，确保使用安全的算法确实是一个重要的方面。可以考虑使用Java的javax.crypto包中提供的加密类，这样可以增强字符串的安全性。以下是一个简单的AES加密和解密示例，供参考：

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

public class SimpleAES {

    private static final String ALGORITHM = "AES";

    public static String encrypt(String data, SecretKey secretKey) throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
        byte[] encryptedData = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encryptedData);
    }

    public static String decrypt(String encryptedData, SecretKey secretKey) throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        byte[] decryptedData = cipher.doFinal(Base64.getDecoder().decode(encryptedData));
        return new String(decryptedData);
    }

    public static SecretKey generateKey() throws Exception {
        KeyGenerator keyGen = KeyGenerator.getInstance(ALGORITHM);
        keyGen.init(128); // 可以选择128、192或者256位
        return keyGen.generateKey();
    }

    public static void main(String[] args) {
        try {
            SecretKey secretKey = generateKey();
            String originalData = "Sensitive Information";
            String encryptedData = encrypt(originalData, secretKey);
            String decryptedData = decrypt(encryptedData, secretKey);

            System.out.println("Original: " + originalData);
            System.out.println("Encrypted: " + encryptedData);
            System.out.println("Decrypted: " + decryptedData);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

为了提高安全性，密钥的管理同样至关重要，可以参考 OWASP 的加密指南，确保在实际应用中遵循最佳实践。此外，建议定期审查加密策略以应对新兴的安全威胁。

详细的信息可以查阅 OWASP 加密指南。

11月16日回复举报

添加新评论

怀过往

11月12日

在数据安全方面，还需遵循更高的安全标准，可结合Java的javax.crypto进行探讨。

赞 0 回复举报

使劲儿： @怀过往

在实现简单的字符串加密解密时，确实需要考虑更高的安全标准，以满足现代应用的需求。使用javax.crypto包可以为数据提供更强的加密机制。下面是一个使用AES对称加密的简单示例：

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

public class AesEncryption {
    public static void main(String[] args) throws Exception {
        String originalText = "Hello, World!";
        SecretKey secretKey = generateKey();

        String encryptedText = encrypt(originalText, secretKey);
        System.out.println("Encrypted: " + encryptedText);

        String decryptedText = decrypt(encryptedText, secretKey);
        System.out.println("Decrypted: " + decryptedText);
    }

    private static SecretKey generateKey() throws Exception {
        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        keyGen.init(128); // 可以选择128, 192, 256位
        return keyGen.generateKey();
    }

    private static String encrypt(String data, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] encryptedBytes = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encryptedBytes);
    }

    private static String decrypt(String encryptedData, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedData));
        return new String(decryptedBytes);
    }
}

这个代码示例展示了如何使用AES算法进行字符串的加密和解密。可以注意到，密钥的管理和加密算法的选择都对安全性至关重要。结合现代加密标准，例如AES和RSA，能够显著提升数据的安全性。

对于进一步的学习，可以参考以下链接，了解更多关于Java加密的内容：
Java Cryptography Architecture (JCA) Reference Guide

通过这些方式，我们不仅可以实现简单的字符串加密，也能在应用中保障数据的安全性。

11月13日回复举报

添加新评论

非谁

11月16日

代码演示中加密过程换用了简单的字符替代法。对于教育目的，这样的实例非常合适。

赞 0 回复举报

离不开： @非谁

在讨论字符替代法时，其实可以拓展到更复杂的替代方法，例如基于移位的加密方式，即著名的凯撒密码。通过这种方式，可以为加密增加一些趣味性。以下是一个简单的实现示例：

public class SimpleEncryption {
    public static String encrypt(String input, int shift) {
        StringBuilder encrypted = new StringBuilder();
        for (char i : input.toCharArray()) {
            char shiftedChar = (char)(i + shift);
            encrypted.append(shiftedChar);
        }
        return encrypted.toString();
    }

    public static String decrypt(String input, int shift) {
        StringBuilder decrypted = new StringBuilder();
        for (char i : input.toCharArray()) {
            char shiftedChar = (char)(i - shift);
            decrypted.append(shiftedChar);
        }
        return decrypted.toString();
    }

    public static void main(String[] args) {
        String original = "Hello World!";
        int shift = 3;

        String encrypted = encrypt(original, shift);
        String decrypted = decrypt(encrypted, shift);

        System.out.println("Original: " + original);
        System.out.println("Encrypted: " + encrypted);
        System.out.println("Decrypted: " + decrypted);
    }
}

这段代码实现了简单的加密和解密，只需一个整数值作为移位参数。对比字符替代法，这种方式能够在一定程度上增强加密效果。对相关理论有兴趣的朋友可以参考更多资料，例如维基百科的凯撒密码，进一步深入理解加密背后的数学原理。

11月20日回复举报

添加新评论

物是

11月27日

除非确定信息的机密性要求很低，否则请避免使用此加密方式。

赞 0 回复举报

唯爱： @物是

虽然简单的加密方式在某些场景下能满足需求，但在处理敏感信息时，确实需要谨慎选择加密方法。可以考虑使用更为安全的加密算法，如AES（高级加密标准），它提供了更强的数据保护。使用Java的javax.crypto包可以轻松实现AES加密。下面是一个简单的示例：

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

public class AESCrypto {
    private static final String ALGORITHM = "AES";

    public static String encrypt(String data, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] encrypted = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encrypted);
    }

    public static String decrypt(String encryptedData, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] original = cipher.doFinal(Base64.getDecoder().decode(encryptedData));
        return new String(original);
    }

    public static void main(String[] args) throws Exception {
        KeyGenerator keyGen = KeyGenerator.getInstance(ALGORITHM);
        keyGen.init(128);
        SecretKey secretKey = keyGen.generateKey();

        String originalData = "Hello, secure world!";
        String encryptedData = encrypt(originalData, secretKey);
        String decryptedData = decrypt(encryptedData, secretKey);

        System.out.println("Original: " + originalData);
        System.out.println("Encrypted: " + encryptedData);
        System.out.println("Decrypted: " + decryptedData);
    }
}

使用更强的加密方法可以在一定程度上提高数据的安全性。有关加密的更深入理解可以参考 Oracle的Java加密开发指南。确保选用适合当前安全需求的加密方案，才能有效保障数据的机密性。

11月19日回复举报

添加新评论

淡雅

12月02日

加密字符串的思路是一种基础入门，未来学习可以探索更多复杂且安全的加密算法，比如SHA、RSA等。

赞 0 回复举报

伤不起： @淡雅

对于字符串加密解密的基础思路，确实是学习加密算法的重要起点。值得一提的是，在简易的加密实现中，可以使用对称加密算法，例如AES（Advanced Encryption Standard）。下面是一个使用Java实现AES加密解密的简单示例：

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

public class AesEncryption {

    private static final String ALGORITHM = "AES";

    public static String encrypt(String data, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] encryptedData = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encryptedData);
    }

    public static String decrypt(String encryptedData, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] decryptedData = cipher.doFinal(Base64.getDecoder().decode(encryptedData));
        return new String(decryptedData);
    }

    public static void main(String[] args) throws Exception {
        KeyGenerator keyGen = KeyGenerator.getInstance(ALGORITHM);
        keyGen.init(128);
        SecretKey secretKey = keyGen.generateKey();

        String originalData = "Hello, World!";
        String encryptedData = encrypt(originalData, secretKey);
        String decryptedData = decrypt(encryptedData, secretKey);

        System.out.println("Original: " + originalData);
        System.out.println("Encrypted: " + encryptedData);
        System.out.println("Decrypted: " + decryptedData);
    }
}

在这段代码中，首先生成一个AES密钥，然后对字符串进行加密和解密。可以看到，AES相较于简单的Caesar加密等方式，提供了更好的安全性。而如果希望深入了解和实际应用其他算法，可以参考 Java Cryptography Architecture (JCA)。

建议在学习过程中，不妨结合不同的场景和算法，进一步探索更安全的和更高效的加密方式。

11月12日回复举报

添加新评论

免费图表工具，画流程图、架构图

Java字符串实现简单加密解密

举报评论

删除

删除后，将不可回复，确认要删除？

提示

复制代码，请先登录