java IO流(一)

IO（Input Output）流

IO流概述

在计算即中，最常见的数据存在形式是多种多样的，其中最常见的形式就是文件。而程序运行时，cpu是只能直接从内存中读取数据的。为了能操作其他数据，让不再内存中的数据，进入内存，java提供了IO流。

因此IO流有如下特点：

IO流用来处理设备之间的数据传输
Java对数据的操作是通过流的方式
Java用于操作流的对象都在IO包中
流按操作数据分为两种：字节流与字符流  
流按流向分为：输入流，输出流

IO流常用基类

字节流的抽象基类：InputStream ，OutputStream。
字符流的抽象基类：Reader ， Writer
注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。
• 如：InputStream的子类FileInputStream。
• 如：Reader的子类FileReader。

IO流书写

导入IO包中的类
 import java.io.*;
进行IO异常处理
在finally中对流进行关闭

注意：
• java有垃圾回收机制，但还要调用close方法关闭流，因为流中使用的资源是系统的IO资源，不关闭，可能会影响到其他程序的使用。
• IO异常一定要处理，因为，IO流中使用到了系统资源，系统IO异常可能导致，流的操作无法正常完成。

IO流异常处理

Try

｛

IO流操作执行语句；

｝catch(IOException e)

｛

异常处理语句；

｝

finally

｛

关闭流操作；//关闭前需判断流是否为空，且也需要使用try catch进行异常处理。

｝

异常处理实例：

import java.io.*;

class  FileWriterDemo2
{
	public static void main(String[] args) 
	{
		FileWriter fw = null;
		try
		{
			fw = new FileWriter("demo.txt");
			fw.write("abcdefg");

		}
		catch (IOException e)
		{
			System.out.println("catch:"+e.toString());
		}
		finally
		{
			try
			{
				if(fw!=null)
					fw.close();				
			}
			catch (IOException e)
			{
				System.out.println(e.toString());
			}
			
		}		

	}
}

字符流

创建对象：

1、创建流对象，建立数据存放文件
FileWriter fw = new FileWriter(“Test.txt”);
2、调用流对象的写入方法，将数据写入流
fw.write(“text”);
3、关闭流资源，并将流中的数据清空到文件中。
fw.close();
字符流读取标准代码：

FileWriter fw = null;
try{
fw = new FileWriter("Test.txt");
fw.write("text");
}
catch (IOException e){
System.out.println(e.toString());
}
finally{
If(fw!=null)
try{
fw.close();
}
catch (IOException e){
System.out.println(e.toString());
}
}

读取文件：

建立一个流对象，将已存在的一个文件加载进流。

FileReader fr = new FileReader(“Test.txt”);
创建一个临时存放数据的数组。

char[] ch = new char[1024];
调用流对象的读取方法将流中的数据读入到数组中

fr.read(ch);

字符流读取标准代码：

FileReader fr = null;
try{
<span style="white-space:pre">	</span>fr = new FileReader("c:\\test.txt");
<span style="white-space:pre">	</span>char[] buf = new char[1024];
<span style="white-space:pre">	</span>int len= 0;
<span style="white-space:pre">	</span>while((len=fr.read(buf))!=-1){
<span style="white-space:pre">		</span>System.out.println(new String(buf,0,len));
<span style="white-space:pre">	</span>}
}
catch (IOException e){
<span style="white-space:pre">	</span>System.out.println("read-Exception :"+e.toString());
}
finally{
<span style="white-space:pre">	</span>if(fr!=null){
<span style="white-space:pre">		</span>try{
<span style="white-space:pre">		</span>fr.close();
<span style="white-space:pre">		</span>}
<span style="white-space:pre">		</span>catch (IOException e){
<span style="white-space:pre">			</span>System.out.println("close-Exception :"+e.toString());
<span style="white-space:pre">		</span>}
<span style="white-space:pre">	</span>}
}

注意：

1）定义文件路径时，可以用“/”或者“\\”。
2）在创建一个文件时，如果目录下有同名文件将被覆盖。
3）在读取文件时，必须保证该文件已存在，否则出异常。

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

缓冲字符流

缓冲区的出现提高了对数据的读写效率
对应类
BufferedWriter
BufferedReader
缓冲区要结合流才可以使用。
在流的基础上对流的功能进行了增强。

装饰设计模式

当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。那么自定义的该类称为装饰类。装饰类通常会通过构造方法接收被装饰的对象。并基于被装饰的对象的功能，提供更强的功能。

以前是通过继承将每一个子类都具备缓冲功能。那么继承体系会复杂，并不利于扩展。现在优化思想。单独描述一下缓冲内容。将需要被缓冲的对象。传递进来。也就是，谁需要被缓冲，谁就作为参数传递给缓冲区。这样继承体系就变得很简单。优化了体系结构。装饰模式比继承要灵活。避免了继承体系臃肿。而且降低了类于类之间的关系。装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。所以装饰类和被装饰类通常是都属于一个体系中的。

装饰修饰类与继承的区别：

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

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

现在优化思想。单独描述一下缓冲内容。
将需要被缓冲的对象。传递进来。也就是，谁需要被缓冲，谁就作为参数传递给缓冲区。
这样继承体系就变得很简单。优化了体系结构。

装饰模式比继承要灵活。避免了继承体系臃肿。
而且降低了类于类之间的关系。

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

字节流
1、基本操作与字符流类相同

2、字节流主要是以字节为单位操作数据
3、但它不仅可以操作字符，还可以操作其他  媒体文件