字节流和字符流

路西法98

已于 2024-02-23 14:58:38 修改

阅读量1.6k

点赞数

文章标签：开发语言 java

于 2023-10-20 15:33:37 首次发布

本文链接：https://blog.csdn.net/weixin_42594143/article/details/133947547

版权

字节流和字符流的区别与联系

Java中的字节流和字符流是用于处理输入和输出的两种不同的流。

区别

1. 数据类型：字节流以字节为单位进行读写，而字符流以字符为单位进行读写。字节流可以处理任意类型的数据，包括文本、图像、音频等，而字符流主要用于处理文本数据。

2. 编码方式：字节流是以字节的形式直接读写数据，不关心数据的具体编码方式。而字符流是以字符的形式读写数据，会根据指定的字符编码将字符转换为字节进行处理。

3. 处理效率：字节流的处理效率通常比字符流高，因为字节流直接操作底层的字节数据，不需要进行字符编码的转换。

4. 使用场景：字节流适用于处理二进制数据，如文件的复制、网络传输等。字符流适用于处理文本数据，如文件的读写、文本的处理等。

联系

1. 继承关系：字节流和字符流都是抽象类InputStream和OutputStream的子类，以及Reader和Writer的子类。
2. 使用方式：字节流和字符流都提供了类似的读写方法，如read()和write()方法。
3. 转换：可以通过InputStreamReader和OutputStreamWriter类将字节流转换为字符流，以便处理文本数据。
4. 字符流是建立在字节流的基础上的。在字符流中，使用了字符编码来处理字符数据，而字符编码又是通过字节流来实现的。因此，字符流可以看作是字节流的高级封装，提供了更方便的字符处理功能。

字节流相关的类：

1. InputStream：所有字节输入流的超类。

2. FileInputStream：从文件中读取数据的输入流。

3. BufferedInputStream：带有缓冲区的输入流，提高读取效率。

4. DataInputStream：可以从输入流中读取Java基本数据类型的输入流。

5. ObjectInputStream：可以从输入流中读取Java对象的输入流。

6. OutputStream：所有字节输出流的超类。

7. FileOutputStream：向文件中写入数据的输出流。

8. BufferedOutputStream：带有缓冲区的输出流，提高写入效率。

9. DataOutputStream：可以向输出流中写入Java基本数据类型的输出流。

10. ObjectOutputStream：可以向输出流中写入Java对象的输出流。

11. ByteArrayInputStream：是一个输入流，它从一个字节数组中读取数据

12. ByteArrayOutputStream：是一个输出流，它将数据写入一个字节数组中。

字符流相关的类：

1. Reader：所有字符输入流的超类。

2. FileReader：从文件中读取字符的输入流。

3. BufferedReader：带有缓冲区的输入流，提高读取效率。

4. InputStreamReader：将字节流转换为字符流的输入流。

5. Writer：所有字符输出流的超类。

6. FileWriter：向文件中写入字符的输出流。

7. BufferedWriter：带有缓冲区的输出流，提高写入效率。

8. OutputStreamWriter：将字符流转换为字节流的输出流。

字节流相关的类示例代码

InputStream示例代码：

InputStream inputStream = new FileInputStream("example.txt");
int data = inputStream.read();
while (data != -1) {
    System.out.print((char) data);
    data = inputStream.read();
}
inputStream.close();

这段代码创建了一个文件输入流，读取了文件中的每一个字节，并将其转换为字符输出到控制台上。最后关闭了输入流。

FileInputStream示例代码：

FileInputStream inputStream = new FileInputStream("example.txt");
int data = inputStream.read();
while (data != -1) {
    System.out.print((char) data);
    data = inputStream.read();
}
inputStream.close();

这段代码创建了一个文件输入流，读取了文件中的每一个字节，并将其转换为字符输出到控制台上。最后关闭了输入流。

BufferedInputStream示例代码：

InputStream inputStream = new FileInputStream("example.txt");
BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
int data = bufferedInputStream.read();
while (data != -1) {
    System.out.print((char) data);
    data = bufferedInputStream.read();
}
bufferedInputStream.close();

这段代码创建了一个文件输入流，并将其包装在一个带有缓冲区的输入流中。读取了文件中的每一个字节，并将其转换为字符输出到控制台上。最后关闭了输入流。

DataInputStream示例代码：

