黑马程序员-IO流（打印流、管道流、合并流）

-----------android培训、java培训、java学习型技术博客、期待与您交流！
------------

  

一、 打印流

1、概述：

 

（1）打印流包括：PrintStream和PrintWriter

（2）该流提供了打印方法，可将各种类型的数据都原样打印

 

2、字节打印流：PrintStream

      构造方法中可接收的参数类型：

（1）file对象：File

（2）字符串路径：String

（3）字符输出流：OutputStream

 

3、字符串打印流：PrintWriter

      构造方法中可接受的参数类型

（1）file对象：File

（2）字符串路径：String

（3）字节输出流：OutputStream

（4）字符输出流：Writer

 

4、代码示例：

import java.io.*;

class PrintDemo {
public static void main(String[] args) throws IOException {
// 键盘录入，创建读取流对象
BufferedReader bufr = new BufferedReader(new InputStreamReader(
System.in));
// 使用打印流，将文件输出
// 输出到屏幕
PrintWriter out = new PrintWriter(new FileWriter("a.txt"), true);
String line = null;
while ((line = bufr.readLine()) != null) {
if ("over".equals(line))
break;
out.println(line.toUpperCase());
// out.flush();
}
bufr.close();
out.close();
}
}

 

 

二、管道流

1、概述：

管道流主要用于连接两个线程间的通信，输入输出可以直接进行连接，通过结合线程使用。

字节流：PipedInputStream，PipedOutputStream

字符流：PipedReader，PipedWriter

2、使用步骤：

（1）要先创建一个读和写的两个类，实现Runnable接口，因为是两个不同的线程，覆盖run方法，注意，需要在内部抛异常

（2）创建两个管道流，并用connect()方法将两个流连接

（3）创建读写对象，并传入两个线程内，并start执行

 

3、代码示例：

import java.io.*;

class Read implements Runnable {
private PipedInputStream in;// 建立输入管道

Read(PipedInputStream in) {
this.in = in;
}

public void run()// 覆盖run方法，不能throw，只能try。
{
try {

// 读取写入的数据
System.out.println("开始写入数据，等待时间");// 测试用
Thread.sleep(3000);
byte[] buf = new byte[1024];

System.out.println("读取前。。没有数据阻塞");
int len = in.read(buf);
System.out.println("读到数据。。阻塞结束");

String s = new String(buf, 0, len);// 变成字符串

System.out.println(s);

in.close();

} catch (Exception e) {
throw new RuntimeException("管道读取流失败");
}
}
}

class Write implements Runnable {
private PipedOutputStream out;// 建立输出管道

// Write构造函数
Write(PipedOutputStream out) {
this.out = out;
}

public void run() {
try {
System.out.println("开始写入数据，等待6秒后。");// 测试用
Thread.sleep(6000);
out.write("管道流来喽~~~~".getBytes());// 字节流
out.close();
} catch (Exception e) {
throw new RuntimeException("管道输出流失败");
}
}
}

class PipedStreamDemo {
public static void main(String[] args) throws IOException {

PipedInputStream in = new PipedInputStream();
PipedOutputStream out = new PipedOutputStream();// 创建管道流

// 将读取流（输入流）和写入流（输出流）关联起来
in.connect(out);// 连接管道输入流和输出流

// 创建读写对象，并创建线程对象
Read r = new Read(in);
Write w = new Write(out);// 创建Runnable子类对象
new Thread(r).start();
new Thread(w).start();// 开启线程
}
}

/*output:
开始写入数据，等待时间
开始写入数据，等待6秒后。
读取前。。没有数据阻塞
读到数据。。阻塞结束
管道流来喽~~~~
*/

 

三、合并流

 

1、概述：

（1）SequenceInputStream可以将多个流连接成一个源

（2）构造函数：SequenceInputStream(Enumeration<? extends FileInputStream> e)

 

2、如何合并多个文件：

（1）创建集合，并将流对象添加进集合

（2）创建Enumeration对象，将集合元素加入。

（3）创建SequenceInputStream对象，合并流对象

（4）创建写入流对象，FileOutputStream，将数据写入流资源

（5）定义数组，将读取流数据存入数组，并将数组中元素写入文件中。

 

思路：

合并文件的时候，要用到集合，而Vector的效率太低，所以选择用ArrayList。

读取要用序列流SequenceInputStream。但该序列流要传入枚举类型的参数。 

而枚举是Vector中的方法，ArrayList 中没有枚举方法，只有相似的Iterator迭代器。

故可建立枚举的匿名类，复写类中的方法以返回调用Iterator的方法即可。 

 

注：匿名内部类访问的局部变量要用final修饰。  

 

代码示例：假设有三个文件，将三者合并到一个新文件中

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

class SequenceDemo {
// 合并流对象
public static void sequenceFile() throws IOException {
FileOutputStream fos = null;
SequenceInputStream sis = null;
try {
// 创建集合，存储多个文件
ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
for (int i = 1; i <= 3; i++) {
al.add(new FileInputStream(i + ".txt"));
}
// 匿名内部类访问局部变量要final
final Iterator<FileInputStream> it = al.iterator();
// 创建Enumeration匿名对象
Enumeration<FileInputStream> en = new Enumeration<FileInputStream>() {
public boolean hasMoreElements() {
return it.hasNext();
}

public FileInputStream nextElement() {
return it.next();
}
};
// 合并流对象，将集合元素加入。
sis = new SequenceInputStream(en);
// 创建写入流对象，FileOutputStream
fos = new FileOutputStream("7.bmp");
byte[] b = new byte[1024 * 1024];
int len = 0;
// 循环，将数据写入流资源
while ((len = sis.read(b)) != -1) {
fos.write(b);
}

} catch (IOException e) {
throw new RuntimeException("文件操作失败");
}
// 关闭流资源
finally {
try {
if (fos != null)
fos.close();
} catch (IOException e) {
throw new RuntimeException("关闭流资源操作失败");
}
try {
if (sis != null)
sis.close();
} catch (IOException e) {
throw new RuntimeException("关闭流资源操作失败");
}
}
}

public static void main(String[] args) throws IOException {
sequenceFile();
}
}

 

3、切割流资源：

1、先关联文件FileInputStream

2、定义写入流变量：FileOutputStream

3、创建数组，并定义切割所需的大小|

4、循环读写数据，并每次创建一个新写入流，创建完后并写入文件中

5、关闭流资源

 

代码示例：

import java.io.*;

public class SplitFile {

// 切割流对象
public static void splitFile() throws IOException {
// 创建全局变量
FileInputStream fis = null;
FileOutputStream fos = null;
try {
// 创建文件读取流
fis = new FileInputStream("11.jpg");
// 创建数组
byte[] b = new byte[1024 * 1024];
int len = 0;
// 计数器
int count = 1;
// 循环写入数据
while ((len = fis.read(b)) != -1) {
// 每次创建一个新写入流，写入后关闭流资源
fos = new FileOutputStream((count++) + ".part");
fos.write(b, 0, len);
fos.close();
}
} catch (IOException e) {
throw new RuntimeException("关闭流资源操作失败");
}
// 关闭流资源
finally {
try {
if (fis != null)
fis.close();
} catch (IOException e) {
throw new RuntimeException("关闭流资源操作失败");
}
}

}

public static void main(String[] args) throws Exception {
splitFile();
}
}