黑马程序员-Java I/O体系

浏览数：24 / 时间：2015年06月08日

java.io在jdk中的定义：为系统提供输入和输出通过数据流，序列化以及文件系统。

在学习IO体系的时候，我们可以遵循这样的规律：

看父类的共性功能，用子类的对象。

而且，IO体系的好处在于：

每个子类的后缀名都是所属体系的父类的名称，很容易区分所属的体系；而且每个子类前缀名都是该子类对象的功能体系。

Java IO体系：

|OutputStream

|字符流抽象基类

|Writer

常用的字符型的节点流有：

文件：FileReader， FileWriter
内存（数组）：CharArrayReader，CharArrayWriter
内存（字符串）：StringReader，StringWriter
管道：PipedReader，PipedWriter

下面先讲解FileWriter

示例：将一段文字数据写入到硬盘上

import java.io.FileWriter;  
import java.io.IOException;  
  
public class FileWriterDemo {  
    public static void main(String[] args) throws IOException {  
        /*   
        //需求：将一个段文字数据写入到硬盘上. 
        思路： 
        1，一段文字就是字符串数据。 
        2，写到硬盘上，从哪到哪呢？字符串数据在内存中，写到硬盘上——将内存中的数据搞到硬盘上， 
        这就涉及到了设备之间的数据处理。就要用到IO技术。 
        既然是从内存到硬盘，应该是输出流。 
        3，对于文字而言，io中提供了便捷的操作，比如字符流。 
        4，结合两者，需要输出流，需要字符流，可以使用字符输出流。Writer 
        5，具体用哪个子类对象呢？硬盘上用于存储数据的体现：文件。在这个体系中有对象FileWriter 。  
         */  
          
          
        //1，通过FileWriter创建流对象。构造时，必须明确写入数据需要存储的位置。   
        /* 
         * 该对象一创建，目的文件就会被创建。 
         * 如果该文件已经存在，会被覆盖。  
         * 做了什么事呢？在堆内存中创建一个对象。同时调用了系统的资源。 
         */  
        FileWriter fw = new FileWriter("demo.txt");  
          
        //2，使用字符输出流对象将字符串进行写入。调用写入方法。  
        //数据没有直接写入到目的文件中，而是写入到了临时缓冲中。  
        fw.write("abcdef");  
          
        //3，怎么把数据弄到文件中呢？发现Writer类中有一个flush()方法。刷新缓冲区，将缓冲的数据立即写入到目标中。  
        fw.flush();  
          
        fw.write("haha");         
        //4，关闭此流，关闭资源。在关闭之前，先刷一次缓冲，将数据都写入到目的中。  
        fw.close();  
                  
        /* 
         * flush()和close()有什么区别？ 
         * flush():仅将缓冲中的数据刷新到目的地。流对象可以继续使用。可以使用多次。 
         * close():将缓冲中的数据刷到目的地后，直接关闭流资源，流无法继续使用。只能使用一次。 
         * 在close()方法当中其实在关闭之前都会调用一次flush(); 
         *  
         */  
    }  
}

　示例展示了FileWriter的基本流程，但是在程序中的很多地方都会发生异常，因此，有必要了解Java中IO体系的异常处理规范。

示例二：IO异常处理

import java.io.FileWriter;  
import java.io.IOException;  
public class FileWriterDemo3 {  
      
    public static void main(String[] args) {  
        /* 
         * IO异常的处理规范。  
         * 创建流对象—————— 在try外创建流对象的引用。 在try内对流对象进行初始化。 
         */  
        FileWriter fw = null;  
        try {  
            fw = new FileWriter("k:\\demo3.txt");  
  
            fw.write("abcde");  
            fw.flush();  
  
        } catch (IOException e) {  
  
            System.out.println(e.toString());  
        } finally {  
            //在关闭之间必须得判断这个流是否存在，是否被创建。  
            if (fw != null)  
                try {  
                    fw.close();  
                } catch (IOException e) {  
  
                    // 相关的代码处理。比如说，将关闭失败的信息记录到日志文件中。  
                    throw new RuntimeException("关闭失败");  
                }  
        }  
    }  
}