InputStream inputStream = new FileInputStream("example.txt");
DataInputStream dataInputStream = new DataInputStream(inputStream);
int data = dataInputStream.readInt();
System.out.println(data);
dataInputStream.close();

这段代码创建了一个文件输入流，并将其包装在一个可以读取Java基本数据类型的输入流中。读取了文件中的一个整数，并将其输出到控制台上。最后关闭了输入流。

ObjectInputStream示例代码：

InputStream inputStream = new FileInputStream("example.txt");
ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
Object object = objectInputStream.readObject();
System.out.println(object);
objectInputStream.close();

这段代码创建了一个文件输入流，并将其包装在一个可以读取Java对象的输入流中。读取了文件中的一个对象，并将其输出到控制台上。最后关闭了输入流。

OutputStream示例代码：

OutputStream outputStream = new FileOutputStream("example.txt");
String data = "Hello, world!";
outputStream.write(data.getBytes());
outputStream.close();

这段代码创建了一个文件输出流，将一个字符串转换为字节数组，并将其写入到文件中。最后关闭了输出流。

FileOutputStream示例代码：

FileOutputStream outputStream = new FileOutputStream("example.txt");
String data = "Hello, world!";
outputStream.write(data.getBytes());
outputStream.close();

这段代码创建了一个文件输出流，将一个字符串转换为字节数组，并将其写入到文件中。最后关闭了输出流。

BufferedOutputStream示例代码：

OutputStream outputStream = new FileOutputStream("example.txt");
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);
String data = "Hello, world!";
bufferedOutputStream.write(data.getBytes());
bufferedOutputStream.close();

这段代码创建了一个文件输出流，并将其包装在一个带有缓冲区的输出流中。将一个字符串转换为字节数组，并将其写入到文件中。最后关闭了输出流。

DataOutputStream示例代码：

OutputStream outputStream = new FileOutputStream("example.txt");
DataOutputStream dataOutputStream = new DataOutputStream(outputStream);
int data = 42;
dataOutputStream.writeInt(data);
dataOutputStream.close();

这段代码创建了一个文件输出流，并将其包装在一个可以写入Java基本数据类型的输出流中。将一个整数写入到文件中。最后关闭了输出流。

ObjectOutputStream示例代码：

OutputStream outputStream = new FileOutputStream("example.txt");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
Object object = new Object();
objectOutputStream.writeObject(object);
objectOutputStream.close();

这段代码创建了一个文件输出流，并将其包装在一个可以写入Java对象的输出流中。将一个对象写入到文件中。最后关闭了输出流。

ByteArrayInputStream示例代码：

byte[] byteArray = {1, 2, 3, 4, 5};
ByteArrayInputStream inputStream = new ByteArrayInputStream(byteArray);

int data;
while ((data = inputStream.read()) != -1) {
    System.out.println(data);
}

创建了一个ByteArrayInputStream对象，将一个字节数组传递给它。然后我们使用while循环从输入流中读取数据，并在控制台上打印出来。

ByteArrayOutputStream示例代码：

ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
outputStream.write(1);
outputStream.write(2);
outputStream.write(3);
outputStream.write(4);
outputStream.write(5);

byte[] byteArray = outputStream.toByteArray();
System.out.println(Arrays.toString(byteArray));

创建了一个ByteArrayOutputStream对象，并使用write方法向它写入数据。最后，我们使用toByteArray方法将数据转换为字节数组，并在控制台上打印出来。

扩展：

ByteArrayInputStream和ObjectInputStream的关系，并给出ByteArrayInputStream和ObjectInputStream结合使用的示例代码

ByteArrayInputStream和ObjectInputStream都是Java IO库中的输入流类，用于从字节数组和对象流中读取数据。它们的关系是，ObjectInputStream是建立在ByteArrayInputStream之上的，即ObjectInputStream需要一个InputStream对象作为参数来初始化，而ByteArrayInputStream正好是一种InputStream对象。

下面是一个示例代码，演示如何使用ByteArrayInputStream和ObjectInputStream结合使用来读取Java对象：

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;

public class ObjectInputStreamExample {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 创建一个包含Java对象的字节数组
        byte[] objectBytes = createObjectBytes();

        // 创建一个ByteArrayInputStream对象
        ByteArrayInputStream bais = new ByteArrayInputStream(objectBytes);

        // 创建一个ObjectInputStream对象，将ByteArrayInputStream对象作为参数传入
        ObjectInputStream ois = new ObjectInputStream(bais);

