黑马程序员_IO流1

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

一    IO流

1 概述：IO用来操作数据的流
（1）流按操作数据分为：字节流和字符流
（2）流按流向分为：输入流和输出流
（3）字符流有两个抽象基类：Reader（读取流）、Writer（写入流）
（4）字节流有两个抽象基类：InputStream(读取输入流)、OutputStream(写入输出流)

二    字符流

1 FileWriter类，操作文件的字符写入流
（1）构造函数：
FileWriter fw=new FileWriter("文件地址");该构造函数会抛出异常。如果该文件不存在，则会创建该文件，如果该文件存在，则会覆盖以有文件
FileWriter fw=new FileWriter("文件地址"，boolean append);该构造函数可以选择文件模式，如果为true是续写文件不会覆盖文件。

（2）方法摘要：
write(String str); 写字符串
flush(); 刷新流到目的地中
close(); 关闭前先刷新

（3）例子：

import java.io.*;
class  IoDemo
{
	public static void main(String[] args) throws IOException//主函数抛异常
	{
		//创建文件写入流，并指定目的地
		FileWriter fw=new FileWriter("FileDemo.txt");
		fw.write("abc");//写入字符串进流中
		fw.flush();//刷新流中数据
		fw.close();//关闭资源
	}
}

2 FileReader类，操作文件的字符读取流
（1）构造函数:
FileReader fr=new FileReader("文件地址");此构造方法会抛出异常。如果文件不存在就抛出异常，文件寻找则不会。

（2）方法摘要：
read(); 读一个字节，如果读到文件的末尾就返回-1
read(char[] buf) ;读一个数组，会返回读到的个数，如果返回-1，说明没有数据了。

（3）例子：

import java.io.*;
class  IoDemo
{
	public static void main(String[] args) throws IOException//主函数抛异常
	{
		//创建文件读取流，并与文件相关联
		FileReader fr=new FileReader("FileDemo.txt");
		//两种读取方式
		//方式一
		read1(fr);
		//方式二
		read2(fr);
	}
	public static void read1(FileReader fr)throws IOException//方式一，一个一个读
	{
		int len=0;
		while((len=fr.read())!=-1)
		{
			System.out.println((char)len);
		}
	}
	public static void read2(FileReader fr)throws IOException//方式二，一个数组一个数组读
	{
		int len=0;
		char[] ch=new char[1024];//定义一个字符数组
		while((len=fr.read(ch))!=-1)
		{
			System.out.println(new String(ch,0,len));
		}
	}
}

3 字符流的缓冲区BufferedWriter、BufferedReader

（1）缓冲区的出现是为了提高流的效率而存在的，所以定义缓冲区时必须要先有流存在

（2）BufferedWriter，字符写入流的缓冲区
构造方法：BufferedWriter bufw=new BufferedWriter(Writer w);
方法摘要：newLine();换行

（3）BufferedReader，字符读取流的缓冲区
构造方法：BufferedReader bufr=new BufferedReader(Reader r);
方法摘要：readLine();读取一行

（4）流的异常处理和加入缓冲技术示例：（复制文件）

import java.io.*;
class  BufferedDemo
{
	public static void main(String[] args) 
	{
		//缓冲流初始化为null
		BufferedReader bufr=null;
		BufferedWriter bufw=null;
		try
		{
			//创建文件读取流与文件相关联并加入缓冲技术
			bufr=new BufferedReader(new FileReader("Demo.java"));
			//创建文件写入流指定写入目的地，并加入缓冲技术
			bufw=new BufferedWriter(new FileWriter("Demo.txt"));
			String line=null;
			//读一行
			while ((line=bufr.readLine())!=null)
			{
				bufw.write(line);//写一行
				bufw.flush();//刷新
				bufw.newLine();//换行
			}
		}
		catch (IOException e)
		{
			throw new RuntimeException("读写失败");
		}
		finally
		{
			try
			{
				if(bufr!=null)
					bufr.close();//关闭资源是一定要执行的，多写在finally中
			}
			catch (IOException e)
			{
				throw new RuntimeException("读取流关闭失败");
			}
			try
			{
				if(bufw!=null)
					bufw.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("写入流关闭失败");
			}
		}
	}
}

二    字节流
1 用于操作字节数据的流InputStream、OutputStream
2 其子类字节流FileInputStream、FileOutputStream、BufferedInputStream、BufferedOutputStream跟字符流类似
3 通过一个例子复制图片将这些流都用上
例子：

import java.io.*;
class  BufferedDemo
{
	public static void main(String[] args) 
	{
		//缓冲流初始化为null
		BufferedInputStream bufi=null;
		BufferedOutputStream bufo=null;
		try
		{
			//创建文件读取流与文件相关联并加入缓冲技术
			bufi=new BufferedInputStream(new FileInputStream("aaa.mp3"));
			//创建文件写入流指定写入目的地，并加入缓冲技术
			bufo=new BufferedOutputStream(new FileOutputStream("bbb.mp3"));
			int by=0;
			//读取
			while ((by=bufi.read())!=-1)
			{
				bufo.write(by);//写入
			}
		}
		catch (IOException e)
		{
			throw new RuntimeException("读写失败");
		}
		finally
		{
			try
			{
				if(bufi!=null)
					bufi.close();//关闭资源是一定要执行的，多写在finally中
			}
			catch (IOException e)
			{
				throw new RuntimeException("读取流关闭失败");
			}
			try
			{
				if(bufo!=null)
					bufo.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("写入流关闭失败");
			}
		}
	}
}

2 转换流
（1）InputStreamReader，字节通向字符的桥梁
（2）OutPutStreamWriter，字符通向字节的桥梁

3 键盘录入
（1）InputStream is=System.in;标准输入流，键盘
（2）OutputStream os=System.out;标准输出流，控制台
（3）键盘录入加入缓冲技术，可以读取一行比较高效。但是readLine()方法是字符流BufferedReader()的方法。所以需要转换流InputStreamReader将字节流转换成字符流。
例如：BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
（4）输入输出流示例，获取键盘录入并打印在控制台上

import java.io.*;
class InOutDemo
{
	public static void main(String[] args) throws IOException
	{
		//获取键盘录入并加入缓冲技术，需要转换流
		BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
		//获取输出流并加入缓冲技术，需要转换流
		BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(System.out));
		//读取键盘录入
		String line=null;
		while ((line=bufr.readLine())!=null)
		{
			if("over".equals(line))//判断结束标记
				break;
			bufw.write(line);//输出读到的字符
			bufw.newLine();//换行
			bufw.flush();//刷新
		}
	}
}

4 流操作规律
（1）明确源
字节：InputStream
字符：Reader
文件：FileReader、FileInputStream
缓冲技术：BufferedReader、BufferedInputStream
键盘:System.in
转换流：InputStreamReader

（2）明确目的
字节：OutputStream
字符：Writer
文件：FileWriter、FileOutputStream
缓冲技术：BufferedWriter、BufferedOutputStream
控制台：System.out
转换流：OutputStreamWriter

（3）通过以上规律从而确定应该用哪个流。

例如：复制图片

源：Reader、InputStream

图片是字节：InputStream

图片是文件：FileInputStream

需要高效：BufferedInputStream

目的：Writer、OutputStream

图片是字节：OutputStream

图片是文件：FileOutputStream

需要高效：BufferedOutputStream

所以可以确定代码为：

源：BufferedInputStream bufi=new BufferedInputStream(new FileInputStream("文件名"));

目的：BufferedOutputStream bufo=new BufferedOutputStream(new FileOutputStream("文件名"));