【Java万花筒】数据之舞：Java编码解码库的艺术与科学

Java 编码与解码：全面掌握常用库与技术

前言

在现代软件开发中，数据的编码与解码是非常常见的操作，尤其在网络通信、数据存储和安全领域中。Java作为一种广泛应用的编程语言，提供了丰富的编码解码库和技术，能够满足各种需求。本文将深入探讨Java中常用的编码与解码库，帮助读者全面了解并掌握这些重要的工具和技术。

欢迎订阅专栏：Java万花筒

1. Base64

Base64 是一种用于将二进制数据转换成 ASCII 字符串的编码方式，常用于在网络传输或存储中表示二进制数据。Java 8 引入了 Base64 类，提供了基本的编码和解码功能。

1.1 Base64 编码

Base64 编码将二进制数据转换成字符串，使用标准的 Base64 字符表进行编码。

import java.util.Base64;

public class Base64EncodingExample {
    public static void main(String[] args) {
        String original = "Hello, World!";
        byte[] bytesToEncode = original.getBytes();
        String encodedString = Base64.getEncoder().encodeToString(bytesToEncode);
        System.out.println("Encoded string: " + encodedString);
    }
}

1.2 Base64 解码

Base64 解码将 Base64 编码的字符串还原成原始的二进制数据。

import java.util.Base64;

public class Base64DecodingExample {
    public static void main(String[] args) {
        String encodedString = "SGVsbG8sIFdvcmxkIQ==";
        byte[] decodedBytes = Base64.getDecoder().decode(encodedString);
        String decodedString = new String(decodedBytes);
        System.out.println("Decoded string: " + decodedString);
    }
}

1.3 Base64 URL 编码

除了标准的 Base64 编码外，Java 的 Base64 类还提供了对URL进行编码的功能，用于在URL参数中传递Base64编码的数据。

import java.util.Base64;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;