        // 从ObjectInputStream中读取Java对象
        ArrayList<String> list = (ArrayList<String>) ois.readObject();

        // 打印读取到的Java对象
        System.out.println(list);
    }

    private static byte[] createObjectBytes() throws IOException {
        ArrayList<String> list = new ArrayList<>();
        list.add("hello");
        list.add("world");

        // 创建一个ByteArrayOutputStream对象
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        // 创建一个ObjectOutputStream对象，将ByteArrayOutputStream对象作为参数传入
        ObjectOutputStream oos = new ObjectOutputStream(baos);

        // 将Java对象写入ObjectOutputStream中
        oos.writeObject(list);

        // 返回ByteArrayOutputStream中的字节数组
        return baos.toByteArray();
    }
}

在上面的示例代码中，首先通过createObjectBytes方法创建了一个包含Java对象的字节数组。然后，创建了一个ByteArrayInputStream对象，并将这个字节数组作为参数传入。接着，创建了一个ObjectInputStream对象，并将ByteArrayInputStream对象作为参数传入。最后，通过ObjectInputStream对象读取了Java对象，并打印出来。

字符流相关的类示例代码

Reader示例代码：

Reader reader = new FileReader("file.txt");
int data = reader.read();
while (data != -1) {
    System.out.print((char) data);
    data = reader.read();
}
reader.close();

代码含义：创建一个Reader对象，使用FileReader将文件"file.txt"作为输入流。然后使用read()方法读取字符，并将其打印出来，直到读取到文件末尾（返回-1）。最后关闭输入流。

FileReader示例代码：

FileReader reader = new FileReader("file.txt");
int data = reader.read();
while (data != -1) {
    System.out.print((char) data);
    data = reader.read();
}
reader.close();

代码含义：创建一个FileReader对象，将文件"file.txt"作为输入流。然后使用read()方法读取字符，并将其打印出来，直到读取到文件末尾（返回-1）。最后关闭输入流。

BufferedReader示例代码：

BufferedReader reader = new BufferedReader(new FileReader("file.txt"));
String line = reader.readLine();
while (line != null) {
    System.out.println(line);
    line = reader.readLine();
}
reader.close();

代码含义：创建一个BufferedReader对象，使用FileReader将文件"file.txt"作为输入流，并带有缓冲区。然后使用readLine()方法读取一行字符，并将其打印出来，直到读取到文件末尾（返回null）。最后关闭输入流。

InputStreamReader示例代码：

InputStreamReader reader = new InputStreamReader(new FileInputStream("file.txt"), "UTF-8");
int data = reader.read();
while (data != -1) {
    System.out.print((char) data);
    data = reader.read();
}
reader.close();

代码含义：创建一个InputStreamReader对象，使用FileInputStream将文件"file.txt"作为字节流输入流，并将其转换为字符流输入流。指定字符编码为UTF-8。然后使用read()方法读取字符，并将其打印出来，直到读取到文件末尾（返回-1）。最后关闭输入流。

Writer示例代码：

Writer writer = new FileWriter("file.txt");
writer.write("Hello, World!");
writer.close();

代码含义：创建一个Writer对象，使用FileWriter将字符写入到文件"file.txt"中。然后使用write()方法写入字符串"Hello, World!"。最后关闭输出流。

FileWriter示例代码：

FileWriter writer = new FileWriter("file.txt");
writer.write("Hello, World!");
writer.close();

代码含义：创建一个FileWriter对象，将字符写入到文件"file.txt"中。然后使用write()方法写入字符串"Hello, World!"。最后关闭输出流。

BufferedWriter示例代码：

BufferedWriter writer = new BufferedWriter(new FileWriter("file.txt"));
writer.write("Hello, World!");
writer.newLine();
writer.write("This is a new line.");
writer.close();

代码含义：创建一个BufferedWriter对象，使用FileWriter将字符写入到文件"file.txt"中，并带有缓冲区。然后使用write()方法写入字符串"Hello, World!“，使用newLine()方法写入一个新行，再使用write()方法写入字符串"This is a new line.”。最后关闭输出流。

OutputStreamWriter示例代码：

OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream("file.txt"), "UTF-8");
writer.write("Hello, World!");
writer.close();

代码含义：创建一个OutputStreamWriter对象，使用FileOutputStream将字节流输出到文件"file.txt"中，并将其转换为字符流输出流。指定字符编码为UTF-8。然后使用write()方法写入字符串"Hello, World!"。最后关闭输出流。