黑马程序员——Java IO流（一）之IO流概述、字符流、字节流等

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

IO流

一、概述

　1.IO流是用来处理设备之间的数据传输。

　2.Java对数据的操作时通过流的方式。

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

　4.流按操作数据分为两种：字节流和字符流。流按流向分为：输入流和输出流。

　5.流常用的基类：

　　1）字节流的抽象基类：ImputStream和OutputStream。

　　2）字符流的抽象基类：Reader和Writer。

　6.体系架构：

　　字符流体系架构：

　　　Reader：用于读取字符流的抽象类。

　　　　|--BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

　　　　　　|--LineNumberReader：跟踪行号的缓冲字符输入流。

　　　　|--InputStreamReader：转换流，是字节流通向字符流的桥梁。

　　　　　　|--FileReader：用来读取字符文件的便捷类。

　　　Writer：写入字符流的抽象类。

　　　　|--BufferedWriter:将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

　　　　|--OutputStreamWriter：转换流，是字符流通向字节流的桥梁。

　　　　　　|--FileWriter:用来写入字符文件的便捷类。

　　字节流体系架构：

　　　ImputStream：此抽象类是表示字节输入流的所有类的超类。

　　　　|--FileInputStream：从文件系统中的某个文件中获得输入字节， 用于读取诸如图像数据之类的原始字节流。

　　　　|--FilterInputStream：

　　　　　　|--BufferedInputStream：字节输入流缓冲区。

　　　OutputStream：此抽象类是表示输出字节流的所有类的超类，输出流接受输出字节并将这些字节发送到某个接收器。

　　　　|--FileOutputStream：文件输出流是用于将数据写入 File 或 FileDescriptor 的输出流，用于写入诸如图像数据之类的原始字节的流。

　　　　|--FilterOutputStream：此类是过滤输出流的所有类的超类。

　　　　　　|--BufferedOutputStream：该类实现缓冲的输出流。通过设置这种输出流，应用程序就可以将各个字节写入底层输出流中，而不必针对每次字节写入调用底层系统。

　　　　　　|--PrintStream:为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。打印的所有字符都使用平台的默认字符编码转换为字节。PrintStream 永远不会抛出 IOException，而是，异常情况仅设置可通过 checkError 方法测试的内部标志。在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类。

　问题思考：字节流和字符流有什么不同？

　　答：字节流可以用于进行任何数据类型的操作，而字符流带编码表，只能用于进行纯文本数据类型的操作。

二、格式示例

　IO异常格式的处理：

import java.io.*;
class  FileWriterDemo2
{
	public static void main(String[] args) 
	{
		//需要将fw引用定义在外部，因为在finally中需要调用close方法
		FileWriter fw=null;
		try
		{
			//创建对象的时候，需要定义在try里面，因为抛出了IO异常。
			fw=new FileWriter("E:\\heima\\deme2.txt");

			//write方法抛出了IO异常。
			fw.write("hello world");
		}
		catch (IOException e)
		{
			System.out.println("cacht="+e.toString());
		}
		finally 
		{
			//关闭流资源一定要执行，需定义在finally内部，且close方法抛出了
			//IO异常，需要进行try处理。
			try
			{
				//需要对fw是否为null进行判断，因为如果fw为null，则再调用close方法
				//发发生NullPoterException异常。如果有多个流资源需要关闭，应进行多次
				//判断并关闭，不要写在一个判断里。
				if (fw!=null)
				{
					fw.close();
				}
			}
			catch (IOException ex)
			{
				System.out.println(ex.toString());
			}
		}
	}
}

三、字符流

　字符流常用对字符文件的操作。对于字符流的操作，应熟练掌握以下几个内容：

　1.在指定目录下创建一个纯文本文件，并在这个文件中写入指定内容：

　　示例1：在"E:\\heima＂的目录下创建纯文本文件demo.txt，并向该文件demo.txt写入内容。

