本文目录导读：
我来为你介绍Java字节流读写文件的完整案例。
基本字节流读写文件
使用FileInputStream和FileOutputStream
import java.io.*;
public class ByteStreamExample {
public static void main(String[] args) {
// 1. 逐字节读写（不推荐用于大文件）
readWriteByteByByte();
// 2. 使用缓冲区读写（推荐方式）
readWriteWithBuffer();
// 3. 使用try-with-resources自动关闭资源
readWriteWithTryResources();
}
// 方法1：逐字节读写
public static void readWriteByteByByte() {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream("source.txt");
fos = new FileOutputStream("destination.txt");
int byteData;
while ((byteData = fis.read()) != -1) {
fos.write(byteData);
}
System.out.println("文件复制完成（逐字节方式）");
} catch (IOException e) {
e.printStackTrace();
} finally {
// 关闭资源
try {
if (fis != null) fis.close();
if (fos != null) fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
// 方法2：使用缓冲区读写（推荐）
public static void readWriteWithBuffer() {
try {
FileInputStream fis = new FileInputStream("source.txt");
FileOutputStream fos = new FileOutputStream("destination.txt");
byte[] buffer = new byte[1024]; // 1KB缓冲区
int bytesRead;
while ((bytesRead = fis.read(buffer)) != -1) {
fos.write(buffer, 0, bytesRead);
}
fis.close();
fos.close();
System.out.println("文件复制完成（缓冲区方式）");
} catch (IOException e) {
e.printStackTrace();
}
}
// 方法3：使用try-with-resources（Java 7+）
public static void readWriteWithTryResources() {
// 自动关闭资源
try (FileInputStream fis = new FileInputStream("source.txt");
FileOutputStream fos = new FileOutputStream("destination.txt")) {
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = fis.read(buffer)) != -1) {
fos.write(buffer, 0, bytesRead);
}
System.out.println("文件复制完成（try-with-resources方式）");
} catch (IOException e) {
e.printStackTrace();
}
}
}
实际应用案例
案例1：复制图片文件
import java.io.*;
public class ImageCopyExample {
public static void copyImage(String sourcePath, String destPath) {
try (FileInputStream fis = new FileInputStream(sourcePath);
FileOutputStream fos = new FileOutputStream(destPath)) {
byte[] buffer = new byte[8192]; // 8KB缓冲区
int bytesRead;
long startTime = System.currentTimeMillis();
while ((bytesRead = fis.read(buffer)) != -1) {
fos.write(buffer, 0, bytesRead);
}
long endTime = System.currentTimeMillis();
System.out.println("图片复制完成！耗时：" + (endTime - startTime) + "ms");
} catch (IOException e) {
System.err.println("文件复制失败: " + e.getMessage());
}
}
public static void main(String[] args) {
copyImage("C:/photos/photo.jpg", "D:/backup/photo_copy.jpg");
}
}
案例2：文件加密（简单异或加密）
import java.io.*;
public class FileEncryptExample {
// 简单异或加密
public static void encryptFile(String source, String dest, byte key) {
try (FileInputStream fis = new FileInputStream(source);
FileOutputStream fos = new FileOutputStream(dest)) {
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = fis.read(buffer)) != -1) {
// 对每个字节进行异或加密
for (int i = 0; i < bytesRead; i++) {
buffer[i] ^= key;
}
fos.write(buffer, 0, bytesRead);
}
System.out.println("文件加密完成");
} catch (IOException e) {
System.err.println("加密失败: " + e.getMessage());
}
}
// 解密（异或两次即可解密）
public static void decryptFile(String source, String dest, byte key) {
encryptFile(source, dest, key); // 相同的异或操作即可解密
}
public static void main(String[] args) {
// 加密文件
encryptFile("original.txt", "encrypted.txt", (byte) 0x7F);
// 解密文件
decryptFile("encrypted.txt", "decrypted.txt", (byte) 0x7F);
}
}
案例3：大文件分块复制
import java.io.*;
public class LargeFileCopyExample {
// 分块复制，显示进度
public static void copyWithProgress(String source, String dest) throws IOException {
File sourceFile = new File(source);
long fileSize = sourceFile.length();
try (FileInputStream fis = new FileInputStream(sourceFile);
FileOutputStream fos = new FileOutputStream(dest)) {
byte[] buffer = new byte[8192];
int bytesRead;
long totalBytesRead = 0;
int progressPercent = 0;
while ((bytesRead = fis.read(buffer)) != -1) {
fos.write(buffer, 0, bytesRead);
totalBytesRead += bytesRead;
// 计算并显示进度
int newProgress = (int) (totalBytesRead * 100 / fileSize);
if (newProgress > progressPercent) {
progressPercent = newProgress;
System.out.print("\r复制进度: " + progressPercent + "%");
}
}
System.out.println("\n文件复制完成！");
} catch (IOException e) {
throw new IOException("文件复制失败", e);
}
}
public static void main(String[] args) {
try {
copyWithProgress("largefile.bin", "largefile_copy.bin");
} catch (IOException e) {
System.err.println("错误: " + e.getMessage());
}
}
}
实用工具类
import java.io.*;
public class FileUtil {
// 复制文件
public static void copyFile(String source, String dest) throws IOException {
try (FileInputStream fis = new FileInputStream(source);
FileOutputStream fos = new FileOutputStream(dest)) {
byte[] buffer = new byte[8192];
int bytesRead;
while ((bytesRead = fis.read(buffer)) != -1) {
fos.write(buffer, 0, bytesRead);
}
}
}
// 读取文件到字节数组
public static byte[] readFileToBytes(String filePath) throws IOException {
File file = new File(filePath);
byte[] data = new byte[(int) file.length()];
try (FileInputStream fis = new FileInputStream(file)) {
fis.read(data);
}
return data;
}
// 写入字节数组到文件
public static void writeBytesToFile(byte[] data, String filePath) throws IOException {
try (FileOutputStream fos = new FileOutputStream(filePath)) {
fos.write(data);
}
}
// 获取文件大小
public static long getFileSize(String filePath) {
File file = new File(filePath);
return file.exists() ? file.length() : -1;
}
}
// 使用示例
public class FileUtilDemo {
public static void main(String[] args) {
try {
// 复制文件
FileUtil.copyFile("source.txt", "dest.txt");
// 读取文件
byte[] fileData = FileUtil.readFileToBytes("config.bin");
System.out.println("文件大小: " + fileData.length + " 字节");
// 写入文件
String content = "Hello, World!";
FileUtil.writeBytesToFile(content.getBytes(), "output.txt");
} catch (IOException e) {
System.err.println("操作失败: " + e.getMessage());
}
}
}
关键知识点总结
- 缓冲区的选择：一般使用1KB-8KB的缓冲区
- 资源管理：使用try-with-resources自动关闭资源
- 异常处理：正确处理IOException
- 性能优化：使用缓冲区而不是逐字节读写
- 文件路径：注意使用正确的文件路径分隔符
这些案例涵盖了Java字节流的基本用法和实际应用场景,可以根据具体需求选择合适的实现方式。
