代码密码相关加密方式对称加密DES加密3DES加密AES加密非对称加密RSADSAECC哈希算法MD5 算法SHA-1 算法SHA-256 算法混合加密国密编码Base64编码URL编码代码demo源码密码相关明文、密文、加密、解密(公钥)、密钥(私钥)、加密和非对称加密、密码算法加密方式对称加密、非对称加密、哈希算法、混合加密对称加密特点 加密和解密使用同一个密钥就像用同一把钥匙锁门和开门。优点 速度快效率高适合加密大量数据。缺点 密钥如何安全地传输给对方是一个难题密钥分发问题DES加密目前确认已是不安全的加密方式(64位密钥进行加密8个字节实际密钥长度56位其中8位用于奇偶校验)早期的标准因为密钥长度较短56位现在已被认为不够安全容易被暴力破解import javax.crypto.Cipher; import javax.crypto.KeyGenerator; import javax.crypto.SecretKey; import javax.crypto.spec.SecretKeySpec; import java.security.NoSuchAlgorithmException; import java.util.Base64; public class DesDemo { public static void main(String[] args) { try { // 原文 String plainText Hello, DES! 这是一段测试文本。; // 1. 生成 DES 密钥 KeyGenerator keyGen KeyGenerator.getInstance(DES); keyGen.init(56); // 指定密钥长度实际是56位加上8位奇偶校验共64位 SecretKey secretKey keyGen.generateKey(); // 也可以从字节数组恢复密钥例如存储的密钥 // byte[] keyBytes secretKey.getEncoded(); // SecretKey keyFromBytes new SecretKeySpec(keyBytes, DES); System.out.println(原始文本: plainText); // 2. 加密 byte[] cipherData encrypt(plainText.getBytes(UTF-8), secretKey); System.out.println(加密后 (Base64): Base64.getEncoder().encodeToString(cipherData)); System.out.println(加密后 (Hex): bytesToHex(cipherData)); // 3. 解密 byte[] decryptedData decrypt(cipherData, secretKey); String decryptedText new String(decryptedData, UTF-8); System.out.println(解密后文本: decryptedText); } catch (Exception e) { e.printStackTrace(); } } /** * 使用 DES 加密数据 * param data 待加密的字节数组 * param key DES 密钥 * return 加密后的字节数组 */ public static byte[] encrypt(byte[] data, SecretKey key) throws Exception { Cipher cipher Cipher.getInstance(DES/ECB/PKCS5Padding); cipher.init(Cipher.ENCRYPT_MODE, key); return cipher.doFinal(data); } /** * 使用 DES 解密数据 * param encryptedData 密文字节数组 * param key DES 密钥 * return 解密后的字节数组 */ public static byte[] decrypt(byte[] encryptedData, SecretKey key) throws Exception { Cipher cipher Cipher.getInstance(DES/ECB/PKCS5Padding); cipher.init(Cipher.DECRYPT_MODE, key); return cipher.doFinal(encryptedData); } /** * 将字节数组转换为十六进制字符串用于显示 */ private static String bytesToHex(byte[] bytes) { StringBuilder sb new StringBuilder(); for (byte b : bytes) { sb.append(String.format(%02X, b)); } return sb.toString(); } }3DES加密为了替代DES对数据应用三次DES加密安全性较高但速度较慢逐渐被AES取代package com.jysemel.top; import javax.crypto.Cipher; import javax.crypto.KeyGenerator; import javax.crypto.SecretKey; import java.util.Base64; public class TripleDesDemo { public static void main(String[] args) { try { // 原文 String plainText Hello, 3DES! 这是一段需要加密的文本。; // 1. 生成 3DES 密钥 (DESede) KeyGenerator keyGen KeyGenerator.getInstance(DESede); // 3DES 密钥长度可选 112 或 168 位通常使用 168 位24 字节 keyGen.init(168); SecretKey secretKey keyGen.generateKey(); // 也可以从预先定义的字节数组恢复密钥例如存储的密钥 // byte[] keyBytes secretKey.getEncoded(); // SecretKey keyFromBytes new SecretKeySpec(keyBytes, DESede); System.out.println(原始文本: plainText); // 2. 加密 byte[] cipherData encrypt(plainText.getBytes(UTF-8), secretKey); System.out.println(加密后 (Base64): Base64.getEncoder().encodeToString(cipherData)); System.out.println(加密后 (Hex): bytesToHex(cipherData)); // 3. 解密 byte[] decryptedData decrypt(cipherData, secretKey); String decryptedText new String(decryptedData, UTF-8); System.out.println(解密后文本: decryptedText); } catch (Exception e) { e.printStackTrace(); } } /** * 使用 3DES 加密数据 * param data 待加密的字节数组 * param key 3DES 密钥 * return 加密后的字节数组 */ public static byte[] encrypt(byte[] data, SecretKey key) throws Exception { // 算法/模式/填充ECB 模式 PKCS5Padding可根据需要改为 CBC 等 Cipher cipher Cipher.getInstance(DESede/ECB/PKCS5Padding); cipher.init(Cipher.ENCRYPT_MODE, key); return cipher.doFinal(data); } /** * 使用 3DES 解密数据 * param encryptedData 密文字节数组 * param key 3DES 密钥 * return 解密后的字节数组 */ public static byte[] decrypt(byte[] encryptedData, SecretKey key) throws Exception { Cipher cipher Cipher.getInstance(DESede/ECB/PKCS5Padding); cipher.init(Cipher.DECRYPT_MODE, key); return cipher.doFinal(encryptedData); } /** * 将字节数组转换为十六进制字符串用于显示 */ private static String bytesToHex(byte[] bytes) { StringBuilder sb new StringBuilder(); for (byte b : bytes) { sb.append(String.format(%02X, b)); } return sb.toString(); } }AES加密一种分组加密算法将要加密的数据分成固定大小的数据块处理每个数据库128位(16字节)目前最常用的对称加密算法用于文件加密、Wi-Fi加密WPA2、硬盘加密等package com.jysemel.top; import javax.crypto.Cipher; import javax.crypto.KeyGenerator; import javax.crypto.SecretKey; import javax.crypto.spec.IvParameterSpec; import java.security.SecureRandom; import java.util.Base64; public class AesDemo { public static void main(String[] args) { try { // 原文 String plainText Hello, AES! 这是一段需要加密的敏感信息。; // 1. 生成 AES 密钥128位 KeyGenerator keyGen KeyGenerator.getInstance(AES); keyGen.init(128); // 也可以使用 192 或 256 位需要 JCE 无限强度策略文件支持 256 SecretKey secretKey keyGen.generateKey(); // 2. 生成随机 IV初始化向量长度为 16 字节 byte[] ivBytes new byte[16]; SecureRandom secureRandom new SecureRandom(); secureRandom.nextBytes(ivBytes); IvParameterSpec ivSpec new IvParameterSpec(ivBytes); System.out.println(原始文本: plainText); System.out.println(使用的 IV (Base64): Base64.getEncoder().encodeToString(ivBytes)); // 3. 加密 byte[] cipherData encrypt(plainText.getBytes(UTF-8), secretKey, ivSpec); System.out.println(加密后 (Base64): Base64.getEncoder().encodeToString(cipherData)); System.out.println(加密后 (Hex): bytesToHex(cipherData)); // 4. 解密使用相同的密钥和 IV byte[] decryptedData decrypt(cipherData, secretKey, ivSpec); String decryptedText new String(decryptedData, UTF-8); System.out.println(解密后文本: decryptedText); } catch (Exception e) { e.printStackTrace(); } } /** * 使用 AES/CBC/PKCS5Padding 加密 * param data 明文数据 * param key AES 密钥 * param iv 初始化向量 * return 密文 */ public static byte[] encrypt(byte[] data, SecretKey key, IvParameterSpec iv) throws Exception { Cipher cipher Cipher.getInstance(AES/CBC/PKCS5Padding); cipher.init(Cipher.ENCRYPT_MODE, key, iv); return cipher.doFinal(data); } /** * 使用 AES/CBC/PKCS5Padding 解密 * param encryptedData 密文 * param key AES 密钥 * param iv 初始化向量 * return 明文 */ public static byte[] decrypt(byte[] encryptedData, SecretKey key, IvParameterSpec iv) throws Exception { Cipher cipher Cipher.getInstance(AES/CBC/PKCS5Padding); cipher.init(Cipher.DECRYPT_MODE, key, iv); return cipher.doFinal(encryptedData); } /** * 将字节数组转换为十六进制字符串 */ private static String bytesToHex(byte[] bytes) { StringBuilder sb new StringBuilder(); for (byte b : bytes) { sb.append(String.format(%02X, b)); } return sb.toString(); } }非对称加密特点 加密和解密使用不同的密钥一对密钥公钥和私钥。公钥可以公开给别人私钥自己秘密保存。优点 解决了密钥分发问题安全性极高。缺点 计算复杂速度非常慢通常只用来加密少量数据如对称加密的密钥RSARSA算法RSA算法是公开密钥加密算法RSA算法的密钥长度可以自己定义package com.jysemel.top; import javax.crypto.Cipher; import java.security.*; import java.util.Base64; public class RsaDemo { public static void main(String[] args) { try { // 原文RSA 加密的明文长度有限这里使用较短文本 String plainText Hello, RSA! 这是一段测试。; // 1. 生成 RSA 密钥对2048位 KeyPairGenerator keyPairGen KeyPairGenerator.getInstance(RSA); keyPairGen.initialize(2048); // 推荐使用 2048 位或更高 KeyPair keyPair keyPairGen.generateKeyPair(); PublicKey publicKey keyPair.getPublic(); PrivateKey privateKey keyPair.getPrivate(); System.out.println(原始文本: plainText); System.out.println(公钥 (Base64): Base64.getEncoder().encodeToString(publicKey.getEncoded())); System.out.println(私钥 (Base64): Base64.getEncoder().encodeToString(privateKey.getEncoded())); // 2. 使用公钥加密 byte[] cipherData encrypt(plainText.getBytes(UTF-8), publicKey); System.out.println(加密后 (Base64): Base64.getEncoder().encodeToString(cipherData)); // 3. 使用私钥解密 byte[] decryptedData decrypt(cipherData, privateKey); String decryptedText new String(decryptedData, UTF-8); System.out.println(解密后文本: decryptedText); } catch (Exception e) { e.printStackTrace(); } } /** * 使用公钥加密 * param data 明文数据 * param publicKey 公钥 * return 密文 */ public static byte[] encrypt(byte[] data, PublicKey publicKey) throws Exception { Cipher cipher Cipher.getInstance(RSA/ECB/PKCS1Padding); // 常用填充方式 cipher.init(Cipher.ENCRYPT_MODE, publicKey); return cipher.doFinal(data); } /** * 使用私钥解密 * param encryptedData 密文 * param privateKey 私钥 * return 明文 */ public static byte[] decrypt(byte[] encryptedData, PrivateKey privateKey) throws Exception { Cipher cipher Cipher.getInstance(RSA/ECB/PKCS1Padding); cipher.init(Cipher.DECRYPT_MODE, privateKey); return cipher.doFinal(encryptedData); } // 签名 public static byte[] sign(byte[] data, PrivateKey privateKey) throws Exception { Signature sig Signature.getInstance(SHA256withRSA); sig.initSign(privateKey); sig.update(data); return sig.sign(); } // 验签 public static boolean verify(byte[] data, byte[] signature, PublicKey publicKey) throws Exception { Signature sig Signature.getInstance(SHA256withRSA); sig.initVerify(publicKey); sig.update(data); return sig.verify(signature); } }DSADSA算法DSA算法是数字签名算法DSA算法的密钥长度可以自己定义DSA 与 RSA 不同只能用于数字签名不能用于加密或密钥交换package com.jysemel.top; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.PrivateKey; import java.security.PublicKey; import java.security.Signature; import java.util.Base64; public class DsaDemo { public static void main(String[] args) { try { // 待签名的原始消息 String message Hello, DSA! 这是一条需要签名的消息。; // 1. 生成 DSA 密钥对1024位 KeyPairGenerator keyPairGen KeyPairGenerator.getInstance(DSA); keyPairGen.initialize(1024); // 也可使用 2048 位需 JDK 支持 KeyPair keyPair keyPairGen.generateKeyPair(); PrivateKey privateKey keyPair.getPrivate(); PublicKey publicKey keyPair.getPublic(); System.out.println(原始消息: message); System.out.println(私钥 (Base64): Base64.getEncoder().encodeToString(privateKey.getEncoded())); System.out.println(公钥 (Base64): Base64.getEncoder().encodeToString(publicKey.getEncoded())); // 2. 使用私钥对消息进行签名 Signature signer Signature.getInstance(SHA1withDSA); // 也可用 SHA256withDSA signer.initSign(privateKey); signer.update(message.getBytes(UTF-8)); byte[] signature signer.sign(); System.out.println(签名结果 (Base64): Base64.getEncoder().encodeToString(signature)); System.out.println(签名结果 (Hex): bytesToHex(signature)); // 3. 使用公钥验证签名 Signature verifier Signature.getInstance(SHA1withDSA); verifier.initVerify(publicKey); verifier.update(message.getBytes(UTF-8)); boolean isVerified verifier.verify(signature); System.out.println(签名验证结果: (isVerified ? 成功 ✓ : 失败 ✗)); // 4. 模拟篡改消息后的验证 String tamperedMessage message 篡改; verifier.initVerify(publicKey); verifier.update(tamperedMessage.getBytes(UTF-8)); boolean isTamperedVerified verifier.verify(signature); System.out.println(篡改消息验证结果: (isTamperedVerified ? 成功 ✓ : 失败 ✗符合预期)); } catch (Exception e) { e.printStackTrace(); } } /** * 将字节数组转换为十六进制字符串 */ private static String bytesToHex(byte[] bytes) { StringBuilder sb new StringBuilder(); for (byte b : bytes) { sb.append(String.format(%02X, b)); } return sb.toString(); } }ECC密钥长度较短、但安全性同样高适合对性能要求高的场景哈希算法不可逆加密算法单向的加密算法、散列算法。相同的明文数据加密之后得到的密文相同只能暴力破解、撞库攻击特点 将任意长度的数据计算成固定长度的唯一字符串哈希值。这是一个单向过程无法从哈希值还原原始数据。用途 验证数据完整性、存储密码、数字签名MD5 算法package com.jysemel.top; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; public class Md5Demo { public static void main(String[] args) { String input Hello, MD5! 这是一段测试文本。; try { // 计算 MD5 哈希 String md5Hash calculateMD5(input); System.out.println(原始字符串: input); System.out.println(MD5 哈希值: md5Hash); // 演示空字符串的 MD5 String emptyHash calculateMD5(); System.out.println(空字符串 MD5: emptyHash); } catch (NoSuchAlgorithmException e) { System.err.println(MD5 算法不可用: e.getMessage()); } } /** * 计算字符串的 MD5 哈希值十六进制字符串 * param input 输入字符串 * return 32 位小写十六进制哈希值 * throws NoSuchAlgorithmException 如果 JDK 不支持 MD5几乎不会发生 */ public static String calculateMD5(String input) throws NoSuchAlgorithmException { // 获取 MD5 MessageDigest 实例 MessageDigest md MessageDigest.getInstance(MD5); // 更新摘要数据UTF-8 编码 byte[] messageDigest md.digest(input.getBytes()); // 将字节数组转换为十六进制字符串 StringBuilder hexString new StringBuilder(); for (byte b : messageDigest) { // 将每个字节转换为两位十六进制 String hex Integer.toHexString(0xff b); if (hex.length() 1) { hexString.append(0); } hexString.append(hex); } return hexString.toString(); } }SHA-1 算法SHA-1 已被证实存在碰撞攻击不应用于数字签名、证书或任何安全关键场景。本示例仅供学习或兼容遗留系统使用。实际开发请使用 SHA-256 或更高强度的哈希算法package com.jysemel.top; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.nio.charset.StandardCharsets; public class Sha1Demo { public static void main(String[] args) { String input Hello, SHA-1! 这是一段测试文本。; try { // 计算 SHA-1 哈希 String sha1Hash calculateSHA1(input); System.out.println(原始字符串: input); System.out.println(SHA-1 哈希值: sha1Hash); // 演示空字符串的 SHA-1 String emptyHash calculateSHA1(); System.out.println(空字符串 SHA-1: emptyHash); } catch (NoSuchAlgorithmException e) { System.err.println(SHA-1 算法不可用: e.getMessage()); } } /** * 计算字符串的 SHA-1 哈希值十六进制字符串 * param input 输入字符串 * return 40 位小写十六进制哈希值 * throws NoSuchAlgorithmException 如果 JDK 不支持 SHA-1几乎不会发生 */ public static String calculateSHA1(String input) throws NoSuchAlgorithmException { // 获取 SHA-1 MessageDigest 实例 MessageDigest md MessageDigest.getInstance(SHA-1); // 更新摘要数据指定 UTF-8 编码避免跨平台问题 byte[] messageDigest md.digest(input.getBytes(StandardCharsets.UTF_8)); // 将字节数组转换为十六进制字符串 StringBuilder hexString new StringBuilder(); for (byte b : messageDigest) { // 将每个字节转换为两位十六进制 String hex Integer.toHexString(0xff b); if (hex.length() 1) { hexString.append(0); } hexString.append(hex); } return hexString.toString(); } }SHA-256 算法package com.jysemel.top; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.nio.charset.StandardCharsets; public class Sha256Demo { public static void main(String[] args) { String input Hello, SHA-256! 这是一段测试文本。; try { // 计算 SHA-256 哈希 String sha256Hash calculateSHA256(input); System.out.println(原始字符串: input); System.out.println(SHA-256 哈希值: sha256Hash); // 演示空字符串的 SHA-256 String emptyHash calculateSHA256(); System.out.println(空字符串 SHA-256: emptyHash); } catch (NoSuchAlgorithmException e) { System.err.println(SHA-256 算法不可用: e.getMessage()); } } /** * 计算字符串的 SHA-256 哈希值十六进制字符串 * param input 输入字符串 * return 64 位小写十六进制哈希值 * throws NoSuchAlgorithmException 如果 JDK 不支持 SHA-256通常都支持 */ public static String calculateSHA256(String input) throws NoSuchAlgorithmException { // 获取 SHA-256 MessageDigest 实例 MessageDigest md MessageDigest.getInstance(SHA-256); // 更新摘要数据指定 UTF-8 编码避免跨平台问题 byte[] messageDigest md.digest(input.getBytes(StandardCharsets.UTF_8)); // 将字节数组转换为十六进制字符串 StringBuilder hexString new StringBuilder(); for (byte b : messageDigest) { // 将每个字节转换为两位十六进制 String hex Integer.toHexString(0xff b); if (hex.length() 1) { hexString.append(0); } hexString.append(hex); } return hexString.toString(); } }混合加密在实际应用中比如你正在使用的HTTPS协议通常不会只用一种加密方式而是混合使用使用非对称加密安全地传输一个临时生成的对称密钥解决密钥传递问题。使用对称加密用这个协商好的密钥加密实际传输的大量数据解决加解密速度问题。使用哈希函数验证数据在传输过程中是否被篡改国密国密算法是国家密码管理局制定的国产密码标准主要包括SM2非对称、SM3哈希和SM4对称三种核心算法maven 依赖dependency groupIdorg.bouncycastle/groupId artifactIdbcprov-jdk15on/artifactId version1.70/version !-- 或使用更新的版本 -- /dependency示例package com.jysemel.top; import org.bouncycastle.jce.provider.BouncyCastleProvider; import javax.crypto.Cipher; import java.security.*; import java.security.spec.ECGenParameterSpec; public class SM2Demo { static { // 添加 Bouncy Castle 作为安全提供者 Security.addProvider(new BouncyCastleProvider()); } public static void main(String[] args) throws Exception { String plainText Hello, SM2! 这是一段需要加密的文本。; // 1. 生成 SM2 密钥对 (使用 sm2p256v1 曲线) KeyPairGenerator keyPairGenerator KeyPairGenerator.getInstance(EC, BC); ECGenParameterSpec sm2Spec new ECGenParameterSpec(sm2p256v1); keyPairGenerator.initialize(sm2Spec, new SecureRandom()); KeyPair keyPair keyPairGenerator.generateKeyPair(); PublicKey publicKey keyPair.getPublic(); PrivateKey privateKey keyPair.getPrivate(); System.out.println(原始文本: plainText); // 2. 使用公钥加密 Cipher cipher Cipher.getInstance(SM2, BC); cipher.init(Cipher.ENCRYPT_MODE, publicKey); byte[] cipherData cipher.doFinal(plainText.getBytes(UTF-8)); System.out.println(加密后 (Base64): java.util.Base64.getEncoder().encodeToString(cipherData)); // 3. 使用私钥解密 cipher.init(Cipher.DECRYPT_MODE, privateKey); byte[] decryptedData cipher.doFinal(cipherData); String decryptedText new String(decryptedData, UTF-8); System.out.println(解密后文本: decryptedText); } }package com.jysemel.top; import org.bouncycastle.crypto.digests.SM3Digest; import org.bouncycastle.jce.provider.BouncyCastleProvider; import java.security.Security; public class SM3Demo { static { Security.addProvider(new BouncyCastleProvider()); } public static void main(String[] args) { String plainText Hello, SM3! 这是一段需要哈希的文本。; System.out.println(原始文本: plainText); // 计算 SM3 哈希值 byte[] hash sm3Hash(plainText.getBytes()); System.out.println(SM3 哈希值 (Hex): bytesToHex(hash)); System.out.println(SM3 哈希值 (Base64): java.util.Base64.getEncoder().encodeToString(hash)); } public static byte[] sm3Hash(byte[] input) { SM3Digest digest new SM3Digest(); digest.update(input, 0, input.length); byte[] hash new byte[digest.getDigestSize()]; digest.doFinal(hash, 0); return hash; } private static String bytesToHex(byte[] bytes) { StringBuilder sb new StringBuilder(); for (byte b : bytes) { sb.append(String.format(%02x, b)); } return sb.toString(); } }package com.jysemel.top; import org.bouncycastle.crypto.engines.SM4Engine; import org.bouncycastle.crypto.modes.CBCBlockCipher; import org.bouncycastle.crypto.paddings.PaddedBufferedBlockCipher; import org.bouncycastle.crypto.params.KeyParameter; import org.bouncycastle.crypto.params.ParametersWithIV; import org.bouncycastle.jce.provider.BouncyCastleProvider; import java.security.SecureRandom; import java.security.Security; public class SM4Demo { static { Security.addProvider(new BouncyCastleProvider()); } public static void main(String[] args) throws Exception { String plainText Hello, SM4! 这是一段需要加密的文本。; // 生成一个 128 位的随机密钥和 IV byte[] key new byte[16]; byte[] iv new byte[16]; new SecureRandom().nextBytes(key); new SecureRandom().nextBytes(iv); System.out.println(原始文本: plainText); // 加密 byte[] cipherData sm4CbcEncrypt(plainText.getBytes(UTF-8), key, iv); System.out.println(加密后 (Base64): java.util.Base64.getEncoder().encodeToString(cipherData)); // 解密 byte[] decryptedData sm4CbcDecrypt(cipherData, key, iv); String decryptedText new String(decryptedData, UTF-8); System.out.println(解密后文本: decryptedText); } public static byte[] sm4CbcEncrypt(byte[] input, byte[] key, byte[] iv) throws Exception { // 创建 SM4 引擎并包装为 CBC 模式 PKCS7 填充 PaddedBufferedBlockCipher cipher new PaddedBufferedBlockCipher( new CBCBlockCipher(new SM4Engine())); cipher.init(true, new ParametersWithIV(new KeyParameter(key), iv)); return process(cipher, input); } public static byte[] sm4CbcDecrypt(byte[] input, byte[] key, byte[] iv) throws Exception { PaddedBufferedBlockCipher cipher new PaddedBufferedBlockCipher( new CBCBlockCipher(new SM4Engine())); cipher.init(false, new ParametersWithIV(new KeyParameter(key), iv)); return process(cipher, input); } private static byte[] process(PaddedBufferedBlockCipher cipher, byte[] input) throws Exception { byte[] output new byte[cipher.getOutputSize(input.length)]; int bytesProcessed cipher.processBytes(input, 0, input.length, output, 0); int bytesFinalized cipher.doFinal(output, bytesProcessed); byte[] finalOutput new byte[bytesProcessed bytesFinalized]; System.arraycopy(output, 0, finalOutput, 0, finalOutput.length); return finalOutput; } }编码常见编码方式Base64编码、URL编码等Base64编码将任意二进制数据编码为ASCII字符串、将二进制数据存储为文本文件或者将二进制数据进行网络传输由64个字符组成编码集26个大写字母、26个小写字母、10个数字、2个特殊字符(,/),当原始数据不够三个字节时用进行填充编码将二进制数据转为字符解码将字符转为二进制数据URL编码主要将特殊字符串和不可打印的字符转换为百分号(%)加上两位十六进制的形式以确保字符在URL中可以正确传递和解析package com.jysemel.top; import java.util.Base64; public class Base64Demo { public static void main(String[] args) { String original Hello, 编码世界; // 编码 String encoded Base64.getEncoder().encodeToString(original.getBytes()); System.out.println(Base64 编码: encoded); // 解码 byte[] decodedBytes Base64.getDecoder().decode(encoded); String decoded new String(decodedBytes); System.out.println(解码后: decoded); // URL 安全的 Base64替换 和 / 为 - 和 _ String urlSafe Base64.getUrlEncoder().encodeToString(original.getBytes()); System.out.println(URL 安全 Base64: urlSafe); } }package com.jysemel.top; /** * Hex 将每个字节表示为两个十六进制字符0-9A-F常用于查看二进制数据或生成哈希值的字符串表示 */ public class HexDemo { public static void main(String[] args) { String original Hello Hex; // 编码字节 - 十六进制字符串 byte[] bytes original.getBytes(); StringBuilder hex new StringBuilder(); for (byte b : bytes) { hex.append(String.format(%02x, b)); } System.out.println(Hex 编码: hex); // 解码十六进制字符串 - 字节 String hexStr hex.toString(); byte[] decodedBytes new byte[hexStr.length() / 2]; for (int i 0; i decodedBytes.length; i) { int index i * 2; int val Integer.parseInt(hexStr.substring(index, index 2), 16); decodedBytes[i] (byte) val; } String decoded new String(decodedBytes); System.out.println(解码后: decoded); } }package com.jysemel.top; import java.net.URLEncoder; import java.net.URLDecoder; import java.nio.charset.StandardCharsets; public class URLEncodingDemo { public static void main(String[] args) throws Exception { String original name张三age20; // 编码 String encoded URLEncoder.encode(original, String.valueOf(StandardCharsets.UTF_8)); System.out.println(URL 编码: encoded); // name%3D%E5%BC%A0%E4%B8%89%26age%3D20 // 解码 String decoded URLDecoder.decode(encoded, String.valueOf(StandardCharsets.UTF_8)); System.out.println(解码后: decoded); } }