import java.io.*;
class FileWriterDemo 
{
	public static void main(String[] args) throws IOException
	{
		
		FileWriter fw=null;
		try
		{
			//fileWriter对象一被初始化就必须明确被操作的文件的对象。
			//而且该文件会被创建到指定目录下，如果该目录下已有同名文件存在，
			//则将被覆盖。由于创建的目录可能不存在，因此抛出了IOException。
			fw=new FileWriter("E:\\heima\\demo.txt");

			//调用write方法，将字符串写入到流中。
			fw.write("nihao");

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

			//可重复进行写入数据到文件中。
			fw.write("hello");
			fw.flush();
		}
		catch (IOException e)
		{
			System.out.println("cacht="+e.toString());
		}
		finally 
		{
			try
			{
				if (fw!=null)
				{
					//关闭流对象，在关闭前会刷新流一次。关闭后不能再向流中写入数据，
					//否则将发生IO异常。该动作一定做，因为流在调用window资源，需要进行关闭。
					fw.close();
				}
			}
			catch (IOException ex)
			{
				System.out.println(ex.toString());
			}
		}
	}
}

　　程序运行后在"E:\\heima＂的目录下的创建了一个Demo.txt文件，文件的内容如下图：

　2.对指定目录下的一个纯文本文件进行内容续写：

　　示例2：对示例1中创建的文件demo.txt进行内容续写。

import java.io.*;
class  FileWriterDemo3
{
	public static void main(String[] args) 
	{
		FileWriter fw=null;
		try
		{
			//传递一个true穿参数，代表不覆盖已有文件，并在已有文件末尾处添加。
			//如果没有已有文件，则会新创建一个文件。
			fw=new FileWriter("E:\\heima\\demo2.txt",true);

			//添加内容
			fw.write("zhangsan");
		}
		catch (IOException e)
		{
			System.out.println(e.toString());
		}
		finally
		{	
			try
			{
				if (fw!=null)
				{
					fw.close();
				}
			}
			catch (IOException ex)
			{
				System.out.println(ex.toString());
			}
		}
	}
}

　　程序运行后，在示例1中的demo.txt文件内容中续写了一些指定内容，截图如下：

　3.写入内容的方法总结：

　　1）写入单个字符。

　　　void write(int c)：将int类型的字符c写入到指定目的对象中。

　　2）写入字符数组或其中的某一部分。

　　　void write(char[] cbuf)：将字符数组cbuf中的全部字符写入到指定对象中。

　　　void write(char[] cbuf,int off,int len)：将字符数组cbuf中从索引off开始写入到指定对象，写入的字符总数为len。

　　3）写入字符串或其中的某一部分。

　　　void write(String str)：将整个字符串内容写入到指定对象中。

　　　void write(String str,int off,int len)：将字符串str中从索引off开始写入到指定对象，写入的字符总数为len。

　　注：上述所有写入的方法都会抛出IOException异常。　

　4.对指定目录下的一个纯文本文件进行内容读取：

　　示例3：对示例2续写的文件demo.txt进行内容读取并打印到控制台。

import java.io.*;
class FileReaderDemo1 
{
	public static void main(String[] args) 
	{
		FileReader fr=null;
		try
		{
			//创建一个文件读取流对象，和指定的文件demo.txt相关联。
			//要保证该文件是存在的，如果不存在则会发生FileNotFoundException异常。
			fr=new FileReader("E:\\heima\\demo.txt");

			int ch=0;

			//read()方法读取文件的内容，一次读一个字符，而且会自动往下读。
			//循环读取文件内容，如果读到文件末尾则会返回-1，可根据此条件
			//来判断是否继续读取。
			while ((ch=fr.read())!=-1)
			{
				System.out.print((char)ch); //将读取到int类型数据转换成字符类型输出。
			}
		}
		catch (IOException e)
		{
			System.out.println(e.toString());
		}
		finally
		{	
			try
			{
				if (fr!=null)
				{
					fr.close();
				}
			}
			catch (IOException ex)
			{
				System.out.println(ex.toString());
			}
		}
	}

}

　　程序运行后的结果如下图：

　5.读取内容的方式总结：

　　1）读取单个字符。

　　　int read()：返回值为读取的int类型字符。如果读取的字符已到达流的末尾，则返回 -1。

　　2）将字符读入数组或数组中的某一部分。

　　　int read(char[] cbuf)：将字符读入数组。在某个输入可用、发生 I/O 错误或者已到达流的末尾前，此方法一直阻塞。

