Java网络编程（二）流

**Java网络编程（二）- 流**

在上一篇文章中，我们讨论了Java网络编程的基本概念，包括Socket、ServerSocket等类。今天我们将继续讨论Java网络编程中的流。

**什么是流？**

在计算机科学中，流（Stream）是一个抽象概念，它代表一个数据序列。在Java中，流通常指的是一个字节序列或字符序列。

**Java中的流**

Java提供了两个主要的流类：`InputStream`和`OutputStream`。这两个类都是抽象类，分别表示输入流和输出流。

### InputStream`InputStream`接口定义了以下方法：

* `read()`:读取一个字节。
* `read(byte[] b)`:读取多个字节到指定的数组中。
* `available()`:返回可以立即读取的字节数。
* `skip(long n)`:跳过指定数量的字节。

### OutputStream`OutputStream`接口定义了以下方法：

* `write(int b)`:写入一个字节。
* `write(byte[] b, int off, int len)`:写入多个字节到指定的数组中。
* `flush()`:将缓冲区中的数据写入输出流。

### FileInputStream和FileOutputStream`FileInputStream`和`FileOutputStream`是Java提供的两个具体实现类，分别用于读取文件和写入文件。

javaimport java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class FileIOExample {
 public static void main(String[] args) throws Exception {
 //读取文件 FileInputStream fis = new FileInputStream("input.txt");
 byte[] data = new byte[1024];
 int len = fis.read(data);
 while (len != -1) {
 System.out.println(new String(data,0, len));
 len = fis.read(data);
 }
 fis.close();

 // 写入文件 FileOutputStream fos = new FileOutputStream("output.txt");
 String str = "Hello, World!";
 byte[] bytes = str.getBytes();
 fos.write(bytes);
 fos.flush();
 fos.close();
 }
}

### ByteArrayInputStream和ByteArrayOutputStream`ByteArrayInputStream`和`ByteArrayOutputStream`是Java提供的两个具体实现类，分别用于读取字节数组和写入字节数组。

javaimport java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;

public class ByteArrayIOExample {
 public static void main(String[] args) throws Exception {
 //读取字节数组 byte[] data = "Hello, World!".getBytes();
 ByteArrayInputStream bis = new ByteArrayInputStream(data);
 int len = bis.read();
 while (len != -1) {
 System.out.println((char) len);
 len = bis.read();
 }

 // 写入字节数组 ByteArrayOutputStream bos = new ByteArrayOutputStream();
 String str = "Hello, World!";
 byte[] bytes = str.getBytes();
 bos.write(bytes);
 byte[] result = bos.toByteArray();
 System.out.println(new String(result));
 }
}

### PipedInputStream和PipedOutputStream`PipedInputStream`和`PipedOutputStream`是Java提供的两个具体实现类，分别用于读取管道输入流和写入管道输出流。

javaimport java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class PipeIOExample {
 public static void main(String[] args) throws Exception {
 //读取管道输入流 PipedInputStream pis = new PipedInputStream();
 PipedOutputStream pos = new PipedOutputStream(pis);
 String str = "Hello, World!";
 byte[] bytes = str.getBytes();
 pos.write(bytes);
 pos.close();

 int len = pis.read();
 while (len != -1) {
 System.out.println((char) len);
 len = pis.read();
 }

 // 写入管道输出流 PipedOutputStream pos2 = new PipedOutputStream();
 PipedInputStream pis2 = new PipedInputStream(pos2);
 String str2 = "Hello, World!";
 byte[] bytes2 = str2.getBytes();
 pis2.write(bytes2);
 int len2 = pis2.read();
 while (len2 != -1) {
 System.out.println((char) len2);
 len2 = pis2.read();
 }
 }
}

### FilterInputStream和FilterOutputStream`FilterInputStream`和`FilterOutputStream`是Java提供的两个抽象类，分别用于过滤输入流和输出流。

javaimport java.io.FilterInputStream;
import java.io.FilterOutputStream;

