【Java 基础篇】Java字节字符流详解：轻松读写文本与二进制数据_java二进制流讲解

在Java编程中，对文件和数据的读写操作是非常常见的任务。为了满足不同需求，Java提供了多种流类来处理输入和输出。本篇博客将详细介绍Java中的字节流和字符流，以及它们的使用方法，帮助初学者更好地理解和运用这些流来处理文件和数据。

字节流和字符流的区别

在开始之前，我们需要了解字节流和字符流的基本区别。这两者都是用于文件和数据的读写，但有一些重要的不同点：

• 字节流：字节流主要用于处理二进制数据，如图像、音频、视频文件等。它们以字节为单位进行读写，适合处理任何类型的数据，包括文本数据。字节流通常使用InputStream和OutputStream类。

• 字符流：字符流用于处理文本数据，以字符为单位进行读写。它们在内部使用编码方式来处理字符数据，可以很好地处理各种字符集。字符流通常使用Reader和Writer类。

接下来，我们将详细介绍这两种流的使用。

字节流操作

使用FileInputStream和FileOutputStream

FileInputStream和FileOutputStream是最基本的字节流，用于读取和写入文件。以下是一个读取文件并将其复制到另一个文件的示例：

import java.io.*;

public class FileInputStreamExample {
    public static void main(String[] args) {
        try (FileInputStream input = new FileInputStream("input.txt");
             FileOutputStream output = new FileOutputStream("output.txt")) {
            int data;
            while ((data = input.read()) != -1) {
                output.write(data);
            }
            System.out.println("File copied successfully!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

使用BufferedInputStream和BufferedOutputStream

BufferedInputStream和BufferedOutputStream提供了缓冲功能，可以提高读写文件的效率。下面是一个使用缓冲流的示例：

import java.io.*;

public class BufferedStreamExample {
    public static void main(String[] args) {
        try (BufferedInputStream input = new BufferedInputStream(new FileInputStream("input.txt"));
             BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream("output.txt"))) {
            int data;
            while ((data = input.read()) != -1) {
                output.write(data);
            }
            System.out.println("File copied successfully!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

使用DataInputStream和DataOutputStream

DataInputStream和DataOutputStream用于读写基本数据类型（如整数、浮点数）和字符串。以下是一个使用它们的示例：

import java.io.*;

public class DataStreamExample {
    public static void main(String[] args) {
        try (DataOutputStream output = new DataOutputStream(new FileOutputStream("data.txt"))) {
            output.writeInt(42);
            output.writeDouble(3.14);
            output.writeUTF("Hello, World!");
            System.out.println("Data written successfully!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

使用ObjectInputStream和ObjectOutputStream

ObjectInputStream和ObjectOutputStream允许您将对象序列化为字节流并将其反序列化回对象。这对于保存和恢复对象状态非常有用。以下是一个示例：

import java.io.*;

class Person implements Serializable {
    private String name;
    private int age;

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class ObjectStreamExample {
    public static void main(String[] args) {
        try (ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream("person.dat"));
             ObjectInputStream input = new ObjectInputStream(new FileInputStream("person.dat"))) {

            Person person = new Person("Alice", 30);
            output.writeObject(person);
            System.out.println("Object written successfully!");

            Person loadedPerson = (Person) input.readObject();
            System.out.println("Loaded person: " + loadedPerson);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

这些是一些用于字节流的基本操作和示例。字节流适用于处理各种文件和数据，但对于文本数据，字符流更加方便。下面我们将介绍字符流的操作。

字符流操作

使用FileReader和FileWriter

FileReader和FileWriter是用于读写文件的字符流。它们非常适合处理文本文件。

import java.io.*;

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

        try (FileReader reader = new FileReader(inputFile);
             FileWriter writer = new FileWriter(outputFile)) {
            int character;

            while ((character = reader.read()) != -1) {
                writer.write(character);
            }

            System.out.println("File copied successfully!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

使用BufferedReader和BufferedWriter

BufferedReader和BufferedWriter提供了缓冲功能，可以提高文件读写的效率。

import java.io.*;

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

        try (BufferedReader reader = new BufferedReader(new FileReader(inputFile));
             BufferedWriter writer = new BufferedWriter(new FileWriter(outputFile))) {
            String line;

            while ((line = reader.readLine()) != null) {
                writer.write(line);
                writer.newLine(); // 添加换行符
            }

            System.out.println("File copied successfully!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

这些是一些用于字符流的高级操作和示例。字符流适用于处理文本数据，特别是需要考虑字符编码的情况。

字节字符流的更多操作

在前面的部分，我们介绍了Java中字节字符流的基本操作。现在让我们深入探讨一些更高级的用法和操作。

1. 复制文件夹

有时候，我们需要将一个文件夹及其内容复制到另一个位置。下面是一个使用字节流来复制文件夹的示例：

import java.io.*;

public class CopyFolderExample {
    public static void main(String[] args) {
        File sourceFolder = new File("sourceFolder");
        File destinationFolder = new File("destinationFolder");

        if (!destinationFolder.exists()) {
            destinationFolder.mkdirs();
        }

        copyFolder(sourceFolder, destinationFolder);
        System.out.println("Folder copied successfully!");
    }

    private static void copyFolder(File source, File destination) {
        if (source.isDirectory()) {
            if (!destination.exists()) {
                destination.mkdir();
            }

            String[] files = source.list();

            if (files != null) {
                for (String file : files) {
                    File srcFile = new File(source, file);
                    File destFile = new File(destination, file);
                    copyFolder(srcFile, destFile);
                }
            }
        } else {
            try (InputStream in = new FileInputStream(source);
                 OutputStream out = new FileOutputStream(destination)) {
                byte[] buffer = new byte[1024];
                int length;
                while ((length = in.read(buffer)) > 0) {
                    out.write(buffer, 0, length);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

2. 压缩文件

你可以使用字节流来压缩和解压缩文件。在Java中，可以使用ZipOutputStream和ZipInputStream来实现这一目标。以下是一个压缩文件的示例：

import java.io.*;
import java.util.zip.*;

public class FileCompressionExample {
    public static void main(String[] args) {
        String sourceFile = "source.txt";
        String compressedFile = "compressed.zip";

        try (FileOutputStream fos = new FileOutputStream(compressedFile);
             ZipOutputStream zipOut = new ZipOutputStream(fos);
             FileInputStream fis = new FileInputStream(sourceFile)) {

            ZipEntry zipEntry = new ZipEntry(sourceFile);
            zipOut.putNextEntry(zipEntry);

            byte[] bytes = new byte[1024];
            int length;
            while ((length = fis.read(bytes)) >= 0) {
                zipOut.write(bytes, 0, length);
            }

            zipOut.closeEntry();
            System.out.println("File compressed successfully!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

3. 文件加密和解密

字节流也可以用于文件的加密和解密操作。你可以对文件的内容进行加密，以确保数据的安全性。以下是一个简单的文件加密和解密示例：

import java.io.*;
import javax.crypto.*;
import javax.crypto.spec.*;

public class FileEncryptionExample {
    public static void main(String[] args) {
        String inputFile = "input.txt";
        String encryptedFile = "encrypted.txt";
        String decryptedFile = "decrypted.txt";

        try {
            // 生成密钥
            KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
            SecretKey secretKey = keyGenerator.generateKey();

            // 创建Cipher对象并初始化为加密模式
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.ENCRYPT_MODE, secretKey);

            // 加密文件
            try (FileInputStream fis = new FileInputStream(inputFile);
                 FileOutputStream fos = new FileOutputStream(encryptedFile);
                 CipherOutputStream cos = new CipherOutputStream(fos, cipher)) {
                byte[] buffer = new byte[1024];
                int length;
                while ((length = fis.read(buffer)) != -1) {
                    cos.write(buffer, 0, length);
                }
            }

            // 解密文件
            cipher.init(Cipher.DECRYPT_MODE, secretKey);
            try (FileInputStream fis = new FileInputStream(encryptedFile);
                 CipherInputStream cis = new CipherInputStream(fis, cipher);
                 FileOutputStream fos = new FileOutputStream(decryptedFile)) {
                byte[] buffer = new byte[1024];
                int length;
                while ((length = cis.read(buffer)) != -1) {
                    fos.write(buffer, 0, length);
                }
            }

            System.out.println("File encryption and decryption successful!");
        } catch (IOException | NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

这些是字节字符流的更多高级操作示例。通过这些操作，你可以更灵活地处理文件和数据，并实现一些高级功能。请根据你的需求选择适合的操作方式。希望这些示例有助于你更好地理解和使用Java中的字节字符流。如果你有任何问题或建议，请随时在下面的评论中提出。

字节字符流的注意事项

在使用Java中的字节字符流时，有一些注意事项需要特别关注，以确保代码的可靠性和性能。以下是一些常见的注意事项：

1. 关闭流

确保在使用完流后关闭它们。流是有限的资源，如果不关闭，可能会导致资源泄漏。使用try-with-resources语句可以确保在退出代码块时自动关闭流。

try (FileInputStream fis = new FileInputStream("input.txt");
     FileOutputStream fos = new FileOutputStream("output.txt")) {
    // 使用流进行读写操作
} catch (IOException e) {
    e.printStackTrace();
}
1
2
3
4
5
6

2. 处理异常

在处理文件IO时，要适当地处理异常。这包括捕获和处理可能出现的异常，以及根据需要抛出自定义异常。

3. 字符编码

当使用字符流时，要注意字符编码。默认情况下，字符流使用平台默认的字符编码。如果需要使用不同的字符编码，可以在构造流时指定。

FileInputStream fis = new FileInputStream("input.txt");
InputStreamReader isr = new InputStreamReader(fis, StandardCharsets.UTF_8);
1
2

4. 缓冲流

使用缓冲流可以提高IO性能。BufferedInputStream和BufferedOutputStream用于字节流，而BufferedReader和BufferedWriter用于字符流。

BufferedReader reader = new BufferedReader(new FileReader("input.txt"));
BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"));
1
2

5. 大文件处理

处理大文件时，应该使用适当的缓冲大小，以免消耗过多的内存。根据需要调整缓冲大小以平衡性能和内存消耗。

6. 异常处理

不要忽视异常处理。在IO操作期间，可能会发生各种异常，如IOException，FileNotFoundException等。正确处理这些异常对于代码的稳定性非常重要。

7. 文件路径

在处理文件时，确保指定的文件路径是正确的。如果文件不存在，可能会引发FileNotFoundException异常。

8. 线程安全性

注意多线程环境下的线程安全性。如果多个线程同时访问文件，必须谨慎处理以避免竞争条件。

9. 清理资源

在不再需要流时，确保调用close()方法释放资源。否则，可能会导致资源泄漏和性能下降。

遵循这些注意事项可以帮助你更好地编写和管理Java中的字节字符流代码。这些最佳实践有助于提高代码的可维护性和可靠性，同时确保你的应用程序能够高效地处理文件和数据。

总结

本篇博客详细介绍了Java中的字节流和字符流，以及它们的基本操作和示例。无论是处理文本数据还是二进制数据，Java提供了丰富的流类来满足各种需求。希望本文对初学者有所帮助，使他们更好地理解和运用Java中的流操作。

如果你有任何问题或建议，请随时在下面的评论中提出。谢谢阅读！