　　　int read(char[] cbuf,int offset,int length)：将字符读入字符数组cbuf中，从索引offset开始存储，存入的字符个数限制为length。

　　　注：返回值为实际存储到字符数组的个数。如果读取的字符数已到达流的末尾，则返回 -1。

　　3）将字符读入指定的字符缓冲区。了解charBuffer更多用法，参加AIP文档。

　　　int read(CharBuffer target)：返回值为添加到缓冲区的字符数量，如果此字符源位于缓冲区末端，则返回 -1。

　6.字符流缓冲区：

　　1）BufferedWriter:字符流写入缓冲区。

　　写入数据的方法有：

　　　a）写入单个字符：

　　　　void write(int c):该方法抛出了IO异常。

　　　b）写入字符数组：

　　　　void write(char[] c):该方法抛出了IO异常。

　　　c）写入字符数组的某一部分：

　　　　void write(char[] cbuf, int off, int len) ：该方法抛出了IO异常。

　　　d）写入字符串：

　　　　void write(String str):该方法抛出了IO异常。

　　　e）写入字符串的某一部分：

　　　　write(String s, int off, int len)：如果 len 参数的值为负数，则不写入任何字符。这与超类中此方法的规范正好相反，它要求抛出 IndexOutOfBoundsException。该方法抛出了IO异常。

　　　示例4：使用缓冲区技术，在"E:\\heima＂的目录下创建纯文本文件test.txt，并向该文件test.txt写入内容。

<pre name="code" class="java">import java.io.*;
class BufferedWriterDemo
{
	public static void main(String[] args) 
	{
		//创建字符流读取缓冲区引用
		BufferedWriter bufw=null;

		try
		{
			//创建字符流读取缓冲区对象，并传入文件读取流对象
			bufw=new BufferedWriter(new FileWriter("E:\\heima\\test.txt"));

			//将字符串内容写入到字符流读取缓冲区中
			bufw.write("nihao");

			//刷新缓冲区中的数据，在写入内容不多的情况下，可以不用flush方法，但一定要close方法关闭
			//资源，即将写入的内容最后关闭的时候一次性刷入文件中。如果写入内容很多，应加flush，防止
			//在还没有刷新的情况下，出现停电，导致数据丢失。当加了flush后，可以即时将数据刷入文件中。
			bufw.flush();

			//换行
			bufw.newLine();

			bufw.write("nihao");

			
		}
		catch (IOException e)
		{
			throw new RuntimeException("文件写入失败");
		}
		finally
		{	
			if (bufw!=null)
			{
				try
				{
					bufw.close();
				}
				catch (IOException ex1)
				{
					throw new RuntimeException("写入关闭失败");
				}
			}
			
		}
	}

}

　　程序运行后在"E:\\heima＂的目录下生成了test.txt文件，文件内容如下截图所示：

　2）BufferedReader：字符流读取缓冲区。

　　读取数据的方法有：

　　　a）读取单个字符：

　　　　int read():返回字符的int类型值。如果已到达流末尾，则返回 -1。

　　　b）将字符读入数组：

　　　　int read(char[] cbuf):返回读入的字符数。如果已到达流的末尾，则返回 -1。在某个输入可用、发生 I/O 错误或者已到达流的末尾前，此方法一直阻塞。

　　　c）将字符读入数组的某一部分：

　　　　int read(char[] c,int off,int len):返回读取的字符数。如果已到达流末尾，则返回 -1。

　　　d）读取一个文本行：

　　　　int readLine():返回包含该行内容的字符串，不包含任何行终止符。如果已到达流末尾，则返回 null。

　　　e）试图将字符读入指定的字符缓冲区：

　　　　int read(charBuffer target):返回添加到缓冲区的字符数量，如果此字符源位于缓冲区末端，则返回 -1。

　　　注：上述方法都抛出了IO异常。

　　示例5：使用缓冲区技术，对示例4创建的test.txt文件进行内容读取并打印输出到控制台。

