java处理流，IO

字符流的抽象基类是：Writer 和 Reader ！

用于操作字符流的子类对象有：

1. FileReader  和 FileWriter .

        2. 功能对象：BufferedReader  和 BufferedWriter  他们分别对应于：FileReader 和 FileWriter ，用来达到对FileReader  和 FileWriter 的高效操作，具体见下文讲解。

——————————————————————————————————————————

 

【FileWriter】的学习，将从如下5点展开，并通过具体示例来体现：

1.      基本方法的演示

2.      对象创建的细节。

3.       对象操作的细节：close()  write()  flush()

4.      续写换行

5.      文件处理是的——异常处理规范！

 

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

 

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();
         *
         */
    }
}

 

通过上述示例，我们必须注意以下几点：

1.      通过FileWriter创建流对象。构造时，必须明确写入数据需要存储的位置。

2.      使用字符输出流对象将字符串写入时，必须调用 writer（） 方法，但是这些字符并没有直接被写到 目的地中，而是被写在了Writer类默认的缓冲区中，这可以在Java源代码中查到。

3.      将缓冲区中的数据写到目的中，需要调用flush()方法，将缓冲区刷新。

4.      在一系列操作完成后，必须要做的动作是，关闭流，释放系统资源。需调用close（）。

5.      其次就是，flush（）和 close（）方法调用，这两者之间的区别：上文已经提到，不在赘述。

 

示例二：想对刚才的文件demo.txt 进行一个续写！

 

import java.io.FileWriter;
import java.io.IOException;

public class FileWriterDemo2 {

private static final String LINE_SPARATOR = System.getProperty("line.separator");

    public static void main(String[] args) throws IOException {

        /*
         * 需求：想要来个续写。
         * 这个对象创建是不行的，因为该构造一创建，就覆盖了已有的文件。
         * 可以使用另一个构造函数，加入一个boolean参数，为true，就可以实现续写。
         *
         * 需求：想要将数据分行写入。
         *
         * window中的特有软件比如notepad。只识别window中的特有换行 \r\n.
         * 为了在不同系统平台下换行。使用System类获取当前系统信息。
         *
         *
         */
        //该构造方式，通过第二个参数来决定是否进行续写
        FileWriter fw = new FileWriter("demo2.txt",true);
        fw.write("xi"+LINE_SPARATOR+"xi");
        fw.close();
    }
}

 

上述示例主要提示我们一下几点：

1.    如果想在原来的文本后，在继续添加文字，该怎么办？这时，可以使用FileWriter的另外一个构造方法，传入加入一个boolean参数，为true，就可以实现续写。

2.    其次，就是，当数据需要分行写入时，为了让程序在不同的系统平台上都可以运行，不能讲换行的符号写死，可以动态的获取系统的属性来取到当前系统中的换行符：

private static final String LINE_SPARATOR =      System.getProperty("line.separator");

3.    无论如何都不能忘记：流不再使用的时候，必须得关闭。

 

 

在对IO系列中的FileWriter对象有了大概的了解后，我们会发现，在程序中的很多地方都会发生异常：繁多而又不同的异常。因此，我们有必要来介绍一下，Java中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("关闭失败");
                }
        }
    }
}

 

通过以上示例，我们的明白，在Java中IO异常的处理时：

1.    对象的创建方式——创建流对象时， 在try外创建流对象的引用。 在try内对流对象进行初始化。

2.    在finally的代码中，流的关闭时必须得执行的动作。但是，在关闭前，必须得判断，这个流是否创建成功，如果没有创建成功的话，何谈关闭。

3.    在处理流关闭失败后，可以进行一系列的操作：或者将关闭失败的信息记录到日志文件中。

 

————————————————————————————

 

下面我们来讲解：另一个重要的对象——FileReader。

 FileReader: 这个对象的主要用途在于读取，因此，我们将着重分析，它对指定文件的读取方式，FileReader 读取字符时有两种方式：

1. 读取单个字符的方法：读取单个字符。在字符可用、发生 I/O 错误或者已到达流的末尾前，此方法一直阻塞。返回值：作为整数读取的字符，范围在 0 到 65535 之间 (0x00-0xffff)，如果已到达流的末尾，则返回 -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);
        }
    }
}

 

上述两种读取方式，最明前的区别在于：

   第二种读取字符的方式，要比第一种方式高效。

 

 

