黑马程序员----------IO流（上）

 -------------Android培训、java培训、期待与您交流------------

IO流（上）

一、IO流基础知识

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

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

Java用于操作流的对象都在IO包中

    流按操作数据分为两种：字节流与字符流 。

    流按流向分为：输入流，输出流。

字节流的抽象基类：

    InputStream ，OutputStream。

字符流的抽象基类：

    Reader ，Writer。

由这四个类派生出来的子类名称都是 以其父类名作为子类名的后缀。

IO程序的书写：

   1、 导入IO包中的类

    2、进行IO异常处理

    3、在finally中对流进行关闭

二、字符流

1、创建文件

FileWriter是一个专门用于操作文件的Writer子类对象。  后缀名是父类名。 前缀名是该流对象的功能。

    创建流对象，建立数据存放文件，

    而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖

FileWriter fw = new FileWriter(“Test.txt”);

    调用流对象的写入方法，将数据写入流

fw.write(“text”);

    关闭流资源，并将流中的数据清空到文件中。

fw.close();

fw.flush(); 刷新流对象中的缓冲中的数据，将数据刷到目的地中。

close和flush区别：

    flush刷新后，流可以继续使用，close刷新后，会将流关闭

异常处理

    因为IO流操作会调用系统底层资源，所以会抛出异常

异常处理例子：

<span style="font-size: 14px;">	</span><span style="font-size:14px;">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());
			}
			
		}		</span>

对已有文件的数据续写

传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。

    FileWriter fw = new FileWriter("demo.txt",true);

    fw.write("nihao");

2、读取文件

    创建一个文件读取流对象，和指定名称的文件相关联。

    要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException

FileReader fr = new FileReader("demo.txt");

    定义一个字符数组。用于存储读到字符。

    该read(char[])返回的是读到字符个数。

char[] buf = new char[1024];

int num = 0;

while((num=fr.read(buf))!=-1)

{

         System.out.println(new String(buf,0,num));

}

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

复制的原理：
    其实就是将C盘下的文件数据存储到D盘的一个文件中。

步骤：
    1、在D盘创建一个文件。用于存储C盘文件中的数据。
    2、定义读取流和C盘文件关联。
    3、通过不断的读写完成数据存储。
    4、关闭资源

<span style="font-size:14px;">import java.io.*;
class CopyText 
{
	public static void main(String[] args) throws IOException
	{
		copy();
	}
	public static void copy()
	{
		FileWriter fw = null;
		FileReader fr = null;
		try
		{
			fw = new FileWriter("d:/Demo_copy.txt");
			fr = new FileReader("c:/Demo.java");

			char[] buf = new char[1024];

			int len = 0;
			while((len=fr.read(buf))!=-1)
			{
				fw.write(buf,0,len);
			}
		}
		catch (IOException e)
		{
			throw new RuntimeException("读写失败");
		}
		finally
		{
			if(fr!=null)
				try
				{
					fr.close();
				}
				catch (IOException e)
				{  throw new RuntimeException("读取关闭失败");
				}
			if(fw!=null)
				try
				{
					fw.close();
				}
				catch (IOException e)
				{  throw new RuntimeException("写入关闭失败");
				}
		}
	}
}
</span>

3、字符流缓冲区

    缓冲区的出现是为了提高流的操作效率而出现的。

    在创建缓冲区之前，必须要先有流对象

    缓冲区内部封装了数组

对应类

    BufferedWriter

    BufferedReader

BufferedWriterd字符写入流缓冲区的基本步骤：

    创建一个字符写入流对象。

FileWriter fw = new FileWriter("buf.txt");

    为了提高字符写入流效率。加入了缓冲技术。

    只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。

BufferedWriter bufw = new BufferedWriter(fw);

    其实关闭缓冲区，就是在关闭缓冲区中的流对象。

bufw.close();

    该缓冲区中提供了一个跨平台的换行符。
newLine();

BufferedReader字符读取流缓冲区的基本步骤：

    创建一个读取流对象和文件相关联。

FileReader fr = new FileReader("buf.txt");

    为了提高效率。加入缓冲技术。将字符读取流对象作为参数传递给缓冲对象的构造函。

BufferedReader bufr = new BufferedReader(fr);

    该缓冲区提供了一个一次读一行的方法 readLine，方便于对文本数据的获取。

    当返回null时，表示读到文件末尾。

readLine方法返回的时候只返回回车符之前的数据内容。并不返回回车符。

<span style="font-size:14px;"><span style="font-size:14px;">String line = null;
while((line=bufr.readLine())!=null)
{
	System.out.print(line);
}</span></span>

装饰设计模式：

    当想要对已有的对象进行功能增强时，

可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。

那么自定义的该类称为装饰类。

    装饰类通常会通过构造方法接收被装饰的对象。

    并基于被装饰的对象的功能，提供更强的功能。

装饰模式比继承：

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

    装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。

所以装饰类和被装饰类通常是都属于一个体系中的。

三、字节流

    基本操作与字符流类相同

    但它不仅可以操作字符，还可以操作其他 媒体文件

InputStream      OutputStream

    字符流底层使用了字节流

    不用刷新就可以写入数据

复制一个图片：

思路：

1、用字节读取流对象和图片关联。

2、用字节写入流对象创建一个图片文件。用于存储获取到的图片数据。

3、通过循环读写，完成数据的存储。

4、关闭资源。

<span style="font-size:14px;"><span style="font-size:14px;">Simport java.io.*;
class  CopyPic
{
	public static void main(String[] args) 
	{
		FileOutputStream fos = null;
		FileInputStream fis = null;
		try
		{
			fos = new FileOutputStream("d:\\2.bmp");
			fis = new FileInputStream("d:\\1.bmp");

			byte[] buf = new byte[1024];

			int len = 0;

			while((len=fis.read(buf))!=-1)
			{
				fos.write(buf,0,len);
			}
		}
		catch (IOException e)
		{
			throw new RuntimeException("复制文件失败");
		}
		finally
		{
			try
			{
				if(fis!=null)
					fis.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("读取关闭失败");
			}
			try
			{
				if(fos!=null)
					fos.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("写入关闭失败");
			}
		}
	}
}
</span></span>

字节流缓冲区

BufferedOutputStream

BufferedInputStream

<span style="font-size:14px;">BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("d:\\lol.mp3"));
BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("d:\\copelol.mp3"));
int by = 0;
while((by=bufis.read())!=-1)
{
	bufos.write(by);
}</span>

四、键盘录入

<span style="font-size:14px;">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);
		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();
		}
	}
}</span>

五、流操作的基本规律

流对象有很多怎么选择：

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

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

  练习3、想要把录入的数据按照指定的编码表（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);

   转换流：字符和字节之间的桥梁，通常，涉及到字符编码转换时，

需要用到转换流。