import java.io.*;
class BufferedReaderDemo
{
	public static void main(String[] args) 
	{
		//创建字符流读取缓冲区引用
		BufferedReader bufr=null;

		try
		{
			//创建字符流读取缓冲区对象，并传入文件读取流对象
			bufr=new BufferedReader(new FileReader("E:\\heima\\test.txt"));

			String line=null;

			//调用字符流读取缓冲区对象的readLine方法，如果判断不为空，则继续读下一行
			while ((line=bufr.readLine())!=null)
			{
				System.out.println(line);
			}
		}
		catch (IOException e)
		{
			throw new RuntimeException("文件读取失败");
		}
		finally
		{	
			if (bufr!=null)
			{
				try
				{
					bufr.close();
				}
				catch (IOException ex1)
				{
					throw new RuntimeException("读取关闭失败");
				}
			}
			
		}
	}

}

　　程序运行后的结果如下截图所示：

　7.装饰设计模式：

　　1）概述

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

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

　　　示例6：对已存在的Person类进行功能增强，并用SuperPerson类描述。

<pre name="code" class="java">class PersonDemo 
{
	public static void main(String[] args) 
	{
		SuperPerson sp=new SuperPerson(new Person());
		sp.superEat();
	}
}
class Person
{
	public void eat()
	{
		System.out.println("吃饭");
	}
}

//装饰类
class SuperPerson
{
	private Person p;

	SuperPerson(Person p)
	{
		this.p=p;
	}

	//对eat功能进行增强
	public void superEat()
	{
		System.out.println("开胃酒");
		p.eat();
		System.out.println("甜点");

	}
}

　　程序运行后的结果如下图所示：

　　

　　2）装饰与继承的区别：

　　　继承结构：　　　　

　　　　MyReader　　　　　

　　　　　|--MyTextReader　　　　　　

　　　　　　　|--MyBuffferedTextReader：继承增强类。　　　　　

　　　　　|--MyMediaReader　　　　　　

　　　　　　　|--MyBufferedMediaReader：继承增强类。　　　　　

　　　　　|--MyDataReader　　　　　　

　　　　　　　|--MyBufferedDataReader：继承增强类。

　　　装饰结构：　　　　

　　　　MyReader　　　　　

　　　　　|--MyTextReader　　　　　

　　　　　|--MyMediaReader　　　　　

　　　　　|--MyDataReader　　　　　

　　　　　|--MyBufferedReader:装饰类，用于给MyReader子类的功能进行增强。

　　　区别：装饰模式比继承要灵活，避免了继承体系的臃肿，而且降低了类与类之间的关系。装饰类因为增强已有对象，具备的功能和已有功能是相同的，只不过提供了更强的功能。所以装饰类和被装饰类通常属于一个体系中的。但装饰类只能在被装饰类的父类的基础上进行增强，而继承可以在被继承类的基础上直接增强。

　　3）自定义装饰类：

　　　示例7：模拟BufferedReader类。

//自定义装饰类
class MyBufferedReader extends Reader
{
	private FileReader r;

	MyBufferedReader(FileReader r)
	{
		this.r=r;
	}
	
	//定义读取行功能
	public String myReadLine() throws IOException
	{
		StringBuilder sb=new StringBuilder();

		int ch=0;

		while ((ch=r.read())!=-1)
		{
			
			if (ch=='\r')
				continue;
			else if (ch=='\n')
				return sb.toString();
			else 
				sb.append((char)ch);
			
		}
		if (sb.length()!=0)
		{
			return sb.toString();
		}
	
		return null;

	}

	//直接用传进来的子类进行覆盖，因为该子类一定实现了父类的方法
	public int read(char buf,int off,int len)
	{
		r.read(buf,off,len);
	}
	
	//覆盖父类的close抽象方法
	public void close()
	{
		r.close();
	}
	
}

　8.LinenumberReader类：

　　1）概述

　　　LineNumberReader是BufferedReader的子类，用于跟踪行号的缓冲字符输入流。该类的setLineNumber和getLineNumber方法可以用于设置和获取行号。

　　　示例8：对示例4创建的test.txt文件进行内容读取并打印输出到控制台，且要求打印的内容带有行号，并要求从100行开始输出。

