黑马程序员--java基础复习之IO

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

IO

IO，即Input和Output(输入输出流)

特点：

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

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

3、java用于操作流的对象都在IO包中。

4、流按照数据分为字节流和字符流。

5、流按照流向分为输入流和输出流。

IO流的常用基类：
        1、字节流的抽象基流：InputStream和OutputStream
        2、字符流的抽象基流：Reader和Writer

注：由这四个类派生出来的子类名称都是以父类名作为子类名的后缀，以前缀为其功能；如InputStream子类FileInputStream；Reader子类FileReader

字符流

特点：

1、字符流中的对象融合了编码表。使用的是默认的编码，即当前系统的编码。
        2、字符流只用于处理文字数据，而字节流可以处理媒体数据。
        3、既然IO流是用于操作数据的，那么数据的最常见体现形式是文件。查看API，找到一个专门用于操作文件的Writer子类对象：FileWriter。 

从 API中可以看到FileWriter类中特有的方法并不多，但是它属于Writer类的子类，Writer类中的方法它都可以使用。

主要的方法有：

write()：写入，其重载函数的类型有 char[ ] 字符数组，int 单个字符，String字符串 ，还有write(char[] chuf,int off,int len) ，字符数组的一部分。

flush()：刷新该流中的缓冲

close()：关闭此流，但要先刷新它。

下面看一段代码，看看使用方式(这里未作异常处理)：

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

上面的代码未作异常处理，因为我们创建 FileWriter对象时，会将文件名作为参数传递，当文件不存在时，会报异常。那么异常该如何处理呢？将上面的代码完善后如下：

import java.io.*;
class FileWriterDemo1
{
	public static void main(String[] args)
	{
		//创建FileWriter的引用
		FileWriter fw=null;
		try
		{
			//创建FileWriter的对象
			fw=new FileWriter("test.txt");
			//写入数据
			fw.write("测试文字");
			
		}
		//处理异常
		catch(IOException e)
		{
			System.out.println(e.toString());
		}
		finally
		{
			try
			{
				//关闭资源
				if(fw!=null)
				fw.close();
			}
			catch(IOException e)
			{
				System.out.println(e.toString());
			}
			
		}
	}
}

通过上面的例子里可以看到，每次FileWriter初始化时就会在指定的目录下创建一个文件，当文件已存在时，那么此文件会被覆盖掉。但是有时候我们需要的是在文件内容末尾处续写，而不是直接覆盖，那怎么办呢？通过查API得到，FileWriter的几个重载构造函数中，FileWriter(String fileName, boolean append) 根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象，可以看到，参数列表中有一个boolean类型的参数append，其是用于判断是否在原有的目标文件末尾处追加。

所以，当我们不想覆盖原文件，而只是在末尾处追加时，代码可略修改：

 fw=new FileWriter("test.txt",true);//在目标文件末尾处续写，而不覆盖。

上面的介绍的是字符流中的写入，对应的字符流 应该有读取。

Reader

其基本方法有：

int read()       读取单个字符。如果已到达流的末尾，则返回 -1
int read(char[] cbuf)  将字符读入数组。   返回： 读取的字符数，如果已到达流的末尾，则返回 -1

read(char[] cbuf, int off, int len)  将字符读入数组的某一部分

close()  关闭该流并释放与之关联的所有资源。

而要读取文件的话，也需要创建一个对应的文件读取流对象，这个对象所属的类是FileReader，而FileReader也是Reader的子类

那么Reader类中的方法也自然可以使用的。下面通过代码来看看FileReader读取文件的应用：

import java.io.*;
class FileReaderDemo
{
	public static void main(String[] args)
	{
		
		FileReader fr=null;
		try
		{
		 //创建一个文件读取流对象，和指定名称的文件相关联
		 //要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException
		 fr=new FileReader("test.txt");	
		 
		 //调用读取流对象的read方法。
		 //read()：一次读一个字符。而且会自动往下读
		 //当读取到结尾处时，则返回-1
		 int ch;
		 
		 while((ch=fr.read())!=-1)
		 {
			 System.out.println((char)ch);
		 }
		 
		}
		catch(IOException e)
		{
			System.out.println(e.toString());
		}
		finally
		{
			try
			{
				if(fr!=null)
				fr.close();
			}
			catch(IOException e)
			{
				System.out.println(e.toString());
			}
			
		}		
		
	}
	
