Java:IO流之字符流Reader、Writer详解

java.io包中：字符流

字符流的两个抽象基类：

Reader         Writer

文件的读取：Reader抽象类(java.io包中)

直接子类的构造方法：

FileReader(File file)

在给定从中读取数据的 File 的情况下创建一个新 FileReader。

FileReader(FileDescriptor fd)

在给定从中读取数据的 FileDescriptor 的情况下创建一个新 FileReader。

FileReader(String fileName)

在给定从中读取数据的文件名的情况下创建一个新 FileReader。

int read()读取单个字符

注意：作为整数读取的字符，范围在0到65535之间(0x00-0xffff),如果已到达流的末尾，则返回 -1

int read(char[] cbuf)  将字符读入数组。

注意：读取的字符数，如果已到达流的末尾，则返回 -1

//例子1：使用read()读取单个字符并输出

import java.io.*;
class FileReaderDemo
{
    public static void sop(Object obj)
    {
        System.out.print(obj);
    }
    public static void main(String[] args)throws IOException
    {
      //创建一个文件读取流对象，和指定名称的文件相关联起来。
      //要保证该文件是已经存在的。如果不存在，会发生异常，即FileNotFoundException
      FileReader fr = new FileReader("F:\\myfile\\test.txt");

      //调用读取流对象的read方法。
      //read方法：一次读取一次字符，而且会自动往后面读取字符。
      int ch = 0;
      while((ch=fr.read())!=-1)
      {
          sop((char)ch);
      }

     /*
     while(true)
      {
        int ch = fr.read();
        if(ch==-1)
            break;
         sop((char)ch);  //读取文件中的一个字符
      }
    */
      fr.close();
    }
}

//例子2：使用read(char[] cbuf)  将字符读入数组再输出

import java.io.*;
class FileReaderDemo2
{
    public static void sop(Object obj)
    {
        System.out.print(obj);
    }
    public static void main(String[] args)throws IOException
    {
      //创建一个文件读取流对象，和指定名称的文件相关联起来。
      //要保证该文件是已经存在的。如果不存在，会发生异常，即FileNotFoundException
      FileReader fr = new FileReader("F:\\myfile\\test.txt");

      //定义一个字符数组，用于存储读取的字符
      char[] buf = new char[1024];
      int num = 0;
      while((num = fr.read(buf))!=-1)//num = fr.read(buf)返回是读取的字符个数,如果已到达流的末尾,则返回 -1
      {
        //String(char[] value, int offset, int count) 分配一个新的 String，它包含取自字符数组参数一个子数组的字符。
        String str = new String(buf,0,num);
        sop(str);
      }

      fr.close();
    }

}

那么再学习字符写入流的特点：Writer 抽象类(java.io包中)

FileWriter(File file)   根据给定的 File 对象构造一个 FileWriter 对象。

既然IO流是用于操作数据的，那么数据的最常见体现形式是：文件

那么先以操作文件为主来显示。

需求：在硬盘上，创建一个文件夹并写入一些文字数据。后缀名是父类名，前缀名是该流对象的功能。

找到一个专门用于操作文件的Writer子类对象。

public abstract void close()

throws IOException关闭此流，但要先刷新它。在关闭该流之后，再调用 write() 或 flush() 将导致抛出 IOException。

关闭以前关闭的流无效。

abstract  void flush()

刷新该流的缓冲。

//例子3：

import java.io.*;
class FileWriterDemo
{
    public static void main(String[] args) throws IOException
    {
        //第一步：
        //创建一个FileWriter对象，该对象一被初始化就必须有明确的被操作的文件，而且该文件会被创建到指定的目录下
        //如果该目录下已有同名文件，将会被覆盖。其实该步就是要明确数据要存放的目的地。
        FileWriter fw = new FileWriter("F:\\myfile\\demo.txt");

        //第二步：
        //调用父类共性方法write方法，将数据写入到了流当中。
        fw.write("asjdsjdfkskidkf,fdhjsdkjfdsk,dfhjdskj");

        //第三步：
        //调用父类共性方法flush方法,刷新流对象中的缓冲中的数据，将数据刷新到目的地中。
        fw.flush();

        //可以接着往目的地中写入数据
        fw.write("xiayuanquan");
        fw.flush();

        //父类中的共性方法close方法,关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据，将数据刷新到目的地中去。
        //和flush的区别：flush刷新后，流可以继续使用；而close刷新后，流会关闭，无法继续使用。
        fw.write(" aaaaaaaaaaaaaa");
        fw.close(); //Stream closed
        //fw.write("xxxx"); //流已关闭，此时不能再向目的地的文件中写入数据

    }
}

