Java使用ByteBuffer进行多文件合并和拆分的代码实现

落在天空_叶子

目录

• 1.背景
• 2.代码工程
• 实验目的
• 合并代码
• 拆分代码
• 工具类
• 代码仓库
• 3.测试

1.背景

因为验证证书的需要，需要把证书文件和公钥给到客户，考虑到多个文件交互的不便性，所以决定将2个文件合并成一个文件交互给客户。刚开始采用字符串拼接2个文件内容，但是由于是加密文件，采用字符串形式合并后，拆分后文件不可用，最后采用基于二进制流拆分和合并文件，效果不错！

2.代码工程

实验目的

1. 对文件进行二进制流合并和拆分

复制代码

合并代码

1. ByteBuffer.allocate(4).putInt(publicCertsContent.length).array()

复制代码

的作用是将

1. publicCertsContent

复制代码

（公钥证书内容）的长度转换为 4 个字节的整数，并写入到字节缓冲区中。具体作用如下：

• 1. ByteBuffer.allocate(4)

  复制代码
  : 创建一个大小为 4 字节的
  1. ByteBuffer

  复制代码
  ，因为 Java 中的整数（
  1. int

  复制代码
  ）是 4 个字节。
• 1. putInt(publicCertsContent.length)

  复制代码
  : 将
  1. publicCertsContent

  复制代码
  的字节数组长度（即证书文件的字节长度）存入
  1. ByteBuffer

  复制代码
  。这样就把证书内容的长度存储为一个 4 字节的整数。
• 1. array()

  复制代码
  : 将
  1. ByteBuffer

  复制代码
  转换为字节数组。这个数组包含了公钥证书内容长度的 4 字节表示形式。

这个表达式的作用是将

1. publicCertsContent

复制代码

数组的长度转换为二进制的 4 字节表示形式，并写入输出流（

1. outputStream

复制代码

）中。这样在以后读取合并文件时，代码可以知道该读取多少字节属于

1. publicCertsContent

复制代码

。

有小伙伴这里可能有疑问，4字节够存多大数字呢？

4 个字节（即 32 位）在计算机中用于存储整数，能表示的整数范围如下：

• 有符号整数（
  1. int

  复制代码
  类型）：
  • 范围是：-2,147,483,648 到 2,147,483,647
  • 其中 1 位用于符号（正负），31 位用于数值。
• 无符号整数（
  1. unsigned int

  复制代码
  ，Java 中没有直接支持，但可以通过转换处理）：
  • 范围是：0 到 4,294,967,295

通常 Java 中的

1. int

复制代码

类型是有符号的，因此 4 个字节可以存储的整数范围为 -2^31 到 2^31 - 1，即 -2,147,483,648 到 2,147,483,647。所以只要不超过这个限制都能存下来

1. package com.et;
4. import java.io.ByteArrayOutputStream;
5. import java.io.IOException;
6. import java.nio.ByteBuffer;
9. public class FileMerger {
11. public static void main(String[] args) {
12. String privateKeys = "D:/IdeaProjects/Java-demo/file/src/main/resources/privateKeys.keystore";
13. String publicCerts = "D:/IdeaProjects/Java-demo/file/src/main/resources/publicCerts.keystore";
14. merger(privateKeys,publicCerts);
16. }
17. public static String merger(String privateKeys, String publicCerts) {
18. String directoryPath = FileUtils.extractDirectoryPath(privateKeys);
19. String mergedFile =directoryPath+"merge.keystore";
21. try {
22. byte[] privateKeysContent = FileUtils.readBinaryFile(privateKeys);
23. byte[] publicCertsContent = FileUtils.readBinaryFile(publicCerts);
26. // create outputStream
27. ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
29. // write keystore length（4 byte）
30. outputStream.write(ByteBuffer.allocate(4).putInt(privateKeysContent.length).array());
32. // write keystore content
33. outputStream.write(privateKeysContent);
35. // witer license content（4 byte int ）
36. outputStream.write(ByteBuffer.allocate(4).putInt(publicCertsContent.length).array());
38. // write license content
39. outputStream.write(publicCertsContent);
41. // write merge content to file
42. FileUtils.writeBinaryFile(mergedFile, outputStream.toByteArray());
44. System.out.println("merge success " + mergedFile);
45. } catch (IOException e) {
46. e.printStackTrace();
47. }
48. return mergedFile;
49. }
53. }