import java.io.*;
class LineNumberReaderDemo
{
	public static void main(String[] args) 
	{
		LineNumberReader lnr=null;

		try
		{
			
			lnr=new LineNumberReader(new FileReader("E:\\heima\\test.txt"));

			String line=null;

			//设置行号为100
			lnr.setLineNumber(100);

			while ((line=lnr.readLine())!=null)
			{
				//连同行号一起打印
				System.out.println(lnr.getLineNumber()+"::"+line);
			}
		}
		catch (IOException e)
		{
			throw new RuntimeException("文件读取失败");
		}
		finally
		{	
			if (lnr!=null)
			{
				try
				{
					lnr.close();
				}
				catch (IOException ex1)
				{
					throw new RuntimeException("读取关闭失败");
				}
			}
			
		}
	}

}

　　程序运行后的结果如下图：

　　2）自定义LineNumberReader类：

/*
自定义LineNumberReader类：

思路：
	1.定义MyLineNumberReader类，并继承BufferedReader。
	2.复写readLine方法，使其没读取一次该方法，行号计数加1。
	3.对外提供设置行号和获取的方法。
*/

import java.io.*;

//继承BufferedReader类，可以使类更加简单，只需定义特有方法即可。
class MyLineNumberReader extends BufferedReader
{
	//定义行号属性
	private int lineNumber;

	MyLineNumberReader(Reader r)
	{
		super(r);
	}

	public String readLine() throws IOException
	{
		//每调用一次行号自增1
		lineNumber++;
		return super.readLine();
	}

	//设置行号
	public void setLineNumber(int lineNumber)
	{
		this.lineNumber=lineNumber;
	}
	
	//获取行号
	public int getLineNumber()
	{
		return lineNumber;
	}

}

　9.代码练习：

　　练习1：完成对示例4创建的test.txt文件的复制。

/*

需求：完成<span style="font-size:14px;">对示例4创建的test.txt文件</span>的复制。

思路：
	1.在指定目录下创建一个文件，用来存储复制文本内容。
	2.创建一个文件读取流对象，与要复制文本文件相关联。
	3.将要复制的文本文件的内容读取到数组中。
	4.将数组中的内容写入到新创建的文件中。
*/
import java.io.*;
class FileCopyDemo1
{
	public static void main(String[] args) 
	{
		FileWriter fw=null;
		FileReader fr=null;

		try
		{
			fw=new FileWriter("E:\\heima\\testCopy.txt");
			fr=new FileReader("E:\\heima\\test.txt");
			
			//定义字符数组用来存储
			char[] buf=new char[1024];

			int num=0;

			
			while ((num=fr.read(buf))!=-1)
			{
				//将数组中的内容写入到新创建的文本文件中,不需要刷新。
				fw.write(buf,0,num);
			}
		}
		catch (IOException e)
		{
			throw new RuntimeException("文件读取失败");
		}
		finally
		{	
			if (fr!=null)
			{
				try
				{
					fr.close();
				}
				catch (IOException ex1)
				{
					throw new RuntimeException("读取关闭失败");
				}
			}
			if (fw!=null)
			{
				try
				{
					fw.close();
				}
				catch (IOException ex2)
				{
					throw new RuntimeException("写入关闭失败");
				}
			}
		}
	}

}

　　程序运行后在"E:\\heima"的目录下创建了一个testCopy.txt文件，该文件的内容的截图如下：

　　练习2：使用字符流缓冲区技术完成练习1。

/*
思路：
	1.在指定目录下创建一个文件，用来存储复制文本内容。定义一个字符写入流缓冲区，并与新创建的文本文件相关联。
	2.创建一个文件读取流对象，与要复制文本文件相关联，定义一个字符读取流缓冲区，并与文件读取流对象相关联。
	3.用readLine方法循环取出字符读取缓冲区的内容。
	4.将readLine取出的内容写入到字符写入流缓冲区中。
	5.用newLine方法换行，并刷新到新创建的文件中。
*/
import java.io.*;
class FileCopyDemo2
{
	public static void main(String[] args) 
	{
		BufferedWriter bufw=null;
		BufferedReader bufr=null;

		try
		{
			bufw=new BufferedWriter(new FileWriter("E:\\heima\\test_Copy.txt"));
			bufr=new BufferedReader(new FileReader("E:\\heima\\test.txt"));

			String line=null;

			
			while ((line=bufr.readLine())!=null)
			{
				
				bufw.write(line);
				bufw.newLine();
				bufw.flush();
			}
		}
		catch (IOException e)
		{
			throw new RuntimeException("文件读取失败");
		}
		finally
		{	
			if (bufr!=null)
			{
				try
				{
					bufr.close();
				}
				catch (IOException ex1)
				{
					throw new RuntimeException("读取关闭失败");
				}
			}
			if (bufw!=null)
			{
				try
				{
					bufw.close();
				}
				catch (IOException ex2)
				{
					throw new RuntimeException("写入关闭失败");
				}
			}
		}
	}

}