使用字符流读取和写入数据时，可能会出现流异常的情况，例如文件不存在、路径错误等，此时，需要我们对异常进行捕获并处理。

//例子4：

import java.io.*;
class FileWriterExceptionDemo
{
    public static void main(String[] args)
    {
        FileWriter fw = null;
        try
        {
            fw = new FileWriter("F:\\myfile\\Exception.txt");//创建目标文件

            fw.write("my name is xiayuanquan!"); //往流里写入数据内容
        }
        catch(IOException ie)
        {
            System.out.println(ie.toString());
        }
        finally
        {
            try
            {
              if(fw!=null)
                fw.close(); //先刷新流，将流中的数据内容刷到目标文件中，然后关闭流资源
            }
            catch(IOException ie)
            {
            System.out.println(ie.toString());
            }
        }
    }
}

拓展：当用户想把数据写入同一个文件，可是文件中已经存在内容时，那么新写入的数据会替换之前的数据。此时，这不是用户所希望的，针对这种情况，我们可以将新写入的内容在文件内容后面续写即可。api中就提供了一个方法如下：

对已有文件数据内容的续写：

FileWriter(File file, boolean append)

根据给定的 File 对象构造一个 FileWriter 对象。

//例子5：

import java.io.*;
class FileWriterDemoappend
{
    public static void main(String[] args)
    {
        FileWriter fw = null;
        try
        {
            //传递一个ture参数，代表不覆盖已有的文件。并在已有文件的末尾处进行文件的续写。
            fw = new FileWriter("F:\\myfile\\demo.txt",true);
            fw.write(",,,wei-zhong-hua-jue-qi-er-du-shu");
            fw.write("\r\nabc=abc");//‘\r\n‘代表换行，然后接着续写数据
        }
        catch(IOException e)
        {
            System.out.println(e.toString());
        }
        finally
        {
            try
            {
                if(fw!=null)
                    fw.close();
            }
            catch(IOException e)
            {
            System.out.println(e.toString());
            }
        }
    }
}

综合练习：将相同目录下一个文本文件赋值到另一个文本文件中。

（例如:将F:\\myfile\\practice.txt--------->F:\\myfile\\test.txt）

思路：第一步，创建读取流与F:\\myfile\\practice.txt相关联。

第二步，将F:\\myfile\\practice.txt中数据内容全部读入流中，并放在定义的数组内,然后关闭资源。

第三部，创建写入流与F:\\myfile\\test.txt相关联，并设置续写功能的布尔值为true；

第四部，将第二部定义的数组的数据内容全部写入F:\\myfile\\test.txt文件中，然后关闭资源。

//例子6：

import java.io.*;
class CopyText
{
    public static void main(String[] args)throws IOException
    {
          FileReader fr = new FileReader("F:\\myfile\\practice.txt");
        FileWriter fw = new FileWriter("F:\\myfile\\test.txt",true);

        //第一种方式:(先全部读完数据后存入缓冲区，再一次性续写入目标文件中)
        int num=0;
        char[] buf = new char[1024];
        while((num = fr.read(buf))!=-1)
        {
            String str = new String(buf,0,num);
            fw.write("\r\n"+str);
                // fw.write(buf,0,num);
            fw.close();
        }
        fr.close();

        /*
        //第二种方式:(每次读一个数据，就往目标文件中写入一个数据)
        int num = 0;
        while((num = fr.read())!=-1)
        {
            fw.write(num);
        }
        fw.write("\r\n");
        fw.close();
        fr.close();
        */
    }
}