复制代码

拆分代码

拆分逻辑就很简单了，先读取4字节，获取文件大小，然后依次获取文件内容就可以了

1. buffer.getInt()

复制代码

可以正确读取文件中的大小信息。具体来说，它会从

1. ByteBuffer

复制代码

中读取 4 个字节，并将这些字节解释为一个整数。 如果你按照之前的代码将文件内容合并时，将文件大小以 4 字节整数形式写入到文件中，那么你可以使用

1. buffer.getInt()

复制代码

来读取这个大小。例如，假设你在合并文件时使用了如下方式写入大小：

1. outputStream.write(ByteBuffer.allocate(4).putInt(content.length).array());

复制代码

在读取合并文件时，你可以这样做：

1. ByteBuffer buffer = ByteBuffer.wrap(fileContent); // 假设 fileContent 是读取的字节数组
2. int size = buffer.getInt(); // 读取前 4 个字节，获取文件大小

复制代码

这里的

1. buffer.getInt()

复制代码

会正确读取到前 4 个字节，并将其转换为整数，这样你就得到了文件内容的大小。 请确保在读取文件时，字节顺序（字节序）与写入时一致，默认情况下是大端序（Big Endian）。如果你的应用需要小端序（Little Endian），你可以使用

1. buffer.order(ByteOrder.LITTLE_ENDIAN)

复制代码

来设置字节序。

1. package com.et;
4. import java.io.ByteArrayOutputStream;
5. import java.io.IOException;
6. import java.nio.ByteBuffer;
7. import java.util.ArrayList;
8. import java.util.Arrays;
9. import java.util.List;
10. import java.util.stream.Collectors;
13. public class FileSplitter {
15. public static void main(String[] args) {
16. String mergedFile = "D:/IdeaProjects/Java-demo/file/src/main/resources/merge.keystore";
17. split(mergedFile);
19. }
20. private static void debugContent(byte[] content, String fileName) {
21. System.out.printf("File: %s%n", fileName);
22. System.out.printf("Length: %d%n", content.length);
23. System.out.print("Content: ");
24. for (byte b : content) {
25. System.out.printf("%02X ", b);
26. }
27. System.out.println();
28. }
29. static String[] split(String mergedFile) {
30. String directoryPath = FileUtils.extractDirectoryPath(mergedFile);
31. String privateKeysFile = directoryPath + ".privateKeys.keystore";
32. String publicCertsFile = directoryPath + ".publicCerts.keystore";
33. String[] filePaths = new String[]{privateKeysFile, publicCertsFile};
35. try {
36. // read merge content
37. byte[] mergedContent = FileUtils.readBinaryFile(mergedFile);
39. // use ByteBuffer parse
40. ByteBuffer buffer = ByteBuffer.wrap(mergedContent);
42. // read privateKeys content length
43. int privateKeysLength = buffer.getInt();
45. // read privateKeys content
46. byte[] privateKeysContent = new byte[privateKeysLength];
47. buffer.get(privateKeysContent);
49. // read publicCerts content length
50. int publicCertsLength = buffer.getInt();
52. // read publicCerts content
53. byte[] publicCertsContent = new byte[publicCertsLength];
54. buffer.get(publicCertsContent);
56. // write privateKeys and publicCerts content to file
57. FileUtils.writeBinaryFile(privateKeysFile, privateKeysContent);
58. FileUtils.writeBinaryFile(publicCertsFile, publicCertsContent);
60. System.out.println("merge file split " + privateKeysFile + " and " + publicCertsFile);
62. } catch (IOException e) {
63. e.printStackTrace();
64. }
66. return filePaths;
67. }
74. private static byte[] extractContent(byte[] mergedContent, byte[] beginMarker, byte[] endMarker) {
75. int beginIndex = indexOf(mergedContent, beginMarker);
76. int endIndex = indexOf(mergedContent, endMarker, beginIndex);
78. if (beginIndex != -1 && endIndex != -1) {
79. // Move past the start marker
80. beginIndex += beginMarker.length;
82. // Adjust endIndex to exclude the end marker
83. int adjustedEndIndex = endIndex;
85. // Extract content
86. return Arrays.copyOfRange(mergedContent, beginIndex, adjustedEndIndex);
87. } else {
88. return new byte[0]; // Return empty array if markers are not found
89. }
90. }
93. private static byte[] removeEmptyLines(byte[] content) {
94. // Convert byte array to list of lines
95. List<byte[]> lines = splitIntoLines(content);
97. // Filter out empty lines
98. lines = lines.stream()
99. .filter(line -> line.length > 0)
100. .collect(Collectors.toList());
102. // Reassemble content
103. return mergeLines(lines);
104. }
106. private static List<byte[]> splitIntoLines(byte[] content) {
107. List<byte[]> lines = new ArrayList<>();
108. int start = 0;
110. for (int i = 0; i < content.length; i++) {
111. if (content[i] == '\n') { // Line break
112. lines.add(Arrays.copyOfRange(content, start, i));
113. start = i + 1;
114. }
115. }
117. if (start < content.length) {
118. lines.add(Arrays.copyOfRange(content, start, content.length));
119. }
121. return lines;
122. }
124. private static byte[] mergeLines(List<byte[]> lines) {
125. ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
126. for (byte[] line : lines) {
127. try {
128. outputStream.write(line);
129. outputStream.write('\n'); // Re-add line break
130. } catch (IOException e) {
131. e.printStackTrace();
132. }
133. }
134. return outputStream.toByteArray();
135. }
137. private static int indexOf(byte[] array, byte[] target) {
138. return indexOf(array, target, 0);
139. }
141. private static int indexOf(byte[] array, byte[] target, int start) {
142. for (int i = start; i <= array.length - target.length; i++) {
143. if (Arrays.equals(Arrays.copyOfRange(array, i, i + target.length), target)) {
144. return i;
145. }
146. }
147. return -1; // Return -1 if target not found
148. }
155. }