public class Base64URLEncodingExample {
    public static void main(String[] args) {
        try {
            String original = "Hello, World!";
            byte[] bytesToEncode = original.getBytes();
            String encodedString = Base64.getUrlEncoder().encodeToString(bytesToEncode);
            System.out.println("URL Encoded string: " + encodedString);

            // URL Decode to get the original string
            String decodedString = new String(Base64.getUrlDecoder().decode(encodedString));
            System.out.println("Decoded string: " + decodedString);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
}

1.4 Base64 MIME 编码

在某些场景下，需要将 Base64 编码的数据格式化成 MIME（Multipurpose Internet Mail Extensions）标准的形式。Java 的 Base64 类也提供了相应的支持。

import java.util.Base64;

public class Base64MIMEEncodingExample {
    public static void main(String[] args) {
        String original = "Hello, World!";
        byte[] bytesToEncode = original.getBytes();
        String encodedString = Base64.getMimeEncoder().encodeToString(bytesToEncode);
        System.out.println("MIME Encoded string: \n" + encodedString);

        // MIME Decode to get the original string
        String decodedString = new String(Base64.getMimeDecoder().decode(encodedString));
        System.out.println("Decoded string: " + decodedString);
    }
}

2. Apache Commons Codec

Apache Commons Codec 是一个开源的编码解码工具库，提供了多种常用编码解码的实现。

2.1 编码与解码工具

Apache Commons Codec 提供了通用的编码解码工具，包括 Base64 编码解码、URL 编码解码、Hex 编码解码等。

import org.apache.commons.codec.binary.Base64;

public class CommonsCodecExample {
    public static void main(String[] args) {
        String original = "Hello, World!";
        
        // Base64 编码
        byte[] base64EncodedBytes = Base64.encodeBase64(original.getBytes());
        String base64EncodedString = new String(base64EncodedBytes);
        System.out.println("Base64 Encoded string: " + base64EncodedString);
        
        // Base64 解码
        byte[] base64DecodedBytes = Base64.decodeBase64(base64EncodedBytes);
        String base64DecodedString = new String(base64DecodedBytes);
        System.out.println("Base64 Decoded string: " + base64DecodedString);
    }
}

2.2 Base64 编码与解码

Apache Commons Codec 提供了更灵活的 Base64 编码解码方式。

import org.apache.commons.codec.binary.Base64;

public class CommonsBase64Example {
    public static void main(String[] args) {
        String original = "Hello, World!";
        
        // Base64 编码
        byte[] base64EncodedBytes = Base64.encodeBase64(original.getBytes());
        String base64EncodedString = new String(base64EncodedBytes);
        System.out.println("Base64 Encoded string: " + base64EncodedString);
        
        // Base64 解码
        byte[] base64DecodedBytes = Base64.decodeBase64(base64EncodedBytes);
        String base64DecodedString = new String(base64DecodedBytes);
        System.out.println("Base64 Decoded string: " + base64DecodedString);
    }
}

2.3 URL 编码与解码

Apache Commons Codec 还提供了 URL 编码解码的功能。

import org.apache.commons.codec.net.URLCodec;

public class CommonsURLCodecExample {
    public static void main(String[] args) throws Exception {
        URLCodec urlCodec = new URLCodec();
        String original = "Hello, World!";
        
        // URL 编码
        String encodedString = urlCodec.encode(original);
        System.out.println("URL Encoded string: " + encodedString);
        
        // URL 解码
        String decodedString = urlCodec.decode(encodedString);
        System.out.println("URL Decoded string: " + decodedString);
    }
}

2.4 Hex 编码与解码

Apache Commons Codec 提供了十六进制编码解码的功能。

import org.apache.commons.codec.binary.Hex;

public class CommonsHexExample {
    public static void main(String[] args) {
        String original = "Hello, World!";
        
        // Hex 编码
        byte[] hexEncodedBytes = Hex.encodeHex(original.getBytes());
        String hexEncodedString = new String(hexEncodedBytes);
        System.out.println("Hex Encoded string: " + hexEncodedString);
        
        // Hex 解码
        try {
            byte[] hexDecodedBytes = Hex.decodeHex(hexEncodedString.toCharArray());
            String hexDecodedString = new String(hexDecodedBytes);
            System.out.println("Hex Decoded string: " + hexDecodedString);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2.5 URLSafe Base64 编码与解码

在某些情况下，需要生成适用于URL的Base64编码，其中将标准Base64中的"+“和”/“字符替换为”-“和”_"，以避免在URL参数中引起歧义。

import org.apache.commons.codec.binary.Base64;

public class CommonsURLSafeBase64Example {
    public static void main(String[] args) {
        String original = "Hello, World!";
        
        // URLSafe Base64 编码
        byte[] urlSafeBase64EncodedBytes = Base64.encodeBase64URLSafe(original.getBytes());
        String urlSafeBase64EncodedString = new String(urlSafeBase64EncodedBytes);
        System.out.println("URLSafe Base64 Encoded string: " + urlSafeBase64EncodedString);
        
        // URLSafe Base64 解码
        byte[] urlSafeBase64DecodedBytes = Base64.decodeBase64(urlSafeBase64EncodedBytes);
        String urlSafeBase64DecodedString = new String(urlSafeBase64DecodedBytes);
        System.out.println("URLSafe Base64 Decoded string: " + urlSafeBase64DecodedString);
    }
}

2.6 Codec 工具类

Apache Commons Codec 还提供了方便的 Codec 工具类，用于简化编码解码的操作。

import org.apache.commons.codec.Encoder;
import org.apache.commons.codec.Decoder;
import org.apache.commons.codec.binary.Base64;

public class CommonsCodecUtilsExample {
    public static void main(String[] args) {
        String original = "Hello, World!";
        
        // 使用 Codec 工具类进行 Base64 编码
        Encoder base64Encoder = new Base64();
        String encodedString = (String) base64Encoder.encode(original);
        System.out.println("Base64 Encoded string: " + encodedString);
        
        // 使用 Codec 工具类进行 Base64 解码
        Decoder base64Decoder = new Base64();
        String decodedString = (String) base64Decoder.decode(encodedString);
        System.out.println("Base64 Decoded string: " + decodedString);
    }
}

3. JCodec

3.1 视频编码

JCodec 提供了视频编码的功能，可以将视频文件编码为特定格式的视频流。以下是一个简单的示例，演示如何使用 JCodec 进行视频编码：

import org.jcodec.api.awt.SequenceEncoder;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

public class VideoEncodingExample {
    public static void main(String[] args) throws IOException {
        File outputFile = new File("output.mp4");
        SequenceEncoder encoder = new SequenceEncoder(outputFile);

        // 假设frames是一个存储视频帧的 BufferedImage 数组
        for (BufferedImage frame : frames) {
            encoder.encodeImage(frame);
        }

        encoder.finish();
        System.out.println("视频编码完成");
    }
}

3.2 视频解码

JCodec 同样也支持视频解码功能，可以将视频文件解码为原始的图像帧。以下是一个简单的示例，演示如何使用 JCodec 进行视频解码：

import org.jcodec.api.JCodecException;
import org.jcodec.api.awt.FrameGrab;
import org.jcodec.common.model.Picture;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

public class VideoDecodingExample {
    public static void main(String[] args) throws IOException, JCodecException {
        File videoFile = new File("input.mp4");
        FrameGrab grab = FrameGrab.createFrameGrab(videoFile);
        
        // 逐帧解码
        Picture picture;
        while ((picture = grab.getNativeFrame()) != null) {
            BufferedImage image = AWTUtil.toBufferedImage(picture);
            // 处理解码后的图像帧
        }
        
        System.out.println("视频解码完成");
    }
}

3.3 视频编辑

JCodec 不仅可以用于视频的编码和解码，还支持基本的视频编辑功能。你可以使用 JCodec 对视频进行剪切、合并、添加水印等操作。以下是一个简单的示例，演示如何使用 JCodec 进行视频编辑：

import org.jcodec.api.JCodecException;
import org.jcodec.api.awt.SequenceEncoder;
import org.jcodec.api.awt.AWTUtil;
import org.jcodec.common.model.Picture;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

public class VideoEditingExample {
    public static void main(String[] args) throws IOException, JCodecException {
        // 输入视频文件
        File inputVideoFile = new File("input.mp4");
        
        // 输出视频文件
        File outputVideoFile = new File("edited_output.mp4");
        
        // 剪切起始和结束时间（单位：秒）
        int startTime = 5;
        int endTime = 15;

        // 创建一个 SequenceEncoder 用于输出编辑后的视频
        SequenceEncoder encoder = new SequenceEncoder(outputVideoFile);

        // 创建 FrameGrab 用于从原视频中获取帧
        FrameGrab grab = FrameGrab.createFrameGrab(inputVideoFile);

        // 定位到起始时间
        grab.seekToFramePrecise((int) (startTime * grab.getVideoTrack().getFrameRate()));

        // 逐帧编码，直到达到结束时间
        int frameNumber = (int) ((endTime - startTime) * grab.getVideoTrack().getFrameRate());
        for (int i = 0; i < frameNumber; i++) {
            Picture picture = grab.getNativeFrame();
            BufferedImage image = AWTUtil.toBufferedImage(picture);

            // 在这里可以对图像进行处理，比如添加水印、调整亮度等

            // 编码并写入输出文件
            encoder.encodeImage(image);
        }

        // 完成视频编辑
        encoder.finish();
        System.out.println("视频编辑完成");
    }
}

在这个示例中，我们展示了如何通过 JCodec 对视频进行剪切操作，并且在逐帧处理时可以加入对图像的进一步处理。

3.4 视频压缩

除了基本的编码和解码功能，JCodec 还提供了视频压缩的支持。通过调整编码参数，可以实现对视频文件的压缩，从而减小文件大小。以下是一个简单的示例：

import org.jcodec.api.SequenceEncoder;
import org.jcodec.common.model.Picture;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

public class VideoCompressionExample {
    public static void main(String[] args) throws IOException {
        File inputVideoFile = new File("input.mp4");
        File outputVideoFile = new File("compressed_output.mp4");

        // 创建一个 SequenceEncoder 用于输出压缩后的视频
        SequenceEncoder encoder = new SequenceEncoder(outputVideoFile);

        // 创建 FrameGrab 用于从原视频中获取帧
        FrameGrab grab = FrameGrab.createFrameGrab(inputVideoFile);

        // 逐帧编码，并降低视频帧的质量以实现压缩
        Picture picture;
        while ((picture = grab.getNativeFrame()) != null) {
            // 在这里可以对图像进行进一步处理，例如降低帧质量
            // 通过调整编码参数，如设置码率等，实现视频压缩
            // ...

            // 编码并写入输出文件
            encoder.encodeNativeFrame(picture);
        }

        // 完成视频压缩
        encoder.finish();
        System.out.println("视频压缩完成");
    }
}

在这个示例中，我们通过调整编码参数，可以实现对视频的压缩，以减小输出文件的大小。

4. Guava

4.1 字符串编码与解码

Guava 提供了字符串编码解码的工具。以下是一个示例：

import com.google.common.io.BaseEncoding;

public class StringEncodingExample {
    public static void main(String[] args) {
        String original = "Hello, World!";
        
        // 字符串编码
        String encodedString = BaseEncoding.base64().encode(original.getBytes());
        System.out.println("Encoded string: " + encodedString);
        
        // 字符串解码
        byte[] decodedBytes = BaseEncoding.base64().decode(encodedString);
        String decodedString = new String(decodedBytes);
        System.out.println("Decoded string: " + decodedString);
    }
}

4.2 URL 编码与解码

Guava 同样也提供了 URL 编码解码的工具。以下是一个示例：

import com.google.common.net.UrlEscapers;
import com.google.common.net.UrlEscapers;

public class URLEncodingExample {
    public static void main(String[] args) {
        String original = "https://www.example.com/?query=Guava编码解码";
        
        // URL 编码
        String encodedURL = UrlEscapers.urlFragmentEscaper().escape(original);
        System.out.println("Encoded URL: " + encodedURL);
        
        // URL 解码
        String decodedURL = UrlEscapers.urlFragmentEscaper().unescape(encodedURL);
        System.out.println("Decoded URL: " + decodedURL);
    }
}

4.3 字节编码与解码

Guava 还提供了字节编码解码的工具。以下是一个示例：

import com.google.common.io.BaseEncoding;

public class ByteEncodingExample {
    public static void main(String[] args) {
        byte[] originalBytes = {0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x2C, 0x20, 0x57, 0x6F, 0x72, 0x6C, 0x64, 0x21};
        
        // 字节编码
        String encodedString = BaseEncoding.base16().encode(originalBytes);
        System.out.println("Encoded string: " + encodedString);
        
        // 字节解码
        byte[] decodedBytes = BaseEncoding.base16().decode(encodedString);
        String decodedString = new String(decodedBytes);
        System.out.println("Decoded string: " + decodedString);
    }
}

4.4 集合操作与处理

Guava 提供了丰富的集合操作与处理工具，使得在处理集合数据时更加方便。以下是一些集合操作的示例：

4.4.1 过滤集合元素

import com.google.common.collect.Collections2;
import java.util.Collection;

public class CollectionFilteringExample {
    public static void main(String[] args) {
        Collection<String> words = Lists.newArrayList("apple", "banana", "cherry", "date", "elderberry");

        // 过滤集合中长度大于等于 6 的元素
        Collection<String> filteredWords = Collections2.filter(words, s -> s.length() >= 6);

        System.out.println("Original Collection: " + words);
        System.out.println("Filtered Collection: " + filteredWords);
    }
}

4.4.2 转换集合元素

import com.google.common.collect.Lists;
import com.google.common.collect.Collections2;
import java.util.Collection;

public class CollectionTransformExample {
    public static void main(String[] args) {
        Collection<String> fruits = Lists.newArrayList("apple", "banana", "cherry");

        // 将集合中的元素转换为大写形式
        Collection<String> uppercaseFruits = Collections2.transform(fruits, String::toUpperCase);

        System.out.println("Original Collection: " + fruits);
        System.out.println("Transformed Collection: " + uppercaseFruits);
    }
}

4.4.3 集合的不可变性

import com.google.common.collect.ImmutableList;

public class ImmutableCollectionExample {
    public static void main(String[] args) {
        ImmutableList<String> immutableList = ImmutableList.of("apple", "banana", "cherry");

        // 尝试修改不可变集合会抛出 UnsupportedOperationException
        // immutableList.add("date");
    }
}

4.5 文件操作

Guava 也提供了一些方便的文件操作工具，以下是一个文件读写的示例：

import com.google.common.io.Files;
import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class FileIOExample {
    public static void main(String[] args) throws IOException {
        File inputFile = new File("input.txt");
        File outputFile = new File("output.txt");

        // 读取文件内容
        String content = Files.asCharSource(inputFile, StandardCharsets.UTF_8).read();

        // 写入文件内容
        Files.asCharSink(outputFile, StandardCharsets.UTF_8).write(content);

        System.out.println("File read and write complete.");
    }
}

在这个示例中，我们展示了如何使用 Guava 进行集合操作以及简便的文件读写操作。 Guava 的集合工具和文件操作工具使得在Java中处理常见任务更加简单和高效。

5. Bouncy Castle

5.1 加密与解密算法

Bouncy Castle 是一个流行的密码学库，提供了各种加密解密算法的实现。以下是一个简单的示例，演示如何使用 Bouncy Castle 进行数据加密解密：

import org.bouncycastle.jce.provider.BouncyCastleProvider;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import java.security.Security;
import java.util.Base64;

public class EncryptionExample {
    public static void main(String[] args) throws Exception {
        Security.addProvider(new BouncyCastleProvider());

        // 生成密钥
        KeyGenerator keyGenerator = KeyGenerator.getInstance("AES", "BC");
        keyGenerator.init(256);
        SecretKey secretKey = keyGenerator.generateKey();

        // 加密
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding", "BC");
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
        byte[] encryptedBytes = cipher.doFinal("Hello, World!".getBytes());
        String encryptedString = Base64.getEncoder().encodeToString(encryptedBytes);
        System.out.println("Encrypted string: " + encryptedString);

        // 解密
        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedString));
        String decryptedString = new String(decryptedBytes);
        System.out.println("Decrypted string: " + decryptedString);
    }
}

5.2 数字签名与验证

Bouncy Castle 提供了数字签名与验证的功能，可以用于确保数据的完整性和真实性。以下是一个示例：

import org.bouncycastle.jce.provider.BouncyCastleProvider;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Security;
import java.security.Signature;
import java.util.Base64;

public class DigitalSignatureExample {
    public static void main(String[] args) throws Exception {
        Security.addProvider(new BouncyCastleProvider());

        // 生成密钥对
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA", "BC");
        keyPairGenerator.initialize(2048);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();

        // 待签名数据
        byte[] data = "Hello, World!".getBytes();

        // 获取私钥
        PrivateKey privateKey = keyPair.getPrivate();

        // 签名
        Signature signature = Signature.getInstance("SHA256withRSA", "BC");
        signature.initSign(privateKey);
        signature.update(data);
        byte[] signatureBytes = signature.sign();
        String signatureString = Base64.getEncoder().encodeToString(signatureBytes);
        System.out.println("Signature: " + signatureString);

        // 获取公钥
        PublicKey publicKey = keyPair.getPublic();

        // 验证签名
        signature.initVerify(publicKey);
        signature.update(data);
        boolean verified = signature.verify(Base64.getDecoder().decode(signatureString));
        System.out.println("Signature verified: " + verified);
    }
}

5.3 密钥生成与管理

Bouncy Castle 可以用于生成和管理密钥，包括对称密钥和非对称密钥。以下是一个示例：

import org.bouncycastle.jce.provider.BouncyCastleProvider;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import java.security.Security;

public class KeyGenerationExample {
    public static void main(String[] args) throws Exception {
        Security.addProvider(new BouncyCastleProvider());

        // 生成对称密钥
        KeyGenerator keyGenerator = KeyGenerator.getInstance("AES", "BC");
        keyGenerator.init(256);
        SecretKey secretKey = keyGenerator.generateKey();
        byte[] keyBytes = secretKey.getEncoded();
        System.out.println("Generated AES Key: " + bytesToHex(keyBytes));
    }

    // 将字节数组转换为十六进制字符串
    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02X", b));
        }
        return sb.toString();
    }
}

5.4 安全随机数生成

Bouncy Castle 提供了安全的随机数生成器，用于生成密码学上安全的随机数。以下是一个示例：

import org.bouncycastle.jce.provider.BouncyCastleProvider;
import java.security.Security;
import java.security.SecureRandom;

public class SecureRandomExample {
    public static void main(String[] args) throws Exception {
        Security.addProvider(new BouncyCastleProvider());

        // 创建安全随机数生成器
        SecureRandom secureRandom = SecureRandom.getInstanceStrong();

        // 生成随机字节数组
        byte[] randomBytes = new byte[16];
        secureRandom.nextBytes(randomBytes);

        System.out.println("Generated Secure Random Bytes: " + bytesToHex(randomBytes));
    }

