java IO，bufferedReader/bufferedWriter对文件的读写

好记性不如赖笔头…………

package com.Ckinghan.ioDemo;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class BuferedIo {

    /**
     * 
     * @描述：高速缓冲流BufferedWrieter/BuffereReader读写数据
     * @创建时间：
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        /**
         * 高速缓冲流的文件写入,提供了一个换行 的方法newLine()
         */
        writerFile();


        /**
         * 高效缓冲流读取数据文件，每次读取一个字符
         */
        readerBuffere();

        /**
         * 高效缓冲流读取数据文件，每次读取一个字符
         */
        readerBuffereChar();

        /**
         * 高效缓冲流读取数据文件，每次读取一行
         */
        readerBuffereReadLine();
    }



    /**
     * @描述：高效缓冲流读取数据文件，每次读取一行
     * @创建时间：
     */
    public static void readerBuffereReadLine(){
        //创建fileReader对象
        FileReader fileReader = null;
        //创建高效缓冲流对象
        BufferedReader bufferedReader = null;

        try {
            //实例化fileReader/bufferedReader对象
            fileReader = new FileReader("bufferedWriter.java");
            bufferedReader = new BufferedReader(fileReader);
            //定义存储每次读取的字符数据
            String string = null;
            //接收字符并判断接收的字符acsii是否为-1，如果为-1说明数据已经读取完毕
            while((string = bufferedReader.readLine()) != null){
                //输出字符
                System.out.println(string);
            }
//          System.out.println();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }catch (IOException e) {
            e.printStackTrace();
        }finally {
            //如果高效缓冲流不等于空
            if(bufferedReader != null){
                try {
                    //关闭缓冲流，会自动关闭fileReader对象
                    bufferedReader.close();
                } catch (IOException e2) {
                    e2.printStackTrace();
                }
            }
        }       
    } 




    /**
     * @描述：高效缓冲流读取数据文件，每次读取指定数量的字符
     * @创建时间：
     */
    public static void readerBuffereChar(){
        //创建fileReader对象
        FileReader fileReader = null;
        //创建高效缓冲流对象
        BufferedReader bufferedReader = null;

        try {
            //实例化fileReader/bufferedReader对象
            fileReader = new FileReader("bufferedWriter.java");
            bufferedReader = new BufferedReader(fileReader);
            //定义每次读取的字符数量
            int val = -1;
            //定义每次读取的字符个数
            char[] chs = new char[1024];
            //接收字符并判断接收的字符acsii是否为-1，如果为-1说明数据已经读取完毕
            while((val = bufferedReader.read(chs)) != -1){
                //输出字符
                System.out.print(new String(chs,0,val));
            }
            System.out.println();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }catch (IOException e) {
            e.printStackTrace();
        }finally {
            //如果高效缓冲流不等于空
            if(bufferedReader != null){
                try {
                    //关闭缓冲流，会自动关闭fileReader对象
                    bufferedReader.close();
                } catch (IOException e2) {
                    e2.printStackTrace();
                }
            }
        }       
    } 


    /**
     * @描述：高效缓冲流读取数据文件，每次读取一个字符
     * @创建时间：
     */
    public static void readerBuffere(){
        //创建fileReader对象
        FileReader fileReader = null;
        //创建高效缓冲流对象
        BufferedReader bufferedReader = null;

        try {
            //实例化fileReader/bufferedReader对象
            fileReader = new FileReader("bufferedWriter.java");
            bufferedReader = new BufferedReader(fileReader);
            //定义读取的字符接收对象
            int val = -1;
            //接收字符并判断接收的字符acsii是否为-1，如果为-1说明数据已经读取完毕
            while((val = bufferedReader.read()) != -1){
                //输出字符
                System.out.print((char)val);
            }
            System.out.println();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }catch (IOException e) {
            e.printStackTrace();
        }finally {
            //如果高效缓冲流不等于空
            if(bufferedReader != null){
                try {
                    //关闭缓冲流，会自动关闭fileReader对象
                    bufferedReader.close();
                } catch (IOException e2) {
                    e2.printStackTrace();
                }
            }
        }       
    } 

    /**
     * @描述：高速缓冲流的文件写入
     * @创建时间：
     */
    public static void writerFile(){
        FileWriter fileWriter = null;
        BufferedWriter bufferedWriter = null;
        try {
            fileWriter = new FileWriter("bufferedWriter.java");
            bufferedWriter = new BufferedWriter(fileWriter);
            for(int i = 0; i< 10; i++){
                bufferedWriter.write("bufferedWriter高速缓存流的文件写入");
                //高速缓冲流 BufferedWriter提供了一个换行的方法
                bufferedWriter.newLine();
            }
            bufferedWriter.flush();
            System.out.println("文件写入成功");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(bufferedWriter != null){
                try {
                    //在关闭bufferedWriter时，会自动关闭fileWriter,所以不用再重写方法关闭了
                    bufferedWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

}