	//第二种读取方式：通过字符数组进行读取
	public static void FileReaderCharArray()
	{
		FileReader fr=null;
		try
		{
			fr=new FileReader("test.txt");
			
			char[] ch=new char[1024];
			int num=0;//每次读取到字符的个数 
			while((num=fr.read(ch))!=-1)
			{
				System.out.println(new String(ch,0,num));
			}
		}
		catch(IOException e)
		{
			System.out.println(e.toString());
		}
		finally
		{
			try
			{
				if(fr!=null)
					fr.close();
			}
			catch(IOException e)
			{
				System.out.println(e.toString());
			}
		}
	}	
}

注意：

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

再看下面一个小练习，关于FileReader的两种读取方式和FileWriter 的使用

/*
将C盘中的一个文本文件复制到D盘 
思路：
1、在D盘创建一个文件，用于存储C盘文件中的数据。
2、定义读取流和C盘文件关联
3、通过不断的读写完成数据存储
4、关闭资源
*/

import java.io.*;
class CopyText
{
	public static void main(String[] args)
	{
		//Copy_1();
		Copy_2();
	}
	
	//从源文件读一个字符就往目的地写一个字符
	public static void Copy_1()
	{
		FileReader fr=null;
		FileWriter fw=null;
		
		try
		{
			//源文件
			fr=new FileReader("D:\\FileWriteDemo1.java");
			//目的文件
			fw=new FileWriter("C:\\FileWriteDemo1.java");						
			int num=0;	
				//当返回值为-1时，表明已到文件末尾
			while((num=fr.read())!=-1)
			{
				sop(num);
				fw.write((char)num);
				fw.flush();
			}	
		}
		catch(IOException e)
		{
			sop(e.toString());
		}
		finally
		{
			try{
				if(fr!=null)
					fr.close();
			}
			catch(IOException e)
			{
				sop(e.toString());
			}
			
			try{
				if(fw!=null)
					fw.close();
			}
			catch(IOException e)
			{
				sop(e.toString());
			}
		}
	}
	