到目前为止，我们已经学了FileReader， FileWrite的具体使用，以及IO异常的处理方式，下面将通过一个具体的示例，来综合的应用上述所学的知识：

我们将完成一个：文件复制的练习。并且使用两种读取字符方式来完成。该例子中用的路径，假设在你的机器中也存在。

 

 

题目：

   

        * 练习：将c盘的一个文本文件复制到d盘。

        * 思路：

        * 1，c盘的文件是一个数据的源。

        * 复制到的d盘，说明d盘是数据的存储的目的。该目的中应该有一个文件。

        * 2，先读取c盘的文件。将读取到的数据写入到目的地中。

        *3，既然是操作文本文件，只要使用字符流即可。

 

 

1.用缓冲区数组，来完成读写操作；

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyTextTest1 {


    public static void main(String[] args) {

        /*
         *
         * 使用缓冲区数组。
         * 使用的就是可以操作数组的读写方法。
         */
        //1，定义字符输入流和字符输出流的引用。
        FileReader fr = null;
        FileWriter fw = null;

        try {
            //2，对流对象进行初始化。
            fr = new FileReader("demo.txt");
            fw = new FileWriter("copy_demo2.txt");

            //3，定义一个数组缓冲区。用于缓冲读取到的数据。
            char[] buf = new char[1024];

            //4，读写操作。
            int len = 0;
            while((len = fr.read(buf))!=-1){
                fw.write(buf,0,len);
            }

        } catch (Exception e) {
            System.out.println(e.toString());
        }finally{

            if(fw!=null)
                try {
                    fw.close();
                } catch (IOException e) {

                    throw new RuntimeException("写入关闭失败");
                }

            if(fr!=null)
                try {
                    fr.close();
                } catch (IOException e) {

                    e.printStackTrace();
                }
        }
    }
}

2. 用读取单个字符的方式来完成。

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyTextTest {

    /**
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {



        //1，创建字符读取流对象和源相关联。
        FileReader fr = new FileReader("IO流.txt");

        //2，创建字符输出流对象，明确要存储数据的目的。
        FileWriter fw = new FileWriter("copy_demo.txt");

        //3，进行读写操作。读取一个，就写入一个。
        int ch = 0;
        while((ch=fr.read())!=-1){
            fw.write(ch);
        }
        //4，关闭资源。
        fw.close();
        fr.close();

    }

}

 

缓冲区高效的原因：

流对象的read():是从目的地一次读取一个；

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

 

 

就在刚才，我们用的高效读取方式，是将字符全部读取到数组中，来达到高效的目的,在Java中，为了提高程序的性能，为我们专门提供了对应的类：

BufferedReader　 和BufferedWriter . 接下来，我们将开始学习，这两个对象。

——————————————————————————————————

 

【BufferedReader 】 

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。(他的构造方法有两个，一个构造方法使用的是默认大小的缓冲区，另一个构造方法，可以设定自己的缓冲区大小)。

他的牛逼之处在于，提供了一个一次读取一行的方法：

readline() ——读取一个文本行。通过下列字符之一即可认为某行已终止：换行 ('\n')、回车 ('\r') 或回车后直接跟着换行。返回值：包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null。

下面来具体应用：

 

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

 

在上述示例中我们应当注意的是：

1.      BufferedReader的简写形式。

BufferedReader bufr = newBufferedReader(new FileReader("Demo.txt"));

 

2. 【readLine().一次读一行的原理】

  从缓冲区中取出字符存储到该方法的容器中。当取出的字符是回车符时，就将已经存储的数据作为字符串返回。就是一行数据。

   ReadLine()  调用buf.read()将缓冲区中的数据存储到，自己建立的容器中。ReadLine()建立自己的容器—— StringBuilder 最合适。

 

 

下面我们来学习，BufferedWriter，作为与BufferedReader配套出现的亲兄弟，他的作用，当然显而易见。

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()?不用，因为关闭缓冲区，其实就是在关闭缓冲区关联的流。

    }
}

在上述示例中，我们应当注意：

1.      写入一个新行的方法：newline();

2.      每写一次，就要讲缓冲区刷新一次。

3.      在使用完后，关闭缓冲区即可，不需要在关闭流。因为流已经与缓冲区相关联了。

 

 

至此：我们已经学习了IO体系中的四个对象：

 

FileReader  FileWriter  BufferedReader BufferedWriter