缓冲流
概述
缓冲流，也被称为高效流，是Java I/O库中为了提高数据读写效率而设计的一组特殊的流。它们通过在内存中创建缓冲区来减少直接的I/O操作次数，从而达到提升性能的目的。
缓冲流的分类：
- 字节缓冲流：包括
BufferedInputStream和BufferedOutputStream，这两个分别用于处理字节数据的输入和输出。 - 字符缓冲流：包括
BufferedReader和BufferedWriter，这两个用于处理字符数据的输入和输出。
工作原理：
- 缓冲流在创建时会生成一个默认大小的缓冲区数组，这个数组用来临时存储数据。
- 当进行读取或写入操作时，数据首先被读取到或从缓冲区写出，这样可以减少对物理设备的直接I/O操作。
- 仅当缓冲区满或空时，才会实际执行对应的读或写操作，从而减少了频繁的系统调用，提高了整体的数据处理速度。
字节缓冲流
Java的字节缓冲流主要包括BufferedInputStream和BufferedOutputStream。以下是对这两种流的详细介绍：
- BufferedInputStream：它是
InputStream类的子类，用于包装其他输入流，以提供缓冲功能。这种流的主要作用是提高读取数据的速度。通过使用内部缓冲区，它可以一次性从底层输入流中读取更多的数据，减少了实际的I/O操作次数。 - BufferedOutputStream：它是
OutputStream类的子类，用于包装其他输出流。与BufferedInputStream类似，它通过内部缓冲区来提高写入数据的效率。当缓冲区填满时，数据会被一次性写入到底层的输出流中，从而减少写操作的次数。
此外，字节缓冲流的原理是在创建流对象时，会创建一个内置的默认大小的缓冲区数组。这个缓冲区用来临时存储数据，当执行读写操作时，数据首先被读取到或写入缓冲区。仅当缓冲区满或空时，才会实际执行对应的读或写操作，这样可以减少对物理设备的直接I/O操作，从而提高读写效率。
以下是使用Java字节缓冲流的代码示例：
import java.io.*;
public class BufferedStreamExample {
public static void main(String[] args) {
File inputFile = new File("input.txt");
File outputFile = new File("output.txt");
try {
// 创建缓冲输入流
FileInputStream fis = new FileInputStream(inputFile);
BufferedInputStream bis = new BufferedInputStream(fis);
// 创建缓冲输出流
FileOutputStream fos = new FileOutputStream(outputFile);
BufferedOutputStream bos = new BufferedOutputStream(fos);
int bytesRead;
byte[] buffer = new byte[1024];
// 从输入文件中读取数据，并将其写入输出文件
while ((bytesRead = bis.read(buffer)) != -1) {
bos.write(buffer, 0, bytesRead);
}
// 关闭流
bis.close();
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
在这个示例中，我们使用BufferedInputStream和BufferedOutputStream来分别处理输入和输出。首先，我们创建了一个名为"input.txt"的文件作为输入源，并创建了一个名为"output.txt"的文件作为输出目标。然后，我们通过FileInputStream和FileOutputStream创建了对应的输入和输出流对象，并将它们包装在缓冲流中。接下来，我们使用一个循环来读取输入流中的数据，并将其写入到输出流中。最后，我们关闭了缓冲流以释放资源。
这个示例展示了如何使用字节缓冲流来高效地读取和写入文件数据。通过使用缓冲区机制，我们可以减少实际的I/O操作次数，从而提高读写效率。
字符缓冲流
Java字符缓冲流是一种用于高效读写字符数据的流。以下是Java字符缓冲流的概述：
- 内部缓冲区：字符缓冲流内部维护了一个缓冲区，这个缓冲区可以一次性读写多个字符，从而减少了对磁盘或网络的I/O操作次数。
- 自动刷新机制：字符缓冲流具有自动刷新功能，当缓冲区满了或者执行手动刷新时，数据会被写入到目标文件中。这有助于确保数据的完整性和及时性。
- 编码处理：字符缓冲流适用于处理文本数据，它可以正确处理字符编码，避免在读写过程中出现字符乱码问题。
- 效率提升：虽然字符流本身就带有缓冲区，但使用字符缓冲流相对于普通字符流仍然可以提高效率，尽管这种效率提升可能不如字节流那么显著。
- 基本类：Java中字符缓冲流的基本类是
BufferedReader和BufferedWriter，它们分别用于读取和写入字符数据。 - 适用场景：字符缓冲流非常适合于处理大量的文本数据，尤其是当涉及到频繁的读写操作时，使用缓冲流可以显著提高程序的性能。
下面是一个Java字符缓冲流的代码示例，演示了如何使用BufferedReader和BufferedWriter进行文件的读写操作：
import java.io.*;
public class BufferedStreamExample {
public static void main(String[] args) {
// 读取文件内容
try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
// 写入文件内容
try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
writer.write("Hello, World!");
writer.newLine();
writer.write("This is a buffered stream example.");
} catch (IOException e) {
e.printStackTrace();
}
}
}
上述代码中，我们使用BufferedReader从名为"input.txt"的文件中逐行读取内容，并打印到控制台上。然后，我们使用BufferedWriter将一些文本写入名为"output.txt"的文件中。
请注意，在示例中，我们使用了try-with-resources语句来自动关闭流对象，以确保资源的正确释放。这是Java 7引入的一种语法糖，可以简化资源的管理。
转换流
概述
Java中的转换流是连接字节流和字符流的桥梁，它们主要用于在字节数据和字符数据之间进行转换。
Java提供了两个主要的转换流类：InputStreamReader和OutputStreamWriter。这两个类都是字符流，但它们与字节流紧密相关，因为它们的作用是在字节流和字符流之间进行转换。具体来说：
- InputStreamReader：这个类继承自
Reader，它的主要作用是将字节输入流转换为字符输入流。这意味着你可以使用InputStreamReader来读取以字节形式存储的数据（如文本文件），并将其转换为程序可以处理的字符数据。在创建InputStreamReader对象时，你可以指定一个字符集，以便正确地将字节数据转换为字符数据。 - OutputStreamWriter：这个类继承自
Writer，它的主要作用是将字符输出流转换为字节输出流。当你需要将程序处理的字符数据写回到以字节形式存储的介质（如文件）时，可以使用OutputStreamWriter。同样，在创建OutputStreamWriter对象时，你也可以指定一个字符集，以确保字符数据被正确地转换为字节数据。
使用转换流的典型场景包括：
- 当需要在不同编码格式之间转换数据时，例如，从UTF-8编码的文件中读取数据，然后将数据写入到ISO-8859-1编码的文件中。
- 当需要处理可能存在乱码问题的文件时，转换流可以帮助你指定正确的编码方式，以避免乱码现象的发生。
InputStreamReader
Java中的InputStreamReader是一个字符流类，它的主要作用是将字节输入流转换为字符输入流。
InputStreamReader类是Java I/O库中的一个重要组件，它位于java.io包中。这个类的实例可以将底层的字节输入流（实现了InputStream接口的任何对象）转换为字符输入流，使得程序可以以字符的形式读取原本以字节形式存储的数据。这种转换是通过使用指定的字符集来完成的，字符集可以由名称指定，也可以明确指定，或者使用平台的默认字符集。
以下是InputStreamReader的一些关键特性：
- 桥接器角色：
InputStreamReader充当字节流和字符流之间的桥接器，它使用指定的字符集将字节数据解码为字符数据。 - 字符集支持：在创建
InputStreamReader对象时，可以指定字符集，这允许程序正确处理不同编码格式的数据，如UTF-8、GBK等。 - 高效转换：为了实现高效的字节到字符转换，
InputStreamReader可能会从底层字节输入流中预读比当前读取操作所需更多的字节。为了获得最高效率，建议将InputStreamReader包装在BufferedReader中使用。 - 可关闭性：
InputStreamReader实现了Closeable和AutoCloseable接口，这意味着它可以被关闭以释放系统资源。 - 直接子类：
FileReader是InputStreamReader的一个直接子类，它用于将文件系统中的文件内容以字符流的形式读取。
InputStreamReader的构造函数如下：
InputStreamReader(InputStream in)
InputStreamReader(InputStream in, String charsetName)
InputStreamReader(InputStream in, Charset charset)
InputStreamReader(InputStream in, CharsetDecoder dec)
其中，in参数表示要读取的字节输入流，可以是任何实现了InputStream接口的对象，如FileInputStream、ByteArrayInputStream等。
第二个构造函数中，charsetName参数表示要使用的字符集名称，例如"UTF-8"、"GBK"等。如果省略该参数，则默认使用系统默认的字符集。
第三个构造函数中，charset参数表示要使用的字符集对象，可以使用Charset.forName()方法获取指定名称的字符集对象。
第四个构造函数中，dec参数表示要使用的字符集解码器对象，可以使用Charset.newDecoder()方法创建一个新的解码器对象。
下面是一个Java InputStreamReader的代码示例，演示了如何使用InputStreamReader将字节输入流转换为字符输入流：
import java.io.*;
public class InputStreamReaderExample {
public static void main(String[] args) {
try (FileInputStream fis = new FileInputStream("input.txt");
InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
BufferedReader br = new BufferedReader(isr)) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
上述代码中，我们首先创建了一个FileInputStream对象，用于读取名为"input.txt"的文件。然后，我们使用InputStreamReader将该文件的字节输入流转换为字符输入流，并指定字符集为"UTF-8"。最后，我们使用BufferedReader对字符输入流进行缓冲，以提高读取效率。
在循环中，我们使用readLine()方法逐行读取文件中的内容，并将其输出到控制台上。最后，我们使用try-with-resources语句来自动关闭流对象，以确保资源的正确释放。
OutputStreamWriter
Java OutputStreamWriter是一个将字符流转换为字节流的类，通常用于将字符数据写入到文件或网络流中。
以下是关于OutputStreamWriter的一些详细说明：
- 转换功能：它的主要功能是将字符数据转换为指定编码格式的字节数据，以便可以写入到各种输出流中，如文件、套接字或管道。
- 构造函数：
OutputStreamWriter提供了多个构造函数，允许用户指定不同的字符编码格式和输出流。这使得它能够适应不同的应用场景和需求。 - 实现接口：
OutputStreamWriter实现了Writer接口，继承了Flushable、Closeable和Appendable接口，这意味着它可以使用write()、flush()等方法来操作数据。 - 编码支持：它支持多种字符编码格式，如UTF-8、GBK等，这有助于确保字符数据在不同的环境中能够正确显示和处理。
- 使用方法：使用
OutputStreamWriter时，首先需要创建一个OutputStream对象，然后将其作为参数传递给OutputStreamWriter的构造函数来创建OutputStreamWriter对象。之后，就可以使用write()方法将字符数据写入到输出流中。 - 资源管理：由于
OutputStreamWriter实现了Closeable接口，它可以被关闭以释放系统资源。在操作完成后，应该调用close()方法来关闭流。
以下是一个Java OutputStreamWriter的代码示例，演示了如何使用OutputStreamWriter将字符数据写入到文件中：
import java.io.*;
public class OutputStreamWriterExample {
public static void main(String[] args) {
// 定义要写入文件的字符串
String str = "Hello, World!";
try {
// 创建FileOutputStream对象，用于写入字节数据到文件
FileOutputStream fos = new FileOutputStream("output.txt");
// 创建OutputStreamWriter对象，用于将字符数据转换为字节数据并写入到输出流中
OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
// 将字符串写入到输出流中
osw.write(str);
// 刷新输出流，确保所有数据都被写入到文件中
osw.flush();
// 关闭输出流和字符流
osw.close();
fos.close();
System.out.println("文件写入成功！");
} catch (IOException e) {
e.printStackTrace();
}
}
}
在这个示例中，我们首先创建了一个FileOutputStream对象，用于将字节数据写入到名为"output.txt"的文件中。然后，我们创建了一个OutputStreamWriter对象，并将FileOutputStream对象作为参数传递给它，同时指定了字符编码为"UTF-8"。接下来，我们使用write()方法将字符串写入到输出流中，并使用flush()方法刷新输出流以确保所有数据都被写入到文件中。最后，我们关闭了输出流和字符流。
序列化
概述
Java序列化是一种机制，它允许将实现了Serializable接口的对象转换为字节流，以便可以将其存储到磁盘上或通过网络传输，同时也可以在以后需要时恢复成原来的对象状态。
Java序列化主要涉及以下几个方面：
- 对象状态的保存：序列化过程只关注对象的状态，即实例变量的值，而不关心对象的方法。这是因为方法通常是类的一部分，而序列化主要目的是保存对象的数据。
- 继承与自动序列化：如果一个父类实现了Serializable接口，那么其子类也会自动实现序列化，无需显式地实现Serializable接口。
- 深度克隆：当一个对象的实例变量引用了其他对象时，序列化该对象会自动把这些被引用的对象也进行序列化，从而实现深度克隆。
- transient关键字：如果某个字段被声明为transient，那么在序列化过程中会被忽略。如果需要对这些字段进行特殊处理，可以通过添加writeObject和readObject方法来实现自定义的序列化和反序列化逻辑。
- 序列化与IO流：序列化是将对象写入到IO流中的过程，而反序列化是从IO流中恢复对象的过程。这一机制使得可以将实现了序列化的Java对象转换为字节序列，这些字节序列可以保存在磁盘上或通过网络传输，以达到以后恢复成原来的对象。
ObjectOutputStream
Java ObjectOutputStream 是一个可以将 Java 对象写入到输出流中的类，它允许将实现了 Serializable 接口的对象以序列化的形式写入到文件或网络中。
以下是关于 ObjectOutputStream 的一些详细信息：
构造方法：它通常与一个底层的输出流（如 FileOutputStream）一起使用，用于指定写入数据的目标位置。
ObjectOutputStream(OutputStream out)：创建一个 ObjectOutputStream，用于写入到指定的底层输出流。ObjectOutputStream(OutputStream out, ObjectStreamClass c)：创建一个 ObjectOutputStream，并指定一个自定义的ObjectStreamClass实例。
主要方法：
void writeObject(Object obj)：将指定的对象写入到输出流中。这个方法会调用对象的writeObject方法（如果定义了的话），然后序列化非静态和非瞬态字段。void writeObjectOverride(Object obj)：与writeObject类似，但允许覆盖超类中的方法。void flush()：刷新此输出流，强制任何缓冲的输出字节被写出。void close()：关闭此输出流并释放与此流关联的所有系统资源。
注意事项：
- 在使用
ObjectOutputStream时，需要确保要写入的对象实现了Serializable接口。 ObjectOutputStream提供了自动序列化机制，但如果需要更精细的控制，可以通过实现Externalizable接口来自定义序列化过程。- 在完成对象写入后，应该调用
flush()方法来确保所有数据都被写出，并且在完成后调用close()方法来释放资源。
以下是一个简单的Java ObjectOutputStream代码示例，演示了如何使用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 ObjectOutputStreamExample {
public static void main(String[] args) {
// 创建一个Person对象
Person person = new Person("张三", 30);
// 序列化对象到文件
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
oos.writeObject(person);
System.out.println("对象序列化成功");
} catch (IOException e) {
e.printStackTrace();
}
}
}
在这个示例中，我们创建了一个名为Person的类，它实现了Serializable接口。然后，我们创建了一个Person对象，并使用ObjectOutputStream将其序列化到文件中。在try-with-resources语句块中，我们创建了一个ObjectOutputStream实例，并将其与一个FileOutputStream关联起来，以便将数据写入到名为"person.ser"的文件中。最后，我们调用ObjectOutputStream的writeObject方法将Person对象写入到输出流中。
ObjectInputStream
Java ObjectInputStream 是一个可以从输入流中读取 Java 对象的类，它允许将实现了 Serializable 接口的对象以序列化的形式从文件或网络中读取出来。
以下是关于 ObjectInputStream 的一些详细信息：
构造方法：它通常与一个底层的输入流（如 FileInputStream）一起使用，用于指定读取数据的来源位置。
ObjectInputStream(InputStream in)：创建一个 ObjectInputStream，用于从指定的底层输入流中读取对象。ObjectInputStream(InputStream in, ObjectStreamClass c)：创建一个 ObjectInputStream，并指定一个自定义的ObjectStreamClass实例。
主要方法：
Object readObject()：从输入流中读取一个对象。这个方法会调用对象的readObject方法（如果定义了的话），然后反序列化非静态和非瞬态字段。void close()：关闭此输入流并释放与此流关联的所有系统资源。
注意事项：
- 在使用
ObjectInputStream时，需要确保要读取的对象实现了Serializable接口。 ObjectInputStream提供了自动反序列化机制，但如果需要更精细的控制，可以通过实现Externalizable接口来自定义反序列化过程。- 在完成对象读取后，应该调用
close()方法来释放资源。
以下是一个简单的Java ObjectInputStream代码示例，演示了如何使用ObjectInputStream从文件中读取对象：
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 ObjectInputStreamExample {
public static void main(String[] args) {
// 从文件中反序列化对象
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) {
Person person = (Person) ois.readObject();
System.out.println("对象反序列化成功");
System.out.println(person);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
在这个示例中，我们创建了一个名为Person的类，它实现了Serializable接口。然后，我们使用ObjectOutputStream将一个Person对象序列化到文件中。在try-with-resources语句块中，我们创建了一个ObjectInputStream实例，并将其与一个FileInputStream关联起来，以便从名为"person.ser"的文件中读取数据。最后，我们调用ObjectInputStream的readObject方法从输入流中读取一个对象，并将其转换为Person类型。
打印流
概述
在 Java 中，打印流（Print Stream）通常指的是 PrintStream 类，它是一个用于写入字符数据的输出流。PrintStream 提供了方便的方法来写入不同类型的数据，包括字符串、整数、浮点数等，并且能够自动将其转换为字符串形式。
以下是关于 PrintStream 的一些详细信息：
构造方法：
PrintStream(OutputStream out)：创建一个不自动冲刷的PrintStream。PrintStream(OutputStream out, boolean autoFlush)：创建一个具有指定自动冲刷设置的PrintStream。PrintStream(File file)：创建一个文件输出流，并使用该文件输出流创建PrintStream。PrintStream(String fileName)：创建一个文件输出流，并使用该文件输出流创建PrintStream。
主要方法：
void print(int b)：将指定的字节输出到流中。void print(long l)：将指定的长整型数值转换为字符串并输出到流中。void print(double d)：将指定的双精度数值转换为字符串并输出到流中。void print(char c)：将指定的字符输出到流中。void print(String s)：将指定的字符串输出到流中。void println()：输出换行符。void println(int b)：输出指定的字节并输出换行符。void println(long l)：输出指定的长整型数值并输出换行符。void println(double d)：输出指定的双精度数值并输出换行符。void println(char c)：输出指定的字符并输出换行符。void println(String s)：输出指定的字符串并输出换行符。void flush()：刷新此打印流。void close()：关闭此打印流并释放与此流关联的所有系统资源。
注意事项：
PrintStream是线程安全的，因此可以用于多线程环境中。PrintStream提供了自动冲刷功能，这意味着每次调用println方法时，都会自动刷新输出流，确保数据被写出。- 在使用完
PrintStream后，应该调用close()方法来释放资源。
示例
以下是一个简单的 Java 打印流代码示例，演示了如何使用 PrintStream 类来输出数据到控制台：
import java.io.*;
public class PrintStreamExample {
public static void main(String[] args) {
// 创建一个 PrintStream 对象，将输出重定向到控制台
PrintStream printStream = new PrintStream(System.out);
// 使用 PrintStream 对象输出数据
printStream.println("Hello, World!");
printStream.println("This is a PrintStream example.");
printStream.println("The current time is: " + System.currentTimeMillis());
// 关闭 PrintStream 对象
printStream.close();
}
}
在这个示例中，我们首先创建了一个 PrintStream 对象，并将输出重定向到控制台。然后，我们使用 println() 方法向控制台输出一些文本和时间戳。最后，我们调用 close() 方法关闭 PrintStream 对象并释放资源。
请注意，在实际应用中，我们通常不需要手动创建 PrintStream 对象，因为 Java 标准库已经提供了许多方便的打印方法，例如 System.out.println() 和 System.err.println()。但是，了解 PrintStream 类的用法可以帮助我们更好地理解 Java 中的 I/O 操作。
压缩/解压缩流
Java压缩流通常指的是用于数据压缩和解压缩的输入/输出流。
在Java中，处理压缩文件主要涉及以下几种流：
- ZipOutputStream：这个类用于写入压缩文件。它可以将多个文件或数据压缩到一个ZIP格式的压缩文件中。通常与FileInputStream配合使用，将文件内容写入到ZipOutputStream中，从而实现文件的压缩。
- ZipInputStream：这个类用于读取ZIP格式的压缩文件。通过循环调用getNextEntry()方法，可以逐个读取压缩文件中的每一个条目（ZipEntry），直到所有条目读取完毕，表示zip流结束。
- GZIPOutputStream 和 GZIPInputStream：这两个类用于读写GZIP格式的压缩文件。GZIPOutputStream用于将数据压缩成GZIP格式，而GZIPInputStream用于解压缩GZIP格式的数据。
使用这些流进行文件压缩和解压缩的好处包括节省存储空间和提高文件传输效率。在进行文件传输时，尤其是当数据量特别大或者文件数量较多时，使用压缩流可以显著减少传输时间和带宽占用。此外，当需要批量导出大文件时，使用压缩流也是一个很好的选择，因为它可以帮助优化性能和提高效率。
示例
以下是一个简单的Java压缩/解压缩流的示例代码：
import java.io.*;
import java.util.zip.*;
public class CompressDecompressExample {
public static void main(String[] args) throws IOException {
// 压缩文件
File inputFile = new File("input.txt");
File outputFile = new File("output.zip");
try (FileInputStream fis = new FileInputStream(inputFile);
FileOutputStream fos = new FileOutputStream(outputFile);
ZipOutputStream zos = new ZipOutputStream(fos)) {
ZipEntry zipEntry = new ZipEntry(inputFile.getName());
zos.putNextEntry(zipEntry);
byte[] buffer = new byte[1024];
int length;
while ((length = fis.read(buffer)) > 0) {
zos.write(buffer, 0, length);
}
zos.closeEntry();
}
// 解压缩文件
File decompressedFile = new File("decompressed.txt");
try (FileInputStream fis = new FileInputStream(outputFile);
ZipInputStream zis = new ZipInputStream(fis);
FileOutputStream fos = new FileOutputStream(decompressedFile)) {
ZipEntry zipEntry = zis.getNextEntry();
byte[] buffer = new byte[1024];
int length;
while ((length = zis.read(buffer)) > 0) {
fos.write(buffer, 0, length);
}
zis.closeEntry();
}
}
}
这个例子中，我们首先使用ZipOutputStream将一个名为input.txt的文件压缩为output.zip。然后，我们使用ZipInputStream将output.zip解压缩为decompressed.txt。
1260
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