	//通过读取写入数组的方式
	public static void Copy_2()
	{
		FileReader fr=null;
		FileWriter fw=null;
		
		try
		{
			//源文件
			fr=new FileReader("D:\\FileWriteDemo1.java");
			//目的文件
			fw=new FileWriter("C:\\FileWriteDemo1.java");
			
			char[] ch=new char[1024];
			int num=0;
			//当返回值为-1时，表明已到文件末尾
			while((num=fr.read(ch))!=-1)
			{
				sop(num);
				//fw.write(new String(ch,0,num));
				fw.write(ch,0,num);
				fw.flush();
			}
			
		}
		catch(IOException e)
		{
			sop(e.toString());
		}
		finally
		{
			//关闭资源
			try{
				if(fr!=null)
					fr.close();
			}
			catch(IOException e)
			{
				sop(e.toString());
			}
			//关闭资源
			try{
				if(fw!=null)
					fw.close();
			}
			catch(IOException e)
			{
				sop(e.toString());
			}
		}
	}
	//打印
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

字符流的缓冲区

BufferedReader和BufferedWriter

字符流的缓冲区：缓冲区要结合流才能使用，是在流的基础上对流的功能进行了增强
1、缓冲区的出现：提高了流的读写效率，所以在缓冲区创建前，要先创建流对象。即先将流对象初始化到构造函数中。 
2、缓冲技术原理：此对象中封装了数组，将数据存入，再一次性取出。
3、写入流缓冲区BufferedWriter的步骤：
A、创建一个字符写入流对象。
如：FileWriter fw=newFileWriter("buf.txt");
B、为了提高字符写入流效率。加入缓冲技术。只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。
如： BufferedWriter bufw =new BufferedWriter(fw);
C、调用write方法写入数据到指定文件
如：bufw.write("adfg");
记住，只要用到缓冲区，就要记得刷新。（关闭流同样会刷新，但为了排除意外事故，保证数据存在，建议写入一次就刷新一次）
如：bufw.flush();
D、其实关闭缓冲区，就是在关闭缓冲区中的流对象。
如： bufw.close();
小知识：BufferedWriter缓冲区中提供了一个跨平台的换行符：newLine();可以在不同操作系统上调用，用作数据换行。
如：bufw.newLine();
4、读取流缓冲区BufferedReader
该缓冲区提供了一个一次读一行的方法readLine，方便于对文本数据的获取，当返回null时表示读到文件末尾。readLine方法返回的时候，只返回回车符之前的数据内容。并不返回回车符。
readLine方法原理：
无论是读一行。或者读取多个字符。其实最终都是在在硬盘上一个一个读取。所以最终使用的还是read方法一次读一个的方法。
步骤：
A、创建一个读取流对象和文件相关联
如： FileReader fr=newFileReader("buf.txt");
B、为了提高效率。加入缓冲技术。将字符读取流对象作为参数传递给缓冲区对象的构造函数。
如： BufferedReader bufr=new BufferedReader(fr);
C、调用该缓冲区提供的readLine方法一行一行读取,如果到达文件末尾，则返回null
如： String s=bufr.readLine();
D、关闭流资源
如： bufr.close();、

通过代码来看其应用：

/*
缓冲区的出现是为了提高流的操作效率而出现的。
所以在创建缓冲区之前，必须要先有流对象。

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

import java.io.*;
class BufferedWriterDemo
{
	public static void main(String[] args)
	{
		BufferedWriterMethod();
	}
	
	public static void BufferedWriterMethod()
	{
		//创建一个字符写入流的引用
		FileWriter fw=null;
		BufferedWriter bfw=null;
		try
		{
			//创建一个字符写入流的对象
			fw=new FileWriter("Test.txt");
			//为了提高字符写入流效率。加入了缓冲技术
			//只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数
			bfw=new BufferedWriter(fw);
			
			for(int x=0;x<5;x++)
			{
				bfw.write("测试文字");
				bfw.newLine();//换行
				//记住：只要用到缓冲区，就要记得刷新
				bfw.flush();// 刷新
			}
			
		}
		catch(IOException e)
		{
			sop(e.toString());
		}
		finally
		{
			try
			{
				if(bfw!=null)
					//其实关闭缓冲区，就是在关闭缓冲区中的流对象
					bfw.close();
			}
			catch(IOException e)
			{
				sop(e.toString());
			}
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

注意，在写入的时候，只要用到缓冲区，就要记得刷新。上面用到了换行的方法newLine()，目的是写入一个换行符。

来看下面一个BufferedReader和BufferedWriter的组合应用：

/*
通过缓冲区复制一个.java文件

*/
import java.io.*;
class CopyTextByBuf
{
	public static void main(String[] args)
	{
		CoypText();
	}
	 public static void CoypText()
	 {
		 FileReader fr=null;
		 FileWriter fw=null;
		 BufferedReader bfr=null;
		 BufferedWriter bfw=null;
		 try
		 {
			 //创建文件读取流对象，和源文件相关联
			 fr=new FileReader("BufferedWriterDemo.java");
			 bfr=new BufferedReader(fr);
			 //简写格式
			 //bfr=new BufferedReader(new FileReader("BufferedWriterDemo.java"));
			 
			 fw=new FileWriter("c:\\buwd.java");
			 bfw=new BufferedWriter(fw);
			 //简写格式
			 //bfw=new BufferedWriter(new FileWriter("c:\\buwd.java"));
			 
			 String line=null;
			 while((line=bfr.readLine())!=null)
			 {
					bfw.write(line);
					bfw.newLine();//换行
					bfw.flush();//刷新
			 }
			 
			 
		 }
		 catch(IOException e)
		 {
			 throw new RuntimeException("复制失败");
		 }
		 finally
		 {
			 try{
				 if(bfr!=null)
					 bfr.close();
			 }
			 catch(IOException e)
			 {
				  throw new RuntimeException("关闭失败");
			
			 }
			 
			  try{
				 if(bfw!=null)
					 bfw.close();
			 }
			 catch(IOException e)
			 {
				  throw new RuntimeException("关闭失败");
			 }
		 }
	 }
}

从上面代码可以看到，创建缓冲区可以简写成一句：BufferedReader br=new BufferedReader(new InputStreamReader(new FileReader("Test.txt"))); 和BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileWriter("Test_copy.txt")));

readLine 方法的原理：
无论是读一行，或者读取多个字符，其实最终都是在硬盘上一个一个读取，所以最终使用的还是read 方法一次读一个的方法。

自定义BufferedReader
原理：
       可根据BufferedReader类中特有一行一行读取方法readLine()的原理，自定义一个类中包含相同功能的方法
步骤：  a、初始化自定义的类，加入流对象。
        b、定义一个临时容器，原BufferedReader封装的是字符数组，此类中可定义一个StringBuilder的容器，最终可实现字符串的提取。
直接上代码：

