黑马程序员_IO(上)

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

IO流
一，概述：
IO流用来处理设备之间的数据传输
设备包括：硬盘，内存，键盘录入等等。

二，IO的具体分类

1，根据处理的数据类型不同：字节流和字符流。
2，根据流向不同：输入流和输出流。

3,字符流的由来：
因为文件编码的不同，而有了对字符进行高效操作的字符流对象。
原理：其实就是基于字节流读取字节时，去查了指定的码表。

4,字节流和字符流的区别：
1，字节流读取的时候，读到一个字节就返回一个字节。
字符流使用了字节流读到一个或多个字节(中文对应的字节数是两个，在 UTF-8
码表中是 3 个字节)时。先去查指定的编码表，将查到的字符返回。
2，字节流可以处理所有类型数据，如图片，mp3，avi。
而字符流只能处理字符数据。

结论：只要是处理纯文本数据，就要优先考虑使用字符流。除此之外都用字节流。

三，IO的体系
1）所具备的基本功能就有两个：读和写。
1，字节流
InputStream（读）,OutputStream（写）。
2，字符流：
Reader（读），Writer（写）。

2）基本的读写操作方式：
因为数据通常都以文件形式存在。

所以就要找到 IO 体系中可以用于操作文件的流对象。
通过名称可以更容易获取该对象。
因为 IO 体系中的子类名后缀绝大部分是父类名称。而前缀都是体现子类功能的名字。

四，字符流
Reader
|--InputStreamReader
|--FileReader:专门用于处理文件的字符读取流对象。
Writer
|--OutputStreamWriter
|--FileWriter:专门用于处理文件的字符写入流对象。

（1）Writer 中的常见的方法：
1，write(ch):  将一个字符写入到流中。
2，write(char[]):  将一个字符数组写入到流中。
3，write(String):  将一个字符串写入到流中。
4，flush():刷新流，将流中的数据刷新到目的地中，流还存在。
5，close():关闭资源：在关闭前会先调用 flush()，刷新流中的数据去目的地。然流
关闭。
既然IO流是用于操作数据的，
那么数据的最常见体现形式是：文件。

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

（2）FileWriter
该类没有特有的方法。只有自己的构造函数。
该类特点在于，
1，用于处理文本文件。
2，该类中有默认的编码表，
3，该类中有临时缓冲。

构造函数：在写入流对象初始化时，必须要有一个存储数据的目的地。
FileWriter(String filename):
该构造函数做了什么事情呢？
1，调用系统资源。
2，在指定位置，创建一个文件。
注意：如果该文件已存在，将会被覆盖。
FileWriter(String filename,boolean append):
该构造函数：当传入的 boolean 类型值为 true 时，会在指定文件末尾处进行数
据的续写。

将文本数据存储到一个文件中：

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

 

(3)Reader 中的常见的方法：
1，int read()：
读取一个字符。返回的是读到的那个字符。如果读到流的末尾，返回-1.
2，int read(char[])：
将读到的字符存入指定的数组中，返回的是读到的字符个数，也就是往数组里
装的元素的个数。如果读到流的末尾，返回-1.
3，close():
读取字符其实用的是 window 系统的功能，就希望使用完毕后，进行资源的释
放。
(4)FileReader：
1，用于读取文本文件的流对象。
2，用于关联文本文件。

构造函数：在读取流对象初始化的时候，必须要指定一个被读取的文件。
如果该文件不存在会发生 FileNotFoundException.
FileReader(String filename);

用一段代码体现：

 

