黑马程序员 IO流-->字符流

------- android培训、java培训、期待与您交流！ ----------

  IO流的简单介绍

1、IO流用来处理设备之间的数据传输；

2、Java对数据的操作是通过流的方式；

3、流按流向分为：输入流和输出流，按操作数据分为：字节流和字符流；

4、IO流的四个抽象基类：字节流 InputStream OutputStream 字符流 Reader Writer

什么是输入流和输出流？

输入流和输出流均是相对于程序而言的，可以理解为从磁盘等往程序中读入数据则是输入流，从程序中往磁

盘文件中写入数据则是输出流。

什么是字节流和字符流？

字节流操作数据是以字节为单位，可以处理一些媒体数据，而一个中文最少占两个字节，如果用字节流操作

中文读入写出的是中文的一半，将会出现不可识别的乱码，所以针对一些文字数据，jdk中提供了可供操作文

字数据的字符流，字符流对象中融合了当前系统默认的码表，操作字符的时候会在码表中找到对应的数据。

字符流

数据的最常见体现形式就是文件，我们可以使用Reader和Writer下的FileReader和FileWriter来操作数据。

怎么从一个文件中往程序中读入数据：

1、创建文件输入流对象，并和指定名称的文件相关联；

2、使用对象的read等方法读入数据；

3、关闭流对象。

示例：

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FileReaderDemo {

	public static void main(String[] args) {
		FileReader reader = null;
		// 由于IO流在操作数据时会抛出异常，我们应该捕获并进行相应的操作
		try {
			// 创建一个文件读取流对象，并和指定名称的文件相关联，如果文件不存在系統会抛出

			// FileNotFoundException异常
			reader = new FileReader("demo.txt");
			
			/*
			int ch = -1;
			// read()一次读一个字符，当数据读完时会返回-1
			while ((ch = reader.read()) != -1) {
			    // 每读入一个字符就在控制台打印一个字符
				System.out.println("ch=" + (char) ch);
			}
			*/
			
			// 定义一个字符数组，用于存储读到字符
			char[] chArr = new char[1024];
			// 用于存储读入char数组中字符的个数
			int len = -1;
			while ((len = reader.read(chArr)) != -1) {
				// 打印读入数组中的所有字符组成的字符串
				System.out.println(new String(chArr, 0, len));
			}
			// 在关闭流资源前可以先刷新一下，把流中的数据刷入目的地
			// 仅使用此方法时并不关闭流资源
			// reader.flush();
		} catch (FileNotFoundException e) {
			System.out.println("文件读取失败");
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				// 关闭流资源
				reader.close();
			} catch (IOException e) {
				System.out.println("关闭流资源失败");
			}
		}
	}
}

怎么从程序往一个文件中写入数据：

1、创建文件输出流对象；

2、使用对象的write等方法写入数据；

3、关闭流对象。

示例：

import java.io.FileWriter;
import java.io.IOException;

public class FileWriterDemo {

	public static void main(String[] args) {
		FileWriter writer = null;
		try {
			// 创建一个输出流对象，会在指定目录下创建此文件
			// 如果该目录下有同名文件，将会被覆盖。
			writer = new FileWriter("demo.txt");
			// 如果存在此文件，想要在内容后面续写，传入FileWriter构造方法的第二个参数为true即可
			// writer = new FileWriter("demo.txt",true);

			// 可以直接写入字符串
			writer.write("afdhdj");
			// 刷新流对象中的缓冲的数据，流仍然存在
			// writer.flush();

		} catch (IOException e) {
			System.out.println("写入资源失败");
		} finally {
			try {
				if (writer != null) {
					// 关闭流资源
					writer.close();
				}
			} catch (IOException e) {
				System.out.println("关闭流资源失败");
			}
		}
	}
}

练习：将C盘一个文本文件复制到D盘。

原理：复制文件其实就是将指定的源文件读入内存中再写入到目标文件

