java基础知识回顾之javaIO类---FileWriter和FileReader

FileWriter类的构造方法定义如下：

1.public FileWriter(File file)throws IOException

字符流的操作比字节流操作好在一点，就是可以直接输出字符串了，不用再像之前那样进行转换操作了。

package com.lp.ecjtu;

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

public class FileWriterDemo {

    /**
     * 字符流，创建一个FileWriter对象，该对象一被初始化，就必须明确操作的文件，将
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        //而且该文件被创建到指定目录下，如果该目录下面已经有同名的文件，将被覆盖
        FileWriter fw = new FileWriter("Demo.txt");
        //调用write方法，将字符串写入到流当中去，也就是缓冲区中
        fw.write("abcefg");
        //刷新流对象中的缓冲中的数据
        //将数据刷到指定的文件当中去
        fw.flush();
        //fw.close();//如果用close，则流关闭，后面的写入流将不会被执行
        fw.write("3423");
        fw.flush();
    }

}

输出结果：

在Demo.txt文件中写入了：abcefg3423

2.public FileWriter(File file,boolean append)throws IOException 用FileWriter的另一种构造方法，传递一个true参数，代表不覆盖已有的文件。并在已有文件进行续写

package com.lp.ecjtu;

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

/**
 * 对已有文件的续写
 * @author Administrator
 *
 */
public class FileWriterDemoApend {

    /**
     * 创建一个FileWriter对象，该对象一被初始化，就必须明确操作的文件
     * @param args
     * @throws IOException
     * @throws IOException
     */
    public static void main(String[] args){
        FileWriter fw = null;
        try{
            //用FileWriter的另一种构造方法，传递一个true参数，代表不覆盖已有的文件。并在已有文件进行续写
            fw = new FileWriter("Demo.txt",true);
            //调用write方法，将字符串写入到流当中去，也就是缓冲区中
            fw.write("234334\r\n谢谢");

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

输出结果：在文件中续写字符串：

结果变为

abcefg3423234334

谢谢

FileReader的构造方法定义如下：

public FileReader(File file)throws FileNotFoundException

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

 

例子：一个字符一个字符读取文件：

package com.lp.ecjtu;

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

public class FileReaderDemo {

    /**
     * 怎样去捕获IO异常，标准的捕获异常方式
     * 下面的1,2,3都会抛出异常，可能发生的异常有下面三个：
     * 1.java.io.FileNotFoundException //关联的文件不存在
     * 2.java.lang.NullPointerException //FileReader可能没有new
     * 3.IOException //操作IO流的时候抛出的异常
     */
    public static void main(String[] args) {
        //创建一个文件读取流对象，和指定的名称的文件相关联
        //要保证该文件是已经存在的，如果不存在，会发生FileNotFoundException
        FileReader fr = null;
        try {
                fr = new FileReader("Demo.txt");

             //一次读取一个字符，而且会自动往下读
            /* int char1 = fr.read();
            System.out.println("char1="+(char)char1);//char1=a
            int char2 = fr.read();
            System.out.println("char2="+(char)char2);//char2=b
            int char3 = fr.read();
            System.out.println("char3="+(char)char3);//char3=c
            int char4 = fr.read();
            System.out.println("char4="+(char)char4);//char4=e
            int char5 = fr.read();
            System.out.println("char5="+(char)char5);
            int char6 = fr.read();
            System.out.println("char6="+(char)char6);
            int char7 = fr.read();
            System.out.println("char7="+char7);*/
            //如果达到流的末尾，则返回-1，-1为数据的分割符
            int ch = 0;
            while((ch=fr.read())!= -1){
                System.out.print((char)ch);
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            if(fr != null){
                try {
                    fr.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }

        }
    }

}

输出结果：

abcefg3423234334
谢谢

以字符数组的形式读取：

使用：

public int read(char[] cbuf)
         throws IOException

package com.lp.ecjtu;

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

public class FileReaderDemo2 {

    /**
     * @param args
     */
    public static void main(String[] args) throws IOException{
        //创建一个文件读取流对象，和指定的名称的文件相关联
        //要保证该文件是已经存在的，如果不存在，会发生FileNotFoundException
        FileReader fr = new FileReader("Demo2.txt");

        //定义一个字符数组，用于存储读到的字符
        //char[] ch = new char[1024];
        //返回读到的字符个数
        //每次读3字符个放到字符数组缓冲区当中，一次性存储3个放到数组当中，然后在一次性读取出来
        char[] ch = new char[3];
        int num = fr.read(ch);
        System.out.println("num="+num+"----"+new String(ch));
        int num1 = fr.read(ch);
        System.out.println("num1="+num1+"----"+new String(ch));
        int num2 = fr.read(ch);
        System.out.println("num2="+num2+"----"+new String(ch));
        int num3 = fr.read(ch);
        System.out.println("num3="+num3+"----"+new String(ch));

        int nu = 0;
        while((nu=fr.read(ch)) !=-1){
            System.out.println(new String(ch,0,nu));
        }

        fr.close();
    }

}

输出：demo2中存储的字符为：abcdefg

num=3----abc
num1=3----def
num2=1----gef
num3=-1----gef

以字符数组的的形式循环读取java文件

package com.lp.ecjtu;

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

public class FileReaderJava {

    /**
     * @param args
     * 读取一个java文件，并且打印到控制台上
     */
    public static void main(String[] args) throws IOException{
        //创建一个文件读取流对象，和指定的名称的文件相关联
        //要保证该文件是已经存在的，如果不存在，会发生FileNotFoundException
        FileReader fr = new FileReader("FileReaderDemo.java");

        //定义一个字符数组，用于存储读到的字符
        char[] ch = new char[1024];
        //返回读到的字符个数
        int num= 0;
        while((num=fr.read(ch)) !=-1){
            System.out.print(new String(ch,0,num));
        }

        fr.close();
    }

}

文件的复制：将一个盘的文件复制到另一个盘：

package com.lp.ecjtu;

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

public class CopyTest {

    /**将C盘一个文本文件复制到D盘
     * @param args
     * 原理：其实就是将C盘下的文件数据存储到D盘的文件当中
     * 步骤：
     * 1.在D盘创建一个文件，用于存储C盘文件的数据
     * 2.定义读取流和C盘文件相关联
     * 3.通过不断的读写完成数据的存储
     * 4.关闭资源
     * @throws IOException
     */

    public static void copy1() throws IOException{
        //创建要写出到哪个文件，也就是目的地：为硬盘文件
        FileWriter fw = new FileWriter("testjava.txt");
        //与要拷贝的文件关联，也就是读取要拷贝的文件 源：为硬盘文件
        FileReader fr = new FileReader("FileReaderDemo.java");
        int ch=0;
        //从c盘  读一个，就往D盘复制一个
        while((ch = fr.read())!= -1){
            fw.write(ch);
        }
        fw.close();
        fr.close();
    }
    /**
     * 写入数组缓存中，一次读出，一次性写入
     * @param args
     * @throws IOException
     */
    public static void copy2(){
        FileWriter fw = null;
        FileReader fr = null;

        try {
            fw = new FileWriter("test2.txt");
            fr = new FileReader("FileReaderDemo.java");
            char[] buf = new char[1024];
            int len = 0;//表示buf数组的长度
            while((len = fr.read(buf))!=-1){
                fw.write(buf,0,len);
                System.out.println(buf);
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                if(fw != null){
                    fw.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            try {
                if(fr != null){
                    fr.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }
    public static void main(String[] args) throws IOException {
        copy1();
        copy2();
    }

}

总结：copy1的效率低于copy2，因为copy2一次性把数组复制到数组缓冲区，然后在写入流中。