/*
自定义功能，实现与BufferedReader一致的功能
ReadLine 功能的原理
<span style="font-size:14px;">无论是读一行，或者读取多个字符，其实最终都是在硬盘上一个一个读取，</span><span style="font-size:14px;">所以最终使用的还是read 方法一次读一个的方法。</span>
*/
import java.io.*;
class MyBufferedReader
{
	private FileReader fr=null;
	MyBufferedReader(FileReader fr)
	{
		this.fr=fr;
	}
	public String MyReadLine() throws IOException
	{
		//定义一个临时容器。原BufferReader封装的是字符数组
		//为了演示方便。定义一个StringBuilder 容器。因为最终还是要将数据变成字符串
		StringBuffer sb=new StringBuffer();
		
		int ch=0;
		while((ch=fr.read())!=-1)
		{
			if(ch=='\r')
				continue;
			if(ch=='\n')				
				return sb.toString();
			else 
				sb.append((char)ch);
		}
		//当文本中最后一行没有回车符时，最后一行数据就没有返回
		if(sb.length()!=0)
			return sb.toString();
		return null;
	}
	
	public void MyClose() throws IOException
	{
		fr.close();
	}
}

class MyBufferedReaderDemo
{
	public static void main(String[] args ) throws IOException
	{
		MyBufferedReader mbr=new MyBufferedReader(new FileReader("Test.txt"));
		
		String line=null;
		while((line=mbr.MyReadLine())!=null)
		{
			System.out.println(line);
		}
		
		mbr.MyClose();
		
	}
}

要注意的是，如果文本中的末尾不是回车符结束的，那么最后需要判断一下字符串缓冲区中是否还有数据，若有，则返回数据。

装饰设计模式

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

装饰类通常会通过构造方法接收被装饰的对象。并基于被装饰的对象的功能 ，提供更强的功能。

装饰设计模式和继承的区别：
1、装饰模式比继承要灵活，避免了继承体系臃肿。而且降低了类与类之间的关系。
2、装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强的功能。 所以装饰类和被装饰类通常是都属于一个体系中。

3、从继承结构转为组合结构

通过一个例子来说明：

class Person
{
	//吃饭功能
	public void chifan()
	{
		System.out.println("吃饭");
	}
}
class SuperPerson
{
	private Person p;
	SuperPerson(Person p)
	{
		this.p=p;
	}
	//对原对象的功能进行增强
	public void superChifan()
	{
		System.out.println("开胃酒");
		p.chifan();
		System.out.println("甜点");
		System.out.println("来一根");
	}
}

class PersonDemo
{
	public static void main(String[] args)
	{
		Person p=new Person();
		
		SuperPerson sp=new SuperPerson(p);
		sp.superChifan();
	}
}

上例中，SuperPerson就是一个装饰类，Person就是一个被装饰的类，被增强的功能就是Person中的chifan()方法。

LineNumberReader
在BufferedReader中有个直接的子类LineNumberReader，其中有特有的方法获取和设置行号：
setLineNumber();//设置初始行号
getLineNumber();//获取行号

上代码：

import java.io.*;
class LineNumberReaderDemo
{
	public static void main(String[] args)
	{
		method();
	}
	
	public static void method()
	{
		FileReader fr=null;
		//创建一个带行号的装饰类的引用
		LineNumberReader lnr=null;
		try
		{
			fr=new FileReader("Test.txt");
			lnr=new LineNumberReader(fr);
			
			//设置行号
			lnr.setLineNumber(200);
			String line=null;
			//因为LineNumberReader是BufferedReader的子类，所以它也是一个缓冲区，可以使用readLine()方法
			while((line=lnr.readLine())!=null)
			{
				//在每行添加行号
				System.out.println(lnr.getLineNumber()+":"+line);
			}
		}
		catch(IOException e)
		{
			System.out.println(e.toString());
		}
		finally
		{
			try
			{
				if(lnr!=null)
					lnr.close();
			}
			catch(IOException e)
			{
				System.out.println(e.toString());
			}
		}
	}
}

字节流

一、概述
1、字节流和字符流的基本操作是相同的，但字节流还可以操作其他媒体文件。
2、由于媒体文件数据中都是以字节存储的，所以，字节流对象可直接对媒体文件的数据写入到文件中，而可以不用再进行刷流动作。
3、读写字节流：InputStream   输入流（读）
                             OutputStream  输出流（写）
4、为何不用进行刷流动作：
        因为字节流操作的是字节，即数据的最小单位，不需要像字符流一样要进行转换为字节。所以可直接将字节数据写入到指定文件中。