FileReader主要用于读取，读取方式的不同也必然导致效率的不同。

1. 读取单个字符：读取单个字符，在字符可用、发生I/O错误或者已到达流的末尾前，此方法一直阻塞。返回值为读取到的字符数，如果已到达流的末尾，则返回-1.

2. 读取字符数组：将读取到的字符存储到字符数组里面，并且返回字符数组的长度。如果到达流的末尾，返回-1.

import java.io.FileNotFoundException;  
import java.io.FileReader;  
import java.io.IOException;  
  
public class FileReaderTest {  
  
    public static void main(String[] args) throws IOException {  
        // TODO Auto-generated method stub  
        FileReader fr = new FileReader("IO流.txt");  
          
        //演示读取单个字符  
        long time = System.currentTimeMillis();  
        readChar(fr);  
        long timereadChar = System.currentTimeMillis();  
          
        System.out.println("time Read char is  = " + (timereadChar-time));  
        //演示读取字符到缓冲区中。  
          
        long time2 = System.currentTimeMillis();  
        readToBuf(fr);  
        long timeReadBuf = System.currentTimeMillis();  
        System.out.println("time Read to Buf is =  " + (timeReadBuf-time2));  
          
  
    }  
    private static void readToBuf(FileReader fr) throws IOException {  
        //定义一个字符缓冲区，用于存放读到的字符。  
        char[] buf = new char[50];  
        //设刚开始读到的字符为0  
        int len = 0 ;  
        //一直循环读取字符到缓冲区中，直到读到流的末尾。  
        while((len = fr.read(buf)) != -1){  
            //将每次读满的缓冲区中的字符，变成字符串打印出来。  
            System.out.println(new String(buf , 0 , len));        
        }     
    }  
    private static void readChar(FileReader fr) throws IOException {  
        //设每个读取到的字符整数值为ch.  
        int ch = 0;   
        //循环读取字符，直到流的末尾  
        while((ch = fr.read()) != -1){  
            //将读取到的字符，强制转换为 char  
            System.out.print((char) ch);  
        }  
    }  
}

缓冲区：
流对象的read()：是从目的地一次读取一个。

缓冲区的read()：是通过流对象的read将一批数据读取到缓数组，然后再从数组中一次取一个，所以内存操作要比硬盘操作要高效。

在Java中，为了提高程序的效率，为我们提供了对应的类：

BufferedReader和BufferedWriter。

示例三：

import java.io.BufferedWriter;  
import java.io.FileWriter;  
import java.io.IOException;  
  
public class BufferedWriterDemo {  
  
    public static void main(String[] args) throws IOException {  
  
        //创建一个流对象。  
        FileWriter fw = new FileWriter("buf.txt");  
          
        //为了提高效率。创建缓冲区对象，并和要被提高效率的流相关联。   
        BufferedWriter bufw = new BufferedWriter(fw);  
      
        for(int x=0;x<4; x++){  
            bufw.write(x+"--hahaha");  
            //写入一个换行符。  
            bufw.newLine();  
            //要对缓冲区进行刷新。记住：一般只要使用了缓冲区，就一定要刷新。   
            bufw.flush();  
        }  
          
        //关闭缓冲区。   
        bufw.close();//问：还用关闭fw.close()?不用，因为关闭缓冲区，其实就是在关闭缓冲区关联的流。  
          
    }  
}

示例四：

import java.io.BufferedReader;  
import java.io.FileReader;  
import java.io.IOException;  
  
public class BuffereReaderDemo {  
  
    public static void main(String[] args) throws IOException {  
        /** 
         * 演示：BufferedReader 
         * 1. 先有字符读取流； 
         * 2. 该类有一个特有方法。readLine(). 一次读一行。 
         */  
        //创建读取流对象 和 文件相关联。  
        FileReader fr = new FileReader("Demo.txt");  
          
        //创建读取缓冲区对象 和 流对象关联对其进行高效 操作；  
        BufferedReader  bufr = new BufferedReader(fr);  
        //简写形式：  
        //BufferedReader bufr = new BufferedReader(new FileReader("Demo.txt"));  
          
        String line = null ;  
        while((line = bufr.readLine()) != null){  
            System.out.println(line);  
        }  
        bufr.close();  
    }  
}