复制代码

工具类

1. package com.et;
3. import java.io.File;
4. import java.io.FileInputStream;
5. import java.io.FileOutputStream;
6. import java.io.IOException;
8. public class FileUtils {
10. static byte[] readBinaryFile(String filePath) throws IOException {
11. File file = new File(filePath);
12. try (FileInputStream fis = new FileInputStream(file)) {
13. byte[] fileBytes = new byte[(int) file.length()];
14. fis.read(fileBytes);
15. return fileBytes;
16. }
17. }
18. public static String extractDirectoryPath(String filePath) {
19. File file = new File(filePath);
20. return file.getParent()+File.separator; // 获取文件所在的目录
21. }
22. static void writeBinaryFile(String filePath, byte[] content) throws IOException {
23. try (FileOutputStream fos = new FileOutputStream(filePath)) {
24. fos.write(content);
25. }
26. }
27. }

复制代码

以上只是一些关键代码，所有代码请参见下面代码仓库

代码仓库

• https://github.com/Harries/Java-demo(file)

3.测试

测试类

1. package com.et;
3. public class Main {
4. public static void main(String[] args) {
5. System.out.println("Hello world!");
6. String privateKeys = "D:/IdeaProjects/Java-demo/file/src/main/resources/privateKeys.keystore";
7. String publicCerts = "D:/IdeaProjects/Java-demo/file/src/main/resources/publicCerts.keystore";
8. FileMerger.merger(privateKeys,publicCerts);
9. String mergedFile = "D:/IdeaProjects/Java-demo/file/src/main/resources/merge.keystore";
10. FileSplitter.split(mergedFile);
11. }
12. }

复制代码

运行main方法，日志显示如下

1. merge success D:\IdeaProjects\Java-demo\file\src\main\resources\merge.keystore
2. merge file split D:\IdeaProjects\Java-demo\file\src\main\resources\.privateKeys.keystore and D:\IdeaProjects\Java-demo\file\src\main\resources\.publicCerts.keystore

复制代码

拆分后文件于原文件大小一模一样

以上就是Java使用ByteBuffer进行多文件合并和拆分的代码实现的详细内容，更多关于Java ByteBuffer文件合并和拆分的资料请关注晓枫资讯其它相关文章！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

弘听然

感谢楼主分享。

太叔海翡

路过，支持一下