    // 将字节数组转换为十六进制字符串
    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02X", b));
        }
        return sb.toString();
    }
}

5.5 安全通信示例

Bouncy Castle 可以用于实现安全的通信，包括加密、解密、数字签名和验证。以下是一个简单的安全通信示例：

import org.bouncycastle.jce.provider.BouncyCastleProvider;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import java.security.Security;
import java.security.KeyPair;
import java.security.KeyPairGenerator;

public class SecureCommunicationExample {
    public static void main(String[] args) throws Exception {
        Security.addProvider(new BouncyCastleProvider());

        // 生成对称密钥
        KeyGenerator keyGenerator = KeyGenerator.getInstance("AES", "BC");
        keyGenerator.init(256);
        SecretKey secretKey = keyGenerator.generateKey();

        // 生成非对称密钥对
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA", "BC");
        keyPairGenerator.initialize(2048);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();

        // 模拟发送方加密消息
        Cipher encryptCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding", "BC");
        encryptCipher.init(Cipher.ENCRYPT_MODE, keyPair.getPublic());
        byte[] encryptedMessage = encryptCipher.doFinal("Hello, Bouncy Castle!".getBytes());

        // 模拟接收方解密消息
        Cipher decryptCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding", "BC");
        decryptCipher.init(Cipher.DECRYPT_MODE, keyPair.getPrivate());
        byte[] decryptedMessage = decryptCipher.doFinal(encryptedMessage);

        System.out.println("Original Message: Hello, Bouncy Castle!");
        System.out.println("Encrypted Message: " + bytesToHex(encryptedMessage));
        System.out.println("Decrypted Message: " + new String(decryptedMessage));
    }