5、InputStream特有方法：
        int available();//返回文件中的字节个数
注：可以利用此方法来指定读取方式中传入数组的长度，从而省去循环判断。但是如果文件较大，而虚拟机启动分配的默认内存一般为64M。
当文件过大时，此数组长度所占内存空间就会溢出。所以，此方法慎用，当文件不大时，可以使用。

代码：

import java.io.*;
class FileStream
{
	public static void main(String[] args)
	{
		//writeFile();
		//readFileByStream();
		//readFileByStream1();
		readFileByStream2();
	}
	//使用字节流写入文件-----
	public static void readFileByStream2()
	{
		FileInputStream fis=null;
		try
		{
			fis=new FileInputStream("PersonDemo.java");
			
			int length=fis.available();//定义一个长度刚刚好的缓冲区，不用再循环了
			//当数据量过大的时候不能使用这个方法。
			byte[] byt=new byte[length];
			
			fis.read(byt);
			sop(new String(byt));
		}
		catch(IOException e)
		{
			sop(e.toString());
		}
		finally
		{
			try
			{
				if(fis!=null)
				fis.close();
			}
			catch(IOException e)
			{
				sop(e.toString());
			}
		}
	}
	//使用字节流读取文件----读取字符数组
	public static void readFileByStream1()
	{
		FileInputStream fis=null;
		try
		{
			fis=new FileInputStream("streamTest.txt");
			
			byte[] byt=new byte[1024];
			int length=0;
			while((length=fis.read(byt))!=-1)
			{
				sop(new String(byt,0,length));
			}
		}
		catch(IOException e)
		{
			sop(e.toString());
		}
		finally
		{
			try
			{
				if(fis!=null)
				fis.close();
			}
			catch(IOException e)
			{
				sop(e.toString());
			}
		}
	}
	