public class FilterIOExample {
 public static void main(String[] args) throws Exception {
 // 过滤输入流 FilterInputStream fis = new FilterInputStream(new FileInputStream("input.txt")) {
 @Override public int read() throws IOException {
 return super.read();
 }
 };
 byte[] data = new byte[1024];
 int len = fis.read(data);
 while (len != -1) {
 System.out.println(new String(data,0, len));
 len = fis.read(data);
 }

 // 过滤输出流 FilterOutputStream fos = new FilterOutputStream(new FileOutputStream("output.txt")) {
 @Override public void write(int b) throws IOException {
 super.write(b);
 }
 };
 String str = "Hello, World!";
 byte[] bytes = str.getBytes();
 fos.write(bytes);
 fos.flush();
 fos.close();
 }
}

### CheckedInputStream和CheckedOutputStream`CheckedInputStream`和`CheckedOutputStream`是Java提供的两个具体实现类，分别用于检查输入流和输出流。

javaimport java.io.CheckedInputStream;
import java.io.CheckedOutputStream;

public class CheckIOExample {
 public static void main(String[] args) throws Exception {
 // 检查输入流 CheckedInputStream cis = new CheckedInputStream(new FileInputStream("input.txt"));
 byte[] data = new byte[1024];
 int len = cis.read(data);
 while (len != -1) {
 System.out.println(new String(data,0, len));
 len = cis.read(data);
 }

 // 检查输出流 CheckedOutputStream cos = new CheckedOutputStream(new FileOutputStream("output.txt"));
 String str = "Hello, World!";
 byte[] bytes = str.getBytes();
 cos.write(bytes);
 cos.flush();
 cos.close();
 }
}

### CipherInputStream和CipherOutputStream`CipherInputStream`和`CipherOutputStream`是Java提供的两个具体实现类，分别用于加密输入流和输出流。

javaimport java.io.CipherInputStream;
import java.io.CipherOutputStream;

public class CipherIOExample {
 public static void main(String[] args) throws Exception {
 // 加密输入流 CipherInputStream cis = new CipherInputStream(new FileInputStream("input.txt"), "AES");
 byte[] data = new byte[1024];
 int len = cis.read(data);
 while (len != -1) {
 System.out.println(new String(data,0, len));
 len = cis.read(data);
 }

 // 加密输出流 CipherOutputStream cos = new CipherOutputStream(new FileOutputStream("output.txt"), "AES");
 String str = "Hello, World!";
 byte[] bytes = str.getBytes();
 cos.write(bytes);
 cos.flush();
 cos.close();
 }
}

### DataInputStream和DataOutputStream`DataInputStream`和`DataOutputStream`是Java提供的两个具体实现类，分别用于读取数据输入流和写入数据输出流。

javaimport java.io.DataInputStream;
import java.io.DataOutputStream;

public class DataIOExample {
 public static void main(String[] args) throws Exception {
 //读取数据输入流 DataInputStream dis = new DataInputStream(new FileInputStream("input.txt"));
 int len = dis.readInt();
 while (len != -1) {
 System.out.println(len);
 len = dis.readInt();
 }

 // 写入数据输出流 DataOutputStream dos = new DataOutputStream(new FileOutputStream("output.txt"));
 String str = "Hello, World!";
 byte[] bytes = str.getBytes();
 dos.write(bytes);
 dos.flush();
 dos.close();
 }
}

### ObjectInputStream和ObjectOutputStream`ObjectInputStream`和`ObjectOutputStream`是Java提供的两个具体实现类，分别用于读取对象输入流和写入对象输出流。

javaimport java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class ObjectIOExample {
 public static void main(String[] args) throws Exception {
 //读取对象输入流 ObjectInputStream ois = new ObjectInputStream(new FileInputStream("input.txt"));
 String str = (String) ois.readObject();
 System.out.println(str);

 // 写入对象输出流 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("output.txt"));
 String str2 = "Hello, World!";
 oos.writeObject(str2);
 oos.flush();
 oos.close();
 }
}

### PrintStream和PrintWriter`PrintStream`和`PrintWriter`是Java提供的两个具体实现类，分别用于写入输出流和打印输出流。

javaimport java.io.PrintStream;
import java.io.PrintWriter;

public class