黑马程序员-------java基础 IO流<一>

                          ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

IO(InputOutput)流


1. 概述
IO流用来处理设备之间的数据传输
Java对数据的操作是通过流的方式
流按操作数据分为两种：字节流与字符流
流按流向分为：输入流，输出流




字节流两个基类：
InputStream   OutputStream


字符流两个基类：
Reader Writer


Writer 重载了很多写的方式:
abstract  void write(char[] cbuf, int off, int len) 
          写入字符数组的某一部分。 (由Writer的子类去覆盖该方法)
void write(int c) 
 写入单个字符。 
void write(String str) 
 写入字符串。 
void write(String str, int off, int len) 
 写入字符串的某一部分。 



例子:

/*需求:在硬盘上，创建一个文件并写入一些文字数据。
找到一个专门用于操作文件的Writer子类对象。FileWriter。  后缀名是父类名。 前缀名是该流对象的功能。
在

异常是没有处理的.
*/
import java.io.*;

class Test {

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

		/*
		 * 创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。
		 * 而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。 其实该步就是在明确数据要存放的目的地。
		 */
		FileWriter fw = new FileWriter("demo.txt");
		
		//调用write方法，将字符串写入到流中。
		fw.write("www.itheima.com");
		
		//刷新流对象中的缓冲中的数据。将数据刷到目的地中。
		fw.flush();
		
		/*
		 * 关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。将数据刷到目的地中。和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。
		 */
		fw.close();
	}
}

/*IO异常的处理方式*/
import java.io.*;

class Test {

	public static void main(String[] args) {

		FileWriter fw = null;
		try {
			/*
			 * 创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。
			 * 而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。 其实该步就是在明确数据要存放的目的地。
			 */
			fw = new FileWriter("demo.txt");
			
			//调用write方法，将字符串写入到流中。
			fw.write("www.itheima.com");
			
			//刷新流对象中的缓冲中的数据。将数据刷到目的地中。
			fw.flush();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				/*
				 * 关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。将数据刷到目的地中。和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。
				 */
				if (fw != null)
					fw.close();
				
			} catch (IOException e2) {
				e2.printStackTrace();
			}
			
		}
	}

/*
在原有的数据上追加新的数据
使用构造函数 FileWriter("filename",true);
需要换行时
在write()中添加换换行符标志 Windows下的换行标准"\r\n",Linux下的换行是"\r"或者"\n"

*/

//数据的读取
class Test {

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

		/*
		 * 读取demo.txt文件中的内容
		 */
		FileReader fr = new FileReader("demo.txt");
		
		/*
		 * 读取的方式一,每读取一个就向控制台上输出,效率低
		 */
		int ch = 0;
		while ((ch=fr.read()) != -1) {
			System.out.print((char)ch);
		}
		
		/*
		 * 读取方式二,定义一个缓冲区,读取到的数据先传入缓冲区,缓冲区满了再一次性写,高效
		 */
		char[] buf = new char[1024];
		int len = 0;
		
		while ((len=fr.read(buf)) != -1) {
			System.out.print(new String(buf,0,len));
		}
		
		/*
		 * 关闭流
		 */
		fr.close();
	}
}