	//使用字节流读取文件----读取字符
	public static void readFileByStream()
	{
		FileInputStream fis=null;
		try{
			fis=new FileInputStream("streamTest.txt");
			
			int ch=0;
			while((ch=fis.read())!=-1)
			{
				sop((char)ch);
			}
		}
		catch(IOException e)
		{
			sop(e.toString());
		}
		finally
		{
			try
			{
				if(fis!=null)
					fis.close();
			}
			catch(IOException e)
			{
				sop(e.toString());
			}
		}
	  
	  
	}
	//使用字节流写入文件
	public static void writeFile()
	{
		FileOutputStream fis=null;
		try
		{
			//创建一个文件字节流对象
			fis=new FileOutputStream("streamTest.txt",true);		
				//向目的文件中写入数据
			fis.write("yes".getBytes());			
		}
		catch(IOException e)
		{
			System.out.println(e.toString());
		}
		finally
		{
			try
			{
				if(fis!=null)
					fis.close();
			}
			catch(IOException e)
			{
				sop(e.toString());
			}
		}
		
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

字节流缓冲区
        同样是提高了字节流的读写效率。
1、读写特点：
        read()：会将字节byte型值提升为int型值
        write()：会将int型强转为byte型，即保留二进制数的最后八位。
2、原理：将数据拷贝一部分，读取一部分，循环，直到数据全部读取完毕。
        1）先从数据中抓取固定数组长度的字节，存入定义的数组中，再通过然后再通过read()方法读取数组中的元素，存入缓冲区。
        2）循环这个动作，直到最后取出一组数据存入数组，可能数组并未填满，同样也取出包含的元素。
        3）每次取出的时候，都有一个指针在移动，取到数组结尾就自动回到数组头部，这样指针在自增。
        4）取出的时候，数组中的元素在减少，取出一个，就减少一个，直到减到0即元素取完。
        5）当文件中的全部数据都被读取出时，read()方法就返回-1。

代码：

import java.io.*;
class CopyMp3ByBufferedStream
{
	public static void main(String[] args)
	{
		copyMp3();
	}
	public static void copyMp3()
	{
		BufferedInputStream bis=null;
		BufferedOutputStream bos=null;
		try
		{
			//字节输入流缓冲区
			bis=new BufferedInputStream(new FileInputStream("c:\\李玉刚 - 雨花石.mp3"));
			//字节输出流缓冲区
			bos=new BufferedOutputStream(new FileOutputStream("c:\\雨花石.mp3"));
			
			int length=0;
			while((length=bis.read())!=-1)
			{
				bos.write(length);
			}
		}
		catch(IOException e)
		{
			throw new RuntimeException("复制失败！！！");
		}
		finally
		{
			try{
				if(bis!=null)
					bis.close();
			}
			catch(IOException E)
			{
				throw new RuntimeException("复制失败！！！");
			}
			
			try{
				if(bos!=null)
					bos.close();
			}
			catch(IOException E)
			{
				throw new RuntimeException("复制失败！！！");
			}
		}
	}
}

自定义读取字节流缓冲区
        需求：根据字节流缓冲区的原理，自定义一个字节流缓冲区。

如下代码：

import java.io.*;

class MyBufferedInputStreamDemo
{
	public static void main(String[] args)
	{
		copyMp3();
	}
	public static void copyMp3()
	{
		myBufferedInputStream mybis=null;
		BufferedOutputStream bos=null;
		try
		{
			//字节输入流缓冲区
			mybis=new myBufferedInputStream(new FileInputStream("c:\\李玉刚 - 雨花石.mp3"));
			//字节输出流缓冲区
			bos=new BufferedOutputStream(new FileOutputStream("c:\\雨花石.mp3"));
			
			int length=0;
			while((length=mybis.myRead())!=-1)
			{
				bos.write(length);
			}
		}
		catch(IOException e)
		{
			throw new RuntimeException("复制失败！！！");
		}
		finally
		{
			try{
				if(mybis!=null)
					mybis.myClose();
			}
			catch(IOException E)
			{
				throw new RuntimeException("复制失败！！！");
			}
			
			try{
				if(bos!=null)
					bos.close();
			}
			catch(IOException E)
			{
				throw new RuntimeException("复制失败！！！");
			}
		}
	}
}

class myBufferedInputStream 
{
	private InputStream is;
	private byte[] buf=new byte[1024];
	
	private int pos=0,count=0;
	myBufferedInputStream(InputStream is)
	{
		this.is=is;
	}
	
	//一次读一个字节，从缓冲区(字节数组)中获取
	public int myRead() throws IOException
	{
		//通过is对象读取硬盘上数据，并存储到buf中
		//当取完后
		if(count==0) 
		{
			count=is.read(buf);
			if(count<0)
				return -1;
			pos=0;//指针归零
			byte b=buf[pos];
			
			count--;//每读取一个字节，数组中的字节数就少一个
			pos++;
			return b&255;//返回此处取到的字节
		}
		else if(count>0) 
		{
			byte b=buf[pos];
			count--;
			pos++;
			return b&255;//0xff
		}
		return -1;
				
	}
	public void myClose() throws IOException
	{
		is.close();
	}
}

注意：
    1、字节流的读一个字节的read方法为什么返回值类型不是byte，而是int。
     因为有可能会读到连续8个二进制1的情况，8个二进制1对应的十进制是-1.那么就会数据还没有读完，就结束的情况。因为我们判断读取结束是通过结尾标记-1来确定的。
    所以，为了避免这种情况将读到的字节进行int类型的提升。并在保留原字节数据的情况前面了补了24个0，变成了int类型的数值。而在写入数据时，只写该int类型数据的最低8位。
2、byte类型的-1提升为int类型时还是-1。原因：因为在bit8个1前面补的全是1导致的。如果在bit8个1前面补0，即可以保留原字节数据不变，又可以避免-1的出现。这时将byte型数据&0xff即255即可。

标准输入输出流
System.out：对应的是标准的输出设备，控制台。
System.in：对应的标准输入设备，键盘。
System.in的类型是InputStream.

代码：

/*

一、键盘录入
读取键盘录入
System
标准输入输出流
	System.out：对应的是标准的输出设备，控制台。
	System.in：对应的标准输入设备，键盘。
	
	System.in的类型是InputStream.
	System.out的类型是PrintStream是OutputStream的子类FilterOutputStream的子类。
		
当录入一行数据后，就将该数据进行打印。
如果录入的是over，那么停止录入
*/
import java.io.*;
class ReadInCode
{
	public static void main(String[] args)throws IOException
	{
		method();
	}
	public static void method() throws IOException
	{
		InputStream ins=System.in;
		
		StringBuilder sb=new StringBuilder();
		
		while(true)
		{
			int num=0;
			num=ins.read();								
			if(num=='\r')
				continue;
			if(num=='\n')
			{
				String s=sb.toString();
				sb.append((char)num);
				if("over".equals(s))//当输入over，则退出
					break;
				System.out.println(s.toUpperCase());			
				sb.delete(0,sb.length());//清空缓存
			}	
			else
				sb.append((char)num);
		}
	}
}

结果：

从上面的结果可以看出，能够得到效果，通过刚才的键盘录入一行数据并打印其大写，发现其实就是读一行数据的原理。也就是readLine 方法。

能不能直接使用readLine方法来完成键盘录入的一行数据的读取呢？
readLine方法是字符流BufferedReader 类中的方法。而键盘录入的read 方法是字节流InputStream的方法。那么能不能将字节流转成字符流再使用字符流缓冲区的readLine方法呢？

转换流
 转换流的由来：
       a、字符流与字节流之间的桥梁
       b、方便了字符流与字节流之间的操作
转换流的应用：
      字节流中的数据都是字符时，转成字符流操作更高效。
  InputStreamReader将字节流通向字符流
       a、获取键盘录入对象。
              InputStream in=System.in;
       b、将字节流对象转成字符流对象，使用转换流。
              InputStreamReaderisr=new InputStreamReader(in);
       c、为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader
              BufferedReaderbr=new BufferedReader(isr);
       //键盘录入最常见写法
              BufferedReaderin=new BufferedReader(new InputStreamReader(System.in));
 OutputStreamWriter字符流通向字节流
       字符通向字节：录入的是字符，存到硬盘上的是字节。步骤和InputStreamReader转换流一样。

代码：

import java.io.*;
class TransStreamDemo
{
	public static void main(String[] args)
	{
		BufferedReader br=null;
		
		try
		{
				//获取键盘录入对象
			InputStream ins=System.in;
			//将字节流对象转成字符流对象，使用转换流。InputStreamReader
			InputStreamReader isr=new InputStreamReader(ins);
			
			//为了提高效率，将字符串进行缓冲区技术高效操作，使用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 len=null;
			while((len=br.readLine())!=null)
			{
				if("over".equals(len))
					break;
				bw.write(len.toUpperCase());
				bw.newLine();  //换行
				bw.flush();	//刷新			
			}		
		}
		catch( IOException e)
		{
			System.out.println(e.toString());
		}
		finally
		{
			try
			{
				if(br!=null)
					br.close();
			}
			catch(IOException e)
			{
				System.out.println(e.toString());
			}
		}			
	}
}

流操作规律
1、
        源：键盘录入。
        目的：控制台。
2、需求：想把键盘录入的数据存储到一个文件中。
        源：键盘
        目的：文件。
        使用字节流通向字符流的转换流（桥梁）：InputStreamReader
3、需求：想要将一个文件的数据打印在控制台上。
        源：文件
        目的：控制台
        使用字符流通向字节流的转换流（桥梁）：OutputStreamWriter
4、流操作的基本规律：
        最痛苦的就是流对象有很多，不知道该用哪一个。
通过三个明确来完成：
4.1   明确源和目的。
        源：输入流。InputStream  Reader
        目的：输出流。OutputStream  Writer
4.2   操作的数据是否是纯文本。
        是：字符流
        否：字节流
4.3   当体系明确后，再明确要使用哪个具体的对象。通过设备来进行区分：
        源设备：内存，硬盘，键盘
        目的设备：内存，硬盘，控制台
5、规律体现
5.1 将一个文本文件中数据存储到另一个文件中。复制文件。
        1）源：因为是源，所以使用读取流：InputStream和Reader
             明确体系：是否操作文本：是，Reader
              明确设备：明确要使用该体系中的哪个对象：硬盘上的一个文件。Reader体系中可以操作文件的对象是FileReader
              是否需要提高效率：是，加入Reader体系中缓冲区 BufferedReader.
              FileReader fr = new FileReader("a.txt");
              BufferedReader bufr = new BufferedReader(fr);
        2）目的：输出流：OutputStream和Writer
             明确体系：是否操作文本：是，Writer
              明确设备：明确要使用该体系中的哪个对象：硬盘上的一个文件。Writer体系中可以操作文件的对象FileWriter。
              是否需要提高效率：是，加入Writer体系中缓冲区 BufferedWriter
              FileWriter fw = new FileWriter("b.txt");
              BufferedWriter bufw = new BufferedWriter(fw);
练习：将一个图片文件中数据存储到另一个文件中。复制文件。要按照以上格式自己完成三个明确。
        1）源：输入流，InputStream和Reader
            是否是文本？否，InputStream
            源设备：硬盘上的一个文件。InputSteam体系中可以操作文件的对象是FileInputSteam
            是否需要提供效率：是，BufferedInputStream
              BufferedInputSteambis=newBufferedInputStream(newFileInputStream("c:/users/asus/desktop/1.jpg"));
        2）目的：输出流，OutputStream和Writer
             是否是文本？否，OutputStream
             源设备：硬盘上的文件，FileOutputStream
             是否需要提高效率：是，加入BufferedOutputStream
               BufferedOutputStreambos=newBufferedOutputStream(newFileOutputStream("c:/users/asus/desktop/2.jpg"));
5.2 需求：将键盘录入的数据保存到一个文件中。
        1）源：InputStream和Reader
              是不是纯文本？是，Reader
              设备：键盘。对应的对象是System.in。——为了操作键盘的文本数据方便。转成字符流按照字符串操作是最方便的。所以既然明确了Reader，那么就将System.in转换成Reader。用Reader体系中转换流,InputStreamReader
              InputStreamReaderisr = new InputStreamReader(System.in);
             需要提高效率吗？需要，BufferedReader
             BufferedReaderbufr = new BufferedReader(isr);
       2）目的：OutputStream  Writer
             是否是存文本？是！Writer。
             设备：硬盘。一个文件。使用 FileWriter。
             FileWriter fw = newFileWriter("c.txt");
           需要提高效率吗？需要。
            BufferedWriter bufw = new BufferedWriter(fw);
5.3   扩展：想要把录入的数据按照指定的编码表（UTF-8）（默认编码表是GBK），将数据存到文件中。
        目的：OutputStream  Writer
        是否是存文本？是！Writer。
        设备：硬盘上的一个文件。使用 FileWriter。——但是FileWriter是使用的默认编码表：GBK。而存储时，需要加入指定编码表utf-8。而指定的编码表只有转换流可以指定。所以要使用的对象是OutputStreamWriter。
        该转换流对象要接收一个字节输出流，而且还可以操作的文件的字节输出流：FileOutputStream
        OutputStreamWriter osw =new OutputStreamWriter(newFileOutputStream("d.txt"),"UTF-8");
        需要高效吗？需要，BufferedWriter
        BufferedWriter bufw = new BufferedWriter(osw);
记住：
       转换流什么使用？
       字符和字节之间的桥梁。通常，涉及到字符编码转换时，需要用到转换流。

通过System类的setIn，setOut方法可以对默认设备进行改变
System.setIn(newFileInputStream(“1.txt”));//将源改成文件1.txt。
System.setOut(newFileOutputStream(“2.txt”));//将目的改成文件2.txt

如下：

import java.io.*;
class TransStreamTest
{
	public static void main(String[] args) throws IOException
	{
		//修改源
		System.setIn(new FileInputStream("ReadInCode.java"));
		//修改目的
		System.setOut(new PrintStream("zz.txt"));
		
		//键盘的最常见写法
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		
		BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8"));
		
		String line=null;
		while((line=br.readLine())!=null)
		{
			if("over".equals(line))
				break;
			bw.write(line);
			bw.flush();
		}
		br.close();
		bw.close();
	}
}

异常的日志信息
当程序在执行的时候，出现的问题是不希望直接打印给用户看的，是需要作为文件存储起来，方便程序员查看，并及时调整的。

代码：

import java.io.*;
import java.text.*;
import java.util.*;
class  ExceptionInfo
{
	public static void main(String[] args) 
	{
		try
		{
			int[] arr =new int[2];
			System.out.println(arr[3]);

		}
		catch (Exception e)
		{
			try
			{
				Date d=new Date();//创建时间对象
				//时间模块格式对象
				SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
				String s=sdf.format(d);

				PrintStream ps=new PrintStream("Exception.log");//打印流对象
				System.setOut(ps);//修改输出流设备
				ps.println(s);//输出时间
				
			}
			catch (IOException ex)
			{
				throw new RuntimeException("日志文件创建失败");
			}
			e.printStackTrace(System.out);//将异常信息输出指定输出流
		}
	}
}

结果：

系统属性信息存入文本
获取系统信息：
 Properties getProperties()
将信息输出到指定输出流中
list(PrintStream out) 将属性列表输出到指定的输出流。
 new PrintStream("systeminfo.txt")

代码：

import java.util.*;
import java.io.*;
class SystemInfo
{
	public static void main(String[] args) throws IOException
	{
		Properties prop=System.getProperties();
		
		prop.list(System.out);//打印在控制台上
		prop.list(new PrintStream("SystemInfo.txt"));		
	}
}

最后，上一张IO流各个类之间的关系图：