BufferWriter的出现，增强了Writer体系中的功能，这种设计方式比原理更为灵活，避免了继承的臃肿。由此引出了java的又一种设计模式-装饰设计模式。

具体实例：

Writer

|MediaWriter

运用缓冲技术提高效率：

Writer

|BufferTextWriter

|BufferMediaWriter

|BufferDataWriter

通过继承的方式提高了效率。但是对于扩展性是一个问题。而且所需的功能越多，子类就越多。一旦加入新类，就需要为它提供高效。

既然都需要缓冲，对数据写入效率进行提高。可以将缓冲技术单独进行封装。哪个对象需要缓冲，就把哪个对象传递给缓冲对象即可。

class Buffer{

Buffer(TextWriterw){

}

Buffer(MediaWriterw){

}

体系就变成了这样：

Writer

|MediaWriter

|--BufferWriter

BufferWriter的出现，增强了Writer体系中的功能。

字符流的常用对象和装饰设计模式简单讨论完了。

字符流处理的数据都是文字，需要将指定的数据，查指定的编码表。而字节流处理的数据不一定都是文字数据，所以不需要指定查表，直接在操作文件数据的时候，就将具体的字节数据写入到目的地址。

下面通过一个示例演示。

示例：copyMp3

import java.io.BufferedInputStream;  
import java.io.BufferedOutputStream;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.FileReader;  
import java.io.FileWriter;  
import java.io.IOException;  
  
public class CopyMp3Test {  
  
    public static void main(String[] args) throws IOException {  
  
        long start = System.currentTimeMillis();  
        copy_1();  
        long end = System.currentTimeMillis();        
        System.out.println("毫秒值:"+(end-start));  
    }  
//不用缓冲区。  
    public static void copy_4() throws IOException {  
          
        FileInputStream fis = new FileInputStream("C:\\0.mp3");  
      
        FileOutputStream fos = new FileOutputStream("c:\\4.mp3");  
          
        int by = 0;  
          
        while((by=fis.read())!=-1){  
            fos.write(by);  
        }  
          
        fos.close();  
        fis.close();  
          
    }  
    //不建议。使用刚刚好的缓冲区。因为文件过大会溢出。  
    public static void copy_3() throws IOException {  
          
        FileInputStream fis = new FileInputStream("C:\\0.mp3");       
        FileOutputStream fos = new FileOutputStream("c:\\3.mp3");  
          
        byte[] buf = new byte[fis.available()];  
          
        fis.read(buf);  
          
        fos.write(buf);  
          
        fos.close();  
        fis.close();  
          
    }  
  
    //使用字节流已有的缓冲区。   
    public static void copy_2() throws IOException {  
          
          
        FileInputStream fis = new FileInputStream("C:\\0.mp3");       
        FileOutputStream fos = new FileOutputStream("c:\\2.mp3");  
          
        BufferedInputStream bufis = new BufferedInputStream(fis);  
        BufferedOutputStream bufos = new BufferedOutputStream(fos);  
          
//      //3,定义一个字节缓冲区。  
//      byte[] buf = new byte[1024];  
          
        int by = 0;  
          
        while((by=bufis.read())!=-1){  
            bufos.write(by);  
        }  
          
        bufos.close();  
        bufis.close();  
          
          
    }  
  
    //自定义数组缓冲区的方式。   
    public static void copy_1() throws IOException {  
          
        //1,读取流对象，和mp3关联。  
        FileInputStream fis = new FileInputStream("C:\\0.mp3");  
        //2,写入流对象，明确存储mp3数据的目的。  
        FileOutputStream fos = new FileOutputStream("c:\\1.mp3");  
          
        //3,定义一个字节缓冲区。  
        byte[] buf = new byte[1024*8];  
          
        int len = 0;  
          
        while((len=fis.read(buf))!=-1){  
            fos.write(buf,0,len);  
        }  
          
        fos.close();  
        fis.close();  
          
    }  
  
}