黑马学习日记--IO流（）

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一：IO流概述

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

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

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

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

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

IO流常用基类：

字节流的抽象基类：

InputStreanm    OutputStream

字符流的抽象基类：

Reader  Writer

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

FileWriter：

write：将字符串写入到流中

flush：刷新流对象中的缓冲中的数据

close：关闭流资源，倒要先刷新

FileReader：

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

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

read：一次读一个字符，会自动往下读。如果已到达流的末尾，返回-1.

read（char[ ]）：返回的是读到字符个数。如果已到达流额末尾，返回-1.

import java.io.*;
class J18_4 
{
	public static void main(String[] args)
	{
		FileWriter fw = null;
		try
		{
			fw = new FileWriter("demo.txt",true);
			fw.write("hoop\r\nzeng");
		}
		catch (IOException e)
		{
			System.out.println(e.toString());
		}
		finally
		{	
			try
			{
				if(fw!=null)
				fw.close();
			}
			catch (IOException e)
			{
				System.out.println(e.toString());
			}
		}
	}
}

拷贝文本文件，练习代码：

//拷贝文本文件
import java.io.*;
class J18_7 
{
	public static void main(String[] args) throws IOException
	{
		//copy1();
		//copy2();
	}
	static void copy1() throws IOException
	{
		FileReader fr = new FileReader("J18_6.java");
		FileWriter fw = new FileWriter("J18_6_copy.txt");
		int ch ;
		while((ch=fr.read())!=-1)
			fw.write(ch);
		fr.close();
		fw.close();
	}
	static void copy2()
	{
		FileReader fr = null;
		FileWriter fw = null;
		try
		{
			fr = new FileReader("J18_5.java");
			fw = new FileWriter("J18_5_copy.txt");
			char[] buf = new char[1024];
			int len = 0;
			while((len=fr.read(buf))!=-1)
				fw.write(new String(buf,0,len));
		}
		catch (IOException e)
		{
			throw new RuntimeException();
		}
		finally
		{
			try
			{
				if (fr!=null)
				{
					fr.close();
				}
			}
			catch (IOException e)
			{
			}
			try
			{
				if (fw!=null)
				{
					fw.close();
				}
			}
			catch (IOException e)
			{
			}
		}
	}
}

二：字符流缓冲区

缓冲区的出现提高了对数据的读写效率

对应类：

BufferedWriter

BufferedReader

缓冲区要结合流才可以使用

（关闭缓冲区，实质是关闭缓冲区中的流对象）

newLine（）：写入一个行分隔符

readLine（）：读取一个文本行（不包含任何行终止符）

练习代码：

//通过缓冲区复制文本文件
import java.io.*;
class J19_3 
{
	public static void main(String[] args) 
	{
		BufferedReader br = null;
		BufferedWriter bw = null;
		try
		{
			br = new BufferedReader(new FileReader("J19_2.java"));
			bw = new BufferedWriter(new FileWriter("J19_2_copy.txt"));
			String s = null;
			while((s=br.readLine())!=null)
			{
				bw.write(s);
				bw.newLine();
				bw.flush();
			}
		}
		catch (IOException e)
		{
			throw new RuntimeException("读写失败");
		}
		finally
		{
			try
			{
				if(br!=null)
					br.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("读取关闭失败");
			}
			try
			{
				if(bw!=null)
					bw.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("写入关闭失败");
			}
		}
	}
}
//测试文字

装饰设计模式：

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

练习代码：

import java.io.*;
class MyBufferedReader extends Reader
{
	private Reader fr;
	MyBufferedReader(Reader fr)
	{
		this.fr = fr;
	}
	String myReadLine() throws IOException
	{
		StringBuilder sb = new StringBuilder();
		int ch = 0;
		while((ch=fr.read())!=-1)
		{
			if(ch=='\r')
				continue;
			if(ch=='\n')
				return sb.toString();
			sb.append((char)ch);
		}
		if(sb.length()!=0)
			return sb.toString();
		return null;
	}
	public int read(char[] cbuf,int off,int len) throws IOException
	{
		return fr.read(cbuf,off,len);
	}
	public void close() throws IOException
	{
		fr.close();
	}
	void myClose() throws IOException
	{
		fr.close();
	}
}
class J19_4 
{
	public static void main(String[] args) throws IOException
	{
		FileReader fr = new FileReader("J19_3.java");
		MyBufferedReader mbr = new MyBufferedReader(fr);
		String s = null;
		while((s=mbr.myReadLine())!=null)
			System.out.println(s);
		mbr.myClose();
	}
}

三：字节流的缓冲区

BufferedOutputStream

BufferedInputStream

练习代码：

//拷贝图片
import java.io.*;
class J19_9 
{
	public static void main(String[] args) 
	{
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try
		{
			fis = new FileInputStream("D:\\1.jpg");
			fos = new FileOutputStream("D:\\2.jpg");
			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("写入关闭失败");
			}
		}
	}
}

四：转换流

System.out：对应的是标准输出设备 控制台

System.in：对应的是标准输入设备  键盘

  InputStreamReader:字节流通向字符流的桥梁

OutputStreamWriter：字符流通向字节流的桥梁

流操作的基本规律：

1，明确源和目的

2，操作的数据是否是纯文本

3，体系明确后，再明确要使用哪个具体对象

练习代码：

/*需求：
通过键盘录入数据
当录入一行数据后，就将该行数据进行打印
如果录入的数据是over，那么停止录入 
*/
import java.io.*;
class J19_12 
{
	public static void main(String[] args) throws IOException
	{
		//InputStream in = System.in;
		//InputStreamReader isr = new InputStreamReader(in);
		//BufferedReader br = new BufferedReader(isr);
		BufferedReader br = new BufferedReader
			(new InputStreamReader(System.in));
		
		//OutputStream os = System.out;
		//OutputStreamWriter osw = new OutputStreamWriter(os);
		//BufferedWriter bw = new BufferedWriter(osw);
		BufferedWriter bw = new BufferedWriter
			(new OutputStreamWriter(System.out));
		
		String s = null;
		while((s=br.readLine())!=null)
		{
			if(s.equals("over"))
				break;
			bw.write(s.toUpperCase());
			bw.newLine();
			bw.flush();
		}
	}
}