    // 将字节数组转换为十六进制字符串
    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02X", b));
        }
        return sb.toString();
    }
}

在这个示例中，我们演示了如何使用 Bouncy Castle 实现安全通信，包括对称密钥加密和非对称密钥对的使用。

6. Google Gson

6.1 JSON 编码

Google Gson 是一个流行的 Java 库，用于将 Java 对象序列化为 JSON 格式的数据。以下是一个示例，演示如何使用 Gson 进行 JSON 编码：

import com.google.gson.Gson;

public class JsonEncodingExample {
    public static void main(String[] args) {
        // 创建要序列化为 JSON 的 Java 对象
        Person person = new Person("John", 30);

        // 创建 Gson 对象
        Gson gson = new Gson();

        // 将 Java 对象序列化为 JSON 字符串
        String json = gson.toJson(person);
        System.out.println("JSON representation: " + json);
    }
}

class Person {
    private String name;
    private int age;

    // 构造函数、getter 和 setter 方法省略

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

6.2 JSON 解码

Google Gson 同样也支持将 JSON 格式的数据解码为 Java 对象。以下是一个示例，演示如何使用 Gson 进行 JSON 解码：

import com.google.gson.Gson;

public class JsonDecodingExample {
    public static void main(String[] args) {
        // 要解析的 JSON 字符串
        String json = "{\"name\":\"John\",\"age\":30}";

        // 创建 Gson 对象
        Gson gson = new Gson();

        // 将 JSON 字符串解析为 Java 对象
        Person person = gson.fromJson(json, Person.class);

        // 访问解析后的 Java 对象的属性
        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
    }
}

class Person {
    private String name;
    private int age;

    // 构造函数、getter 和 setter 方法省略

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

总结

编码与解码是Java开发中常见的操作，对于数据的传输、存储和处理都至关重要。本文系统地介绍了Java中常用的编码与解码库，包括Base64、Apache Commons Codec、JCodec、Guava、Bouncy Castle和Google Gson。通过学习这些库，读者可以更加灵活地处理各种编码解码任务，提高代码的效率和可靠性。