import java.io.*;;public class FileReaderDemo {public static void main(String[] args)throws Exception {//创建一个文件读取流对象，和指定名称的文件相关联。//要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundExceptionFileReader fr =new FileReader("demo.txt");//调用读取流对象的read方法。//read():一次读一个字符。而且会自动往下读。int ch =0;//如果读取已到达流的末尾，则返回 -1 while((ch=fr.read())!=-1){System.out.println((char)ch);}fr.close();}}

第二种方式：通过字符数组进行读取。

import java.io.*;class FileReaderDemo2 {public static void main(String[] args) throws IOException{FileReader fr = new FileReader("demo.txt");//定义一个字符数组。用于存储读到字符。//该read(char[])返回的是读到字符个数。char[] buf = new char[1024];//该长度通常都是 1024 的整数倍int num = 0;while((num=fr.read(buf))!=-1){System.out.println(new String(buf,0,num));}fr.close();}}

 

五，IO异常的处理
对于读取或者写入流对象的构造函数，以及读写方法，还有刷新关闭功能都会抛出
IOException 或其子类。

所以都要进行处理。或者 throws 抛出，或者 try   catch 处理。
比如：

import java.io.*;public class FileWriterDemo {public static void main(String[] args) {       FileWriter fw =null;//在这里建立一个引用 这样fw变量作用于整个函数try{//这个代码块写的内容在finally中是访问不到的     fw =new FileWriter("demo.txt");fw.write("abcdeff");}catch(IOException e){System.out.println("catch:"+e.toString());}finally{try{   //这里要判断下文件是否被创建，如果创建了 才执行close 否则会抛出异常if(fw!=null)fw.close();//因为创建IO流对象后 必须得关闭流资源 所以close放在了finally中}catch(IOException e){System.out.println(e.toString());}}}}

 

一个小细节：
当指定绝对路径时，定义目录分隔符有两种方式：
1，反斜线 但是一定要写两个。\\    new FileWriter("c:\\demo.txt");
2，斜线    /   写一个即可。 new FileWriter("c:/demo.txt");

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

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

 

import java.io.*;class CopyText {public static void main(String[] args) throws IOException{copy_2();}    //方法2  定义一个数组 直接读取一个数组的长度public static void copy_2(){FileWriter fw = null;FileReader fr = null;try{fw = new FileWriter("D:/ExceptionDemo_copy.txt");fr = new FileReader("E:/java/java2013/day09/ExceptionDemo.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){}if(fw!=null)try{fw.close();//关闭流资源}catch (IOException e){}}}//从C盘读一个字符，就往D盘写一个字符。public static void copy_1()throws IOException{//创建目的地。FileWriter fw = new FileWriter("D:/ExceptionDemo_copy.txt");//与已有文件关联。FileReader fr = new FileReader("E：/java/java2013/day09/ExceptionDemo.java");int ch = 0;while((ch=fr.read())!=-1){fw.write(ch);}fw.close();fr.close();}}

六，字符串的缓冲区
缓冲区的出现是为了提高流的操作效率而出现的。
原理：其实就是将数组进行封装。
缓冲区要结合流才可以使用。在流的基础上对流的功能进行了增强。
所以在创建缓冲区之前，必须要先有流对象。
其实缓冲内部就是在使用流对象的方法，只不过加入了数组对数据进行了临时存储。为
了提高操作数据的效率。

对应类
BufferedWriter
BufferedReader

1）BufferedWriter
概念：将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
特有方法：
该缓冲区中提供了一个跨平台的换行符。
newLine();
/r/n是对于windows而言的换行。
比如下面的代码：

 

import java.io.*;class  BufferedWriterDemo{public static void main(String[] args) throws IOException{//创建一个字符写入流对象。FileWriter fw = new FileWriter("buf.txt");//为了提高字符写入流效率。加入了缓冲技术。//只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。BufferedWriter bufw = new BufferedWriter(fw);for(int x=1; x<5; x++){bufw.write("abcd"+x);bufw.newLine();//写入一个字符就换行一次bufw.flush();//写入一次就刷新一次}//记住，只要用到缓冲区，就要记得刷新。//bufw.flush();//其实关闭缓冲区，就是在关闭缓冲区中的流对象。bufw.close();}}

 

2）BufferedReader
概念：从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
字符读取流缓冲区：
该缓冲区提供了一个一次读一行的方法 readLine，方便于对文本数据的获取。
当返回null时，表示读到文件末尾。

readLine方法返回的时候只返回回车符之前的数据内容。并不返回回车符。
比如下面的代码：

import java.io.*;class  BufferedReaderDemo{public static void main(String[] args) throws IOException{//创建一个读取流对象和文件相关联。FileReader fr = new FileReader("buf.txt");//为了提高效率。加入缓冲技术。将字符读取流对象作为参数传递给缓冲对象的构造函数。BufferedReader bufr = new BufferedReader(fr);String line = null;//按照行的形式取出数据。取出的每一个行数据不包含回车符。//当readLine方法返回的数据不为空时，循环打印每行的数据内容while((line=bufr.readLine())!=null){System.out.print(line);}//关闭缓冲区也就是关闭该流并释放与之关联的所有资源。bufr.close();}}

练习：通过缓冲区的形式，对文本文件进行拷贝。

public static void main(String[] args) { BufferedReader bufr = new BufferedReader(new FileReader("a.txt")); BufferedWriter bufw = new BufferedWriter(new FileWriter("b.txt")); String line = null; while((line=bufr.readLine())!=null) { bufw.write(line); bufw.newLine(); bufw.flush(); } bufw.close(); bufr.close(); } 

readLine()的原理：
无论是读一行，或者读取多个字符，其实最终都是在硬盘上一个一个读取。
所以最终使用的还是read方法一次读一个的方法。
明白了BufferedReader类中特有方法readLine的原理后，
可以自定义一个类中包含一个功能和readLine一致的方法。
来模拟一下BufferedReader

import java.io.*;class MyBufferedReader extends Reader{private Reader r;MyBufferedReader(Reader r){this.r = r;}//可以一次读一行数据的方法。public String myReadLine()throws IOException{//定义一个临时容器。原BufferReader封装的是字符数组。//为了演示方便。定义一个StringBuilder容器。因为最终还是要将数据变成字符串。StringBuilder sb = new StringBuilder();int ch = 0;while((ch=r.read())!=-1){if(ch=='\r')continue;if(ch=='\n')return sb.toString();elsesb.append((char)ch);}//防止哪一行的最后的\n被去掉而没有返回这行的数据if(sb.length()!=0)return sb.toString();return null;}/*覆盖Reader类中的抽象方法。*/public int read(char[] cbuf, int off, int len) throws IOException{return r.read(cbuf,off,len) ;}public void close()throws IOException{r.close();}public void myClose()throws IOException{r.close();}}class  MyBufferedReaderDemo{public static void main(String[] args) throws IOException{FileReader fr = new FileReader("buf.txt");MyBufferedReader myBuf = new MyBufferedReader(fr);String line = null;while((line=myBuf.myReadLine())!=null){System.out.println(line);}myBuf.myClose();}}

 

它的出现基于流并增强了流的功能。这也是一种设计模式的体现：装饰设计模式。
对一组对象进行功能的增强。

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

装饰类通常会通过构造方法接收被装饰的对象。
并基于被装饰的对象的功能，提供更强的功能。
该模式和继承有什么区别呢？
它比继承有更好的灵活性。
通常装饰类和被装饰类都同属与一个父类或者接口。
Writer
|--MediaWriter
|--TextWriter

（注：MediaWriter 与 TextWtiter 两个类在 JDK 中并不存在，为了更形象的举例说明而
“创建”的，不要误解。）
需求：想要对数据的操作提高效率，就用到了缓冲技术。
通过所学习的继承特性。可以建立子类复写父类中的 write 方法。即可
Writer：（注：不要误解，以下两个对象不存在，只为举例。）
|--MediaWriter
|--BufferedMediaWriter
|--TextWriter
|--BufferedTextWriter
当 Writer 中子类对象过多，那么为了提高每一个对象效率，每一个对象都有一个自己
的子类 Buffered。
虽然可以实现，但是继承体系变的很臃肿。

那么是否可以对其进行一下优化呢？
其实子类都是在使用缓冲技术。
可不可以对缓冲技术进行描述，将需要增强的对象传递给缓冲区即可。

class BufferdWriter
{
BufferedWriter(MediaWriter mw)
{ }
BufferedWriter(TextWriter mw)
{ }
}

该类虽然完成了对已有两个对象的增强。
但是当有新的对象出现时，还要继续在该类中添加构造函数。这样不利于扩展和维护。
将对这些对象父类型进行操作即可。这就是多态，提高了程序的扩展性。
同时 BufferedWriter 中一样具有 write 方法，只不过是增强后的 write。

所以 BuferedWriter 也应该是 Writer 中的一个子类。

class BufferedWriter extends Writer { private Writer w; BufferedWriter(Writer w) { this.w = w; } } 

 

Writer  
|--MediaWriter
|--TextWriter
|--BufferedWriter
这样就会发现装饰设计模式，优化增强功能的部分。比继承要灵活很多。

比如：可以在读一行的基础上添加一个行号。

class MyLineNumberReader extends MyBufferedReader
{
 //将lineNumber私有化 作为成员变量
 private int lineNumber;
 //将被装饰的对象传进来装饰即可
 MyLineNumberReader(Reader r)
 {
  //直接传给父类即可 父类已有方法描述
  super(r);
 }
 //读一行的方法
 public String myReadLine()throws IOException
 {
  //每读取一行 行号加一
  lineNumber++;
  return super.myReadLine();
 }
 //子类特有方法 get和set 设置和获取行号
 public void setLineNumber(int lineNumber)
 {
  this.lineNumber = lineNumber;
 }
 public int getLineNumber()
 {
  return lineNumber;
 }
}

五，字节流
抽象基类：InputStream，OutputStream。

字节流可以操作任何数据。

注意：字符流使用的数组是字符数组。char [] chs
字节流使用的数组是字节数组。byte [] bt
FileOutputStream 用于写入诸如图像数据之类的原始字节的流。
FileInputStream 用于读取诸如图像数据之类的原始字节流。
用一段代码体现：

FileOutputStream fos = new FileOutputStream("a.txt"); fos.write("abcde");//直接将数据写入到了目的地。fos.close();//只关闭资源。FileInputStream fis = new FileInputStream("a.txt"); //fis.available();//获取关联的文件的字节数。//如果文件体积不是很大。//可以这样操作。byte[] buf = new byte[fis.available()];//创建一个刚刚好的缓冲区。//但是这有一个弊端，就是文件过大，大小超出 jvm 的内容空间时，会内存溢出。fis.read(buf); System.out.println(new String(buf)); 

需求：copy 一个图片。
思路：
1，用字节读取流对象和图片关联。
2，用字节写入流对象创建一个图片文件。用于存储获取到的图片数据。
3，通过循环读写，完成数据的存储。
4，关闭资源。
比如：

//用字节读取流对象和图片1.jpg关联。BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("1.jpg")); //用字节写入流对象创建一个图片文件2.jpg。用于存储获取到的图片数据。BufferedOutputStream bufos = new BufferedOutputStream(new FileOutptStream("2.jpg")); int by = 0; //当读取完毕返回-1while((by=bufis.read())!=-1) { bufos.write(by); } //关闭流资源bufos.close(); bufis.close(); 

 

目前学习的流对象
字符流：
FileReader.
FileWriter.

BufferedReader
BufferedWriter.

字节流：
FileInputStream
FileOutputStream

BufferedInputStream
BufferedOutputStream
字节流的 read()方法读取一个字节。为什么返回的不是 byte 类型，而是 int 类型呢？

因为 read 方法读到末尾时返回的是-1.
而在所操作的数据中的很容易出现连续多个 1 的情况，而连续读到 8 个 1，就是-1.
导致读取会提前停止。

所以将读到的一个字节给提升为一个 int 类型的数值，但是只保留原字节，并在剩余二进制
位补 0.
具体操作是：byte&255    or    byte&0xff

对于 write 方法，可以一次写入一个字节，但接收的是一个 int 类型数值。
只写入该 int 类型的数值的最低一个字节（8 位）。

简单说:read 方法对读到的数据进行提升。write 对操作的数据进行转换。

六，转换流
1）特点：
1，是字节流和字符流之间的桥梁。
2，该流对象中可以对读取到的字节数据进行指定编码表的编码转换。

什么时候使用呢?
1，当字节和字符之间有转换动作时。
2，流操作的数据需要进行编码表的指定时。

具体的对象体现：
1，InputStreamReader：字节到字符的桥梁。
2，OutputStreamWriter：字符到字节的桥梁。

这两个流对象是字符流体系中的成员。

那么它们有转换作用，而本身又是字符流。所以在构造的时候，需要传入字节流对象进
来。

2）构造函数：
InputStreamReader(InputStream):通过该构造函数初始化，使用的是本系统默认的编码表
GBK。

InputStreamReader(InputStream,String charSet):通过该构造函数初始化，可以指定编码表。

OutputStreamWriter(OutputStream):通过该构造函数初始化，使用的是本系统默认的编
码表 GBK。

OutputStreamWriter(OutputStream,String charSet):通过该构造函数初始化，可以指定编码
表。

读取键盘录入。
System.out:对应的是标准输出设备，控制台。
System.in:对应的标准输入设备：键盘。

而键盘录入的read方法是字节流InputStream的方法。

那么能不能将字节流转成字符流在使用字符流缓冲去的readLine方法呢？

用一段代码体现：

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);//键盘的最常见写法。BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));//OutputStream out = System.out;//OutputStreamWriter osw = new OutputStreamWriter(out);//BufferedWriter bufw = new BufferedWriter(osw);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();}bufr.close();}}

 

3）操作文件的字符流对象是转换流的子类。
 Reader
|--InputStreamReader
|--FileReader

Writer  
|--OutputStreamWriter
|--FileWriter
转换流中的 read 方法。已经融入了编码表，
在底层调用字节流的 read 方法时将获取的一个或者多个字节数据进行临时存储，
并去查指定的编码表，如果编码表没有指定，
查的是默认码表。那么转流的 read 方法就可以返回一个字符比如中文。

转换流已经完成了编码转换的动作，对于直接操作的文本文件的 FileReader 而言，就不
用在重新定义了，
只要继承该转换流，获取其方法，就可以直接操作文本文件中的字符数据了。

注意：
在使用 FileReader 操作文本数据时，该对象使用的是默认的编码表。
如果要使用指定编码表时，必须使用转换流。

FileReader fr = new FileReader("a.txt");//操作 a.txt 的中的数据使用的本系统默认的 GBK。

操作 a.txt 中的数据使用的也是本系统默认的 GBK。
InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));

这两句的代码的意义相同。

如果 a.txt 中的文件中的字符数据是通过 utf-8 的形式编码。
那么在读取时，就必须指定编码表。
那么转换流必须使用。
InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"utf-8");

4）流操作的基本规律。

通过三个明确来完成。

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

拓展：
想要把录入的数据按照指定的编码表（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);

 所以，记住。转换流什么使用。字符和字节之间的桥梁，通常，涉及到字符编码转换时，
 需要用到转换流。

 

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