示例：

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyDemo {

	public static void main(String[] args) {
		FileWriter writer = null;
		FileReader reader = null;
		try {
			// 创建输出流对象，并指定目标文件
			writer = new FileWriter("d:\\demo.txt");
			// 创建输入流对象，并与要操作的文件相关联
			reader = new FileReader("c:\\demo.txt");
			/* 方法1
			int ch = -1;
			// 每从源文件中读取到一个字符就写入到目标文件中
			while ((ch = reader.read()) != -1) {
				writer.write(ch);
			}
			*/
			
			// 方法2
			char[] buf = new char[1024];
			// 读入buf中的字符个数
			int len = -1;
			while((len = reader.read(buf))!=-1){
				writer.write(buf, 0, len);
			}
		} catch (IOException e) {
			System.out.println("文件读写失败");
		} finally {
			// 关闭流资源
			if (writer != null) {
				try {
					writer.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (reader != null) {
				try {
					reader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

第一种方法读取一个字符就写入目标文件一个字符，而第二种方法是先把读取的字符存入一个缓冲区，存满

后一次性写入到目标文件中，这样可以避免对文件系统的多次读写，从而提高效率，所以建议使用第二种方法。

字符流的缓冲区

简单介绍：

字符流的缓冲区就是对字符流的一种处理流BufferedReader和BufferedWriter，处理流对象中封装了数组，

将数据存入，再一次性取出。其实处理流就是运用了设计模式中的装饰模式，对已有对象的功能进行增强，

所以处理流必须要有要增强功能的流对象，即构造方法中需要传入相应的输入或输出流对象。

缓冲区的出现提高了流的读写效率

练习：使用处理流来拷贝文件，提高效率。

示例：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyByBuffer {

	public static void main(String[] args) {
		// 声明输入输出流对象
		FileWriter writer = null;
		FileReader reader = null;
		// 声明处理流对象
		BufferedWriter bufWriter = null;
		BufferedReader bufReader = null;
		try {
			// 创建输出流对象，并指定目标文件
			writer = new FileWriter("d:\\demo.txt");
			// 创建输入流对象，并与要操作的文件相关联
			reader = new FileReader("c:\\demo.txt");

			// 创建处理流对象，并把要增强功能的输出流对象传入
			bufWriter = new BufferedWriter(writer);
			bufReader = new BufferedReader(reader);
			// 读入内存中的数据
			String line = null;
			// 每次从流中读一行到line中
			while ((line = bufReader.readLine()) != null) {
				// 将内存中的数据写入流中
				bufWriter.write(line);
				// 换行
				bufWriter.newLine();
				// 将流中的数据刷新到指定文件中
				bufWriter.flush();
			}

		} catch (IOException e) {
			System.out.println("文件读写失败");
		} finally {
			// 关闭流资源
			if (bufWriter != null) {
				try {
					bufWriter.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (bufReader != null) {
				try {
					bufReader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

注意：

1>缓冲流要结合流才可以使用，它只是在流的基础上对流的功能进行了增强；

2>缓冲流提供了一个跨平台的行分隔符：newLine()；

3>BufferedReader提供了一个一次读取一行的方法readLine();方便于对文本数据的读取；

4>readLine读取的数据不包含任何行终止符，当返回null时，表示读到文件末尾；

5>关闭缓冲流对象即是关闭了它处理的流对象资源，因为缓冲流其实就是在内存中创建一个缓冲的区域，

先把数据存入缓冲区，再进行多个字符的读写以提高文本数据的读写效率，当使用close的时候，实际上

在方法的内部关闭的是构造方法时传入的流对象，而readLine()方法实现的最终原理也是从硬盘一个一个

的读入缓冲流对象封装的字符数组，当读到行终止符时以字符串的形式返回读到的数据。

下面就readLine的原理自定义一个类MyBufferedReader，包含与readLine相同功能的方法。

示例：

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

/**
 * 自定义一个功能与BufferedReader相似的类，继承Reader 对象中包含一个输入流对象
 */
class MyBufferedReader extends Reader {
	private Reader r;

	// 构造方法，需要传入一个输入流对象
	// 这里用到了多态，父类引用指向子类对象
	public MyBufferedReader(Reader r) {
		this.r = r;
	}

	@Override
	public int read(char[] cbuf, int off, int len) throws IOException {
		// 直接调用的是输入流对象的方法
		return r.read(cbuf, off, len);
	}

	@Override
	public void close() throws IOException {
		// 从这也可以看出，当调用缓冲区的close的方法时，直接关闭的是传入的输入流的资源
		r.close();
	}

	// 重写一个方法来实现readLine方法的功能,并抛出异常由调用者去处理
	public String myReadLine() throws IOException {
		// 定义一个缓冲区，readLine是用数组来实现的
		StringBuilder builder = new StringBuilder();

		int ch = -1;
		while ((ch = r.read()) != -1) {
			// 如果读到\r字符，则继续读下个字符，并不存入缓冲区
			if (ch == '\r') {
				continue;
			}
			if (ch == '\n') {
				// 当读到换行符时，将缓冲区中的数据以字符串形式返回
				return builder.toString();
			} else {
				// 将读取的字符存入缓冲区
				builder.append((char) ch);
			}
			// 如果最后一行并没有行终止符，那么将缓冲区的数据返回
			if (builder != null) {
				return builder.toString();
			}
		}
		// 读到结尾，返回null
		return null;
	}
}


// 测试类
public class MyBufferedDemo {

	public static void main(String[] args) {

		MyBufferedReader bufferedReader = null;

		try {
			// 创建一个自定义的缓冲流
			bufferedReader = new MyBufferedReader(new FileReader("demo.txt"));

			String line = null;
			// 使用自己创建的方法来读取一行的数据
			while ((line = bufferedReader.myReadLine()) != null) {
				System.out.println(line);
			}
		} catch (FileNotFoundException e) {
			System.out.println("文件读取失败");
		} catch (IOException e) {
			System.out.println("文件读取失败");
		} finally {
			// 关闭流资源
			try {
				bufferedReader.close();
			} catch (IOException e) {
				System.out.println("关闭流资源失败");
			}
		}
	}
}

最后：流一般都是以一对的形式存在的，有输入流就有输出流，例如：FileInputStream和FileOutputStream，

DataInputStream和DataOutputStream等。