　　程序运行后在"E:\\heima"的目录下创建了test_Copy.txt文件，该文件的内容截图如下：

四、字节流

　字节流常用于对非字符文件的操作，如图象、视频等，但不表示字节流不能操作字符文件，而是用字符流来操作字符文件更为便捷。字节流应掌握的内容基本同字符流一致。

　1.写入内容的方法总结：

　　1）将指定字节写入此文件输出流。

　　　void write(int b):该方法抛出了IO异常。

　　2）将 b.length 个字节从指定 byte 数组写入此文件输出流中。

　　　void write(byte[] b):该方法抛出了IO异常。

　　3）将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。

　　　void write(byte[] b,int off,int len):该方法抛出了IO异常。

　　注：上述所有方法都是FileOutputStream类特有方法，且写入文件时，不需要进行刷新操作。

　2.读取内容的方法总结：

　　1）从此输入流中读取一个数据字节。

　　　int read():返回下一个数据字节。如果已到达文件末尾，则返回 -1。

　　2）从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。

　　　int read(byte[] b):返回读入缓冲区的字节总数。如果因为已经到达文件末尾而没有更多的数据，则返回 -1。在某些输入可用之前，此方法将阻塞。

　　3）从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。

　　　int read(byte[] b,int off,int len):读入缓冲区的字节总数，如果因为已经到达文件末尾而没有更多的数据，则返回 -1。如果 len 不为 0，则在输入可用之前，该方法将阻塞；否则，不读取任何字节并返回 0。

　3.复制图片（复制视频等原理类似）：

　　示例9：复制指定目录的文件。

