黑马程序员--（IO流）

---------------------- JavaEE+Android开发、JavaEE+Android培训、期待与您交流！ ----------------------

IO（Input Output）流

IO流用于处理设备之间的数据传输

java对数据的操作是通过流的方式

java用于操作流的对象都在IO包里

流按操作数据可分为两种：字节流和字符流

流按流向可分为：输入流和输出流

（1）字符流
写操作：
操作文件的Writer子类对象。FileWrite以及IO异常的处理方式

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

已有文件的数据续写：传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。
           FileWriter fw = new FileWriter("demo.txt",true);

读操作：

 import java.io.*;

class  FileReaderDemo
{
	public static void main(String[] args) throws IOException
	{
		//创建一个文件读取流对象，和指定名称的文件相关联。
		//要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException
		FileReader fr = new FileReader("demo.txt");


		//调用读取流对象的read方法。
		//read():一次读一个字符。而且会自动往下读。
		
		int ch = 0;


		while((ch=fr.read())!=-1)
		{
			System.out.println((char)ch);
		}




		/*
		while(true)
		{
			int ch = fr.read();
			if(ch==-1)
				break;
			System.out.println("ch="+(char)ch);
		}
		*/
		fr.close();
	}
}

缓冲区  BufferedReader
        BufferedWriter
缓冲区的出现是为了提高流的操作效率而出现的。
所以在创建缓冲区之前，必须要先有流对象。
该缓冲区中提供了一个跨平台的换行符：newLine();
字符读取流缓冲区：
该缓冲区提供了一个一次读一行的方法 readLine，方便于对文本数据的获取。
当返回null时，表示读到文件末尾。
readLine方法返回的时候只返回回车符之前的数据内容。并不返回回车符。


装饰设计模式
当想要对已有的对象进行功能增强时，
可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。
那么自定义的该类称为装饰类。
装饰类通常会通过构造方法接收被装饰的对象。
并基于被装饰的对象的功能，提供更强的功能。
装饰设计模式与继承的区别
MyReader//专门用于读取数据的类。
|--MyTextReader
|--MyBufferTextReader
|--MyMediaReader
|--MyBufferMediaReader
|--MyDataReader
|--MyBufferDataReader
class MyBufferReader
{
MyBufferReader(MyTextReader text)
{}
MyBufferReader(MyMediaReader media)
{}
}
上面这个类扩展性很差。
找到其参数的共同类型。通过多态的形式。可以提高扩展性。
class MyBufferReader extends MyReader
{
private MyReader r;
MyBufferReader(MyReader r)
{}
}
MyReader//专门用于读取数据的类。
|--MyTextReader
|--MyMediaReader
|--MyDataReader
|--MyBufferReader

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


现在优化思想。单独描述一下缓冲内容。
将需要被缓冲的对象。传递进来。也就是，谁需要被缓冲，谁就作为参数传递给缓冲区。
这样继承体系就变得很简单。优化了体系结构。
装饰模式比继承要灵活。避免了继承体系臃肿。
而且降低了类于类之间的关系。
装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。
所以装饰类和被装饰类通常是都属于一个体系中的。
带行号的装饰类：
FileReader fr = new FileReader("PersonDemo.java");
LineNumberReader lnr = new LineNumberReader(fr);


字节流（图片）
InputStream
OutputStream


FileInputStream
FileOutputStream


BufferedInputStream
BufferedOutputStream

import java.io.*;
class  TransStreamDemo
{
	public static void main(String[] args) throws IOException
	{
		//获取键盘录入对象。
		//InputStream in = System.in;


		//将字节流对象转成字符流对象，使用转换流。InputStreamReader
		//InputStreamReader isr = new InputStreamReader(in);


		//为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader


		//BufferedReader bufr = new BufferedReader(isr);




		//键盘的最常见写法。
		BufferedReader bufr = 
				new BufferedReader(new InputStreamReader(System.in));
		  
//		OutputStream out = System.out;
//		OutputStreamWriter osw = new OutputStreamWriter(out);
//		BufferedWriter bufw = new BufferedWriter(osw);
		BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
		String line = null;


		while((line=bufr.readLine())!=null)
		{
			if("over".equals(line))
			 	break; 
			bufw.write(line.toUpperCase());
			bufw.newLine();
			bufw.flush();
		}
		bufr.close();
	}
}

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


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


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);

2，需求：将键盘录入的数据保存到一个文件中。
这个需求中有源和目的都存在。
那么分别分析
源：InputStream Reader
是不是纯文本？是！Reader

设备：键盘。对应的对象是System.in.
不是选择Reader吗？System.in对应的不是字节流吗？
为了操作键盘的文本数据方便。转成字符流按照字符串操作是最方便的。
所以既然明确了Reader，那么就将System.in转换成Reader。
用了Reader体系中转换流,InputStreamReader


InputStreamReader isr = new InputStreamReader(System.in);

需要提高效率吗？需要！BufferedReader
BufferedReader bufr = new BufferedReader(isr);


目的：OutputStream  Writer
是否是存文本？是！Writer。
设备：硬盘。一个文件。使用 FileWriter。
FileWriter fw = new FileWriter("c.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);


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


（2）异常的日志信息
                 

                   try
			{
				PrintStream ps = new PrintStream("exeception.log");
				System.setOut(ps);				
			}
			catch (IOException ex)
			{
				throw new RuntimeException("日志文件创建失败");
			}
			e.printStackTrace(System.out);

（3）系统信息
     

  Properties prop = System.getProperties();
	//System.out.println(prop);
	prop.list(new PrintStream("sysinfo.txt"));

---------------------- JavaEE+Android开发、JavaEE+Android培训、期待与您交流！ ----------------------