//通过缓存复制一个文本:
class Test {
	/*
	通过缓冲区复制一个.txt文件。
	*/
	public static void main(String[] args) {
		
		//定义字符输入缓冲流
		BufferedReader bufr = null;
		//定义字符输出缓冲流
		BufferedWriter bufw = null;
		
		try {
			bufr = new BufferedReader(new FileReader("demo.txt"));
			bufw = new BufferedWriter(new FileWriter("demo_copy.txt"));
			
			//接收读入的数据
			String temp = null;
			while ((temp=bufr.readLine()) != null) {
				bufw.write(temp);
				bufw.newLine();
			}
		} catch (IOException e) {
			throw new RuntimeException(e);
		} finally {
			try {
				if (bufr != null)
					bufr.close();
				if (bufw != null)
					bufw.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

装饰设计模式：
当想要对已有的对象进行功能增强时，
可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。
那么自定义的该类称为装饰类。


装饰类通常会通过构造方法接收被装饰的对象。
并基于被装饰的对象的功能，提供更强的功能。

import java.io.*;

/*
 * 来模拟一下BufferedReader,MyBufferedReader中有一个增强功能的方法,MyReadLine();读一行的方法
 */
class MyBufferedReader extends Reader {

	private Reader r;

	MyBufferedReader(Reader r) {
		this.r = r;
	}

	// 可以一次读一行数据的方法。
	public String myReadLine() throws IOException {
		// 定义一个临时容器。原BufferReader封装的是字符数组。
		// 为了演示方便。定义一个StringBuilder容器。因为最终还是要将数据变成字符串。
		StringBuilder sb = new StringBuilder();
		int ch = 0;
		while ((ch = r.read()) != -1) {
			if (ch == '\r')
				continue;
			if (ch == '\n')
				return sb.toString();
			else
				sb.append((char) ch);
		}

		if (sb.length() != 0)
			return sb.toString();
		return null;
	}

	/*
	 * 覆盖Reader类中的抽象方法。
	 */
	public int read(char[] cbuf, int off, int len) throws IOException {
		return r.read(cbuf, off, len);
	}

	public void close() throws IOException {
		r.close();
	}

	public void myClose() throws IOException {
		r.close();
	}
}

class Test {
	/*
	 * 通过缓冲区复制一个.txt文件。
	 */
	public static void main(String[] args) throws IOException {
		FileReader fr = new FileReader("demo.txt");

		MyBufferedReader myBuf = new MyBufferedReader(fr);

		String line = null;

		while ((line = myBuf.myReadLine()) != null) {
			System.out.println(line);
		}

		myBuf.myClose();
	}
}

装饰设计模式的体系结构:
装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。
所以装饰类和被装饰类通常是都属于一个体系中的。


如:
MyReader//专门用于读取数据的类。
|--MyTextReader
|--MyMediaReader
|--MyDataReader
|--MyBufferReader//新添的装饰类,带缓存的读取数据类,可以提高效率


与继承相比:
以前是通过继承将每一个子类都具备缓冲功能。
那么继承体系会复杂，并不利于扩展。


现在优化思想。单独描述一下缓冲内容。
将需要被缓冲的对象。传递进来。也就是，谁需要被缓冲，谁就作为参数传递给缓冲区。
这样继承体系就变得很简单。优化了体系结构。
装饰设计模式优点:
装饰模式比继承要灵活。避免了继承体系臃肿。
而且降低了类于类之间的关系。

选用流的判断方式:

需求:
练习：将一个文本数据打印在控制台上。要按照以上格式自己完成三个明确。


1,
源：键盘录入。
目的：控制台。


2，需求：想把键盘录入的数据存储到一个文件中。
源：键盘。
目的：文件。


3，需求：想要将一个文件的数据打印在控制台上。
源：文件。
目的：控制台。


流操作的基本规律：


通过三个明确来完成。


1，明确源和目的。
源：输入流。InputStream  Reader
目的：输出流。OutputStream  Writer。
2，操作的数据是否是纯文本。
是：字符流。
不是：字节流。


3，当体系明确后，在明确要使用哪个具体的对象。
通过设备来进行区分：
源设备：内存，硬盘。键盘
目的设备：内存，硬盘，控制台。



1，将一个文本文件中数据存储到另一个文件中。复制文件。
源：因为是源，所以使用读取流。InputStream Reader 
是不是操作文本文件。
是！这时就可以选择Reader
这样体系就明确了。


接下来明确要使用该体系中的哪个对象。
明确设备：硬盘。上一个文件。
Reader体系中可以操作文件的对象是 FileReader


是否需要提高效率：是！。加入Reader体系中缓冲区 BufferedReader.


FileReader fr = new FileReader("a.txt");
BufferedReader bufr = new BufferedReader(fr);



目的：OutputStream Writer
是否是纯文本。
是！Writer。
设备：硬盘，一个文件。
Writer体系中可以操作文件的对象FileWriter。
是否需要提高效率：是！。加入Writer体系中缓冲区 BufferedWriter

FileWriter fw = new FileWriter("b.txt");
BufferedWriter bufw = new BufferedWriter(fw);




**************
扩展一下，想要把录入的数据按照指定的编码表（utf-8），将数据存到文件中。

目的：OutputStream  Writer
是否是存文本？是！Writer。
设备：硬盘。一个文件。使用 FileWriter。
但是FileWriter是使用的默认编码表。GBK.

但是存储时，需要加入指定编码表utf-8。而指定的编码表只有转换流可以指定。
所以要使用的对象是OutputStreamWriter。
而该转换流对象要接收一个字节输出流。而且还可以操作的文件的字节输出流。FileOutputStream


OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");


需要高效吗？需要。
BufferedWriter bufw = new BufferedWriter(osw);


所以，记住。转换流什么使用。字符和字节之间的桥梁，通常，涉及到字符编码转换时，
需要用到转换流。