/*

思路：
	1.用字节读取流对象与图片关联。
	2.用字节写入流对象创建一个新的图片文件，用来进行存储获取到的文件数据。
	3.通过循环读写完成数据的存储。
	4.关闭资源。

注：字节流写入数据时不需要刷新，但仍需关闭资源。
*/
import java.io.*;
class  CopyPicDemo
{
	public static void main(String[] args) 
	{
		FileInputStream fis=null;
		FileOutputStream fos=null;

		try
		{
			
			fos=new FileOutputStream("E:\\heima\\2.png"); //创建字节写入流对象，生成复制图像文件。
			fis=new FileInputStream("E:\\heima\\1.png"); //创建字节读取流对象，并与要被复制的图像文件关联。

			byte[] by=new byte[1024];

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

　　程序运行后，复制图像文件与被复制图形文件对比图如下：

　4.字节流缓冲区

　　字节流缓冲区有两个：BufferedInputStream（字节流读取缓冲区）和BufferedOutputStream（字节流写入缓冲区）。

　　从输入流读取数据的方法总结：

　　　1）从输入流中读取数据的下一个字节：　

　　　　int read():返回下一个数据字节。如果到达流末尾，则返回 -1。

　　　2）从此输入流中将 byte.length 个字节的数据读入一个 byte 数组中：

　　　　int read(byte[] b)：返回读入缓冲区的字节总数，如果因为已经到达流末尾而没有更多的数据，则返回 -1。在某些输入可用之前，此方法将阻塞。

　　　3）从此字节输入流中给定偏移量处开始将各字节读取到指定的 byte 数组中：

　　　　int read(byte[] b, int off, int len)：返回读取的字节数。如果已到达流末尾，则返回 -1。

　　　注：上述方法都抛出了IO异常。

　　将数据写入缓冲的输出流的方法：

　　　1）将指定的字节写入此缓冲的输出流：

　　　　void write(int b):该方法抛出了IO异常。

　　　2）将 b.length 个字节写入此输出流：

　　　　void write(byte[] b):该方法抛出了IO异常。

　　　3）将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流：

　　　　void write(byte[] b,int off,int len):该方法抛出了IO异常。

　　示例10：使用缓冲区技术完成对示例9的复制文件操作。

import java.io.*;
class  BufferedStreamDemo
{
	public static void main(String[] args) 
	{
		BufferedInputStream bufis=null;
		BufferedOutputStream bufos=null;

		try
		{
			//创建字节流写入缓冲区对象
			bufos=new BufferedOutputStream(new FileOutputStream("E:\\heima\\2.png"));

			//创建字节流读取缓冲区对象
			bufis=new BufferedInputStream(new FileInputStream("E:\\heima\\1.png"));

			int num=0;
			while ((num=bufis.read())!=-1)
			{
				bufos.write(num);
			}
		}
		catch (IOException e)
		{
			System.out.println(e.toString());
		}
		finally
		{	
			if (bufis!=null)
			{
				try
				{
					bufis.close();
				}
				catch (IOException ex1)
				{
					throw new RuntimeException("读取关闭失败");
				}
			}
			if (bufos!=null)
			{
				try
				{
					bufos.close();
				}
				catch (IOException ex1)
				{
					throw new RuntimeException("写入关闭失败");
				}
			}
			
		}
	}
}

　　 程序运行后，复制图像文件与被复制图形文件对比图如下：

　5.读取键盘录入：

　　示例11：通过键盘录入，当录入一行的数据后，就将该行数据转换成大写并进行打印。如果录入的数据是over，那么停止录入。

/*

System.out:对应的标准输出设备，控制台。
System.in：对应的标准输入设备，键盘。
*/
import java.io.*;
class  ReadInDemo
{
	public static void main(String[] args) 
	{
		InputStream in=System.in;
		StringBuilder sb=new StringBuilder();
		try
		{
			while (true)
			{
				int ch=in.read();
				if (ch=='\r')
				{
					continue;
				}
				else if (ch=='\n')
				{
					String s=sb.toString();
					if (s.equals("over"))
					{
						break;
					}
					System.out.println(s.toUpperCase());
					sb.delete(0,sb.length());
				}
				else 
					sb.append((char)ch);
			}

		}
		catch (IOException ex)
		{
			throw new RuntimeException("发生异常");
		}
		finally
		{
			try
			{
				in.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("关闭失败");
			}
		}
	}
}

　　程序运行后的结果如下图：

　

　6.转换流

　　转换流包括两个：InputStreamReader（字节流通向字符流）和OutpuStreamWriter（字符流通向字节流）。

　　示例12：通过转换流完成对示例11的操作。

import java.io.*;
class  TransStreamDemo
{
	public static void main(String[] args) 
	{
		BufferedReader bufr=null;
		BufferedWriter bufw=null;
		try
		{
			//将字节流转换成字符流输入
			bufr=new BufferedReader(new InputStreamReader(System.in));

			//将字符流转换成字节流输出
			bufw=new BufferedWriter(new OutputStreamWriter(System.out));
			String line=null;
			while ((line=bufr.readLine())!=null)
			{
				if (line.equals("over"))
				{
					break;
				}
				bufw.write(line.toUpperCase());  //将读取内容转换成大写，并写入字符流写入缓冲区
				bufw.newLine();  //换行
				bufw.flush();  //刷新字符流写入缓冲区的数据到控制台
			}
		}
		catch (IOException ex)
		{
			throw new RuntimeException("发生异常");
		}
		finally
		{
			if (bufr!=null)
			{
				try
				{
					bufr.close();
				}
				catch (IOException e)
				{
					throw new RuntimeException("读取关闭失败");
				}
			}
			if (bufw!=null)
			{
				try
				{
					bufw.close();
				}
				catch (IOException e)
				{
					throw new RuntimeException("写入关闭失败");
				}
			}
		}
	}
}

　　程序运行后的结果如下图：

五、自定义缓冲区

　1.自定义字符流缓冲区：

　　字符流缓冲区提供了一个一次读一行的方法readline，方便于对文本数据的读取。当返回null时，表示读到文件末尾。

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

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

　　示例13：自定义字符流读取缓冲区。

<pre name="code" class="java">import java.io.*;
class MyBufferedReaderDemo
{
	public static void main(String[] args) 
	{
		MyBufferedReader bufr=null;

		try
		{
			//创建自定义字符流读取缓冲区对象
			bufr=new MyBufferedReader(new FileReader("E:\\heima\\BufferDemo.txt"));

			String line=null;

			
			while ((line=bufr.myReadLine())!=null)
			{
				System.out.println(line);
			}
		}
		catch (IOException e)
		{
			throw new RuntimeException("文件读取失败");
		}
		finally
		{	
			if (bufr!=null)
			{
				try
				{
					bufr.myClose();
				}
				catch (IOException ex1)
				{
					throw new RuntimeException("读取关闭失败");
				}
			}
			
		}
	}

}

//自定义字符读取流缓冲区
class MyBufferedReader
{
	private FileReader r;

	MyBufferedReader(FileReader r)
	{
		this.r=r;
	}
	
	//定义读取行功能
	public String myReadLine() throws IOException
	{
		StringBuilder sb=new StringBuilder();

		int ch=0;

		while ((ch=r.read())!=-1)
		{
			
			if (ch=='\r')
				continue;
			else 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
	{
		r.close();
	}
}

　　文件BufferedDemo.txt内容截图如下：

　　

　　 程序运行后的结果如下图：

　2.自定义字节流缓冲区：

　　示例14：自定义字节流读取缓冲区。

import java.io.*;
class  MyBufferedInputStreamDemo
{
	public static void main(String[] args) 
	{
		MyBufferedInputStream mybufis=null;
		BufferedOutputStream bufos=null;

		try
		{
			//创建自定义字节流写入缓冲区对象
			bufos=new BufferedOutputStream(new FileOutputStream("E:\\heima\\2.mp3"));

			//创建字节流读取缓冲区对象
			mybufis=new MyBufferedInputStream(new FileInputStream("E:\\heima\\1.mp3"));

//			byte[] by=new byte[1024];

			int num=0;
			while ((num=mybufis.myRead())!=-1)
			{
				//num是int类型，那么写入文件的字节数是不是4个字节呢？不是的，因为write方法
				//里对int类型做了强制类型转换，只保留了int类型的最后八位。所以还是只写入了
				//一个字节的数据。
				bufos.write(num);
			}
		}
		catch (IOException e)
		{
			throw new RuntimeException("文件复制失败");
		}
		finally
		{	
			if (mybufis!=null)
			{
				try
				{
					mybufis.myClose();
				}
				catch (IOException ex1)
				{
					throw new RuntimeException("读取关闭失败");
				}
			}
			if (bufos!=null)
			{
				try
				{
					bufos.close();
				}
				catch (IOException ex1)
				{
					throw new RuntimeException("写入关闭失败");
				}
			}
			
		}
	}
}

//自定义字节流读取缓冲区
class MyBufferedInputStream 
{
	private InputStream is;
	private byte[] by=new byte[1024*4];
	private int pos=0,count=0;

	MyBufferedInputStream(InputStream is)
	{
		this.is=is;
	}
	
	//一次读一个字节，从缓冲区（字节数组）获取
	public int myRead() throws IOException
	{

		if (count==0)
		{
			//通过is对象获取硬盘上的数据，并存储在by数组中
			count=is.read(by);
			pos=0;
		}
		if (count>0)
		{
			int b=by[pos];
			pos++;
			count--;

			//为什么要与上255？因为字节流的字节数据都是二进制，如果读取的一个字节数据为1111-1111，即十进制为-1，
			//那么提升为int类型时，还是-1，此时这个字节数据的-1就会和循环读取的判断条件-1一致，导致循环停止，复
			//制文件失败，所以需与上255，从而保证int类型的最后一个八位不变，前面三个八位都为0，此时就不会出现返回
			//-1的现象。这也是返回类型不是byte而是int的原因所在。
			return b&255;
		}
		return -1;
	}

	public void myClose() throws IOException
	{
		is.close();
	}
}

　　程序运行后的截图如下：