package com.kale.io;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

/**

 * @author:Jack Tony

 * @date  :2014-10-12

 */

public class IOTest {

    public static void main(String[] args) {

        //String str = byteRead();

        //byteWrite(str);

        //String readStr = fileReader();

        //fileWriter(readStr);

        //readerWriter();

        //bufferedReader();

    }

    /**

     * 字节流写入

     * @param result

     */

    public static void byteWrite(String result) {

        FileOutputStream fos = null;

        try {

            //将字符串写入到硬盘的一个文件中，这里请确保文件存在

            File file = new File("d:/to.txt");

            if(!file.exists()) {

                file.createNewFile();

            }

            //通过文件来建立流

            fos = new FileOutputStream(file);

            //将字符串转换为byte数组，一次性写入

            fos.write(result.getBytes());

        } catch (FileNotFoundException e) {

            // TODO 自动生成的 catch 块

            e.printStackTrace();

        } catch (IOException e) {

            // TODO 自动生成的 catch 块

            e.printStackTrace();

        }

        finally {

            try {

                fos.flush();

                fos.close();

            } catch (IOException e) {

                // TODO 自动生成的 catch 块

                e.printStackTrace();

            }

        }

    }

    /**

     * 字节流读出

     * @return

     */

    public static String byteRead() {

        FileInputStream fis = null;

        //存放读取结果的String对象

        String result = "";

        try {

            //通过文件来建立一个流，文件不存在则出现异常

            fis = new FileInputStream(new File("d:/from.txt"));

            //fis读取必须要用到byte[]，所以要建立一个byte来存放字节流。这样就可以从文件中一点点读取了

            byte []buffer = new byte[1024*3];

            //每次读取字节的实际数目

            int n = 0;

            //每次读取一个buffer长度，存到buffer中，直到没有读取到字节

            while((n = fis.read(buffer, 0, buffer.length)) > 0) {

                result += new String(buffer,0,n);

            }

            System.out.println("【"+result.trim()+"】");

        } catch (FileNotFoundException e) {

            // TODO 自动生成的 catch 块

            e.printStackTrace();

        } catch (IOException e) {

            // TODO 自动生成的 catch 块

            e.printStackTrace();

        }

        finally {

            try {

                fis.close();

            } catch (IOException e) {

                // TODO 自动生成的 catch 块

                e.printStackTrace();

            }

        }

        return result;

    }

    /**

     * 通过fileReader来进行读取字符流

     * @return

     */

    public static String fileReader() {

        String result = "";

        FileReader fr = null;

        try {

            fr = new FileReader(new File("d:/reader.txt"));

            //通过这个数组来做缓冲区，一点一点的读入到程序中

            char []c = new char[2];

            //实际读取的字符个数

            int n = 0;

            //循环读取，直到文件的末尾

            while((n = fr.read(c)) != -1) {

                result += new String(c,0,n);

            }

            System.out.println("【"+result+"】");

        } catch (FileNotFoundException e) {

            // TODO 自动生成的 catch 块

            e.printStackTrace();

        } catch (IOException e) {

            // TODO 自动生成的 catch 块

            e.printStackTrace();

        }

        finally {

            try {

                fr.close();

            } catch (IOException e) {

                // TODO 自动生成的 catch 块

                e.printStackTrace();

            }

        }

        return result;

    }

    /**

     * 将字符流写入到文件中

     * @param str

     */

    public static void fileWriter(String str) {

        FileWriter fw = null;

        try {

            fw = new FileWriter(new File("d:/writer.txt"));

            //将字符串一次性的写入到文件中

            fw.write(str);

        } catch (IOException e) {

            // TODO 自动生成的 catch 块

            e.printStackTrace();

        }

        finally {

            try {

                fw.flush();

                fw.close();

            } catch (IOException e) {

                // TODO 自动生成的 catch 块

                e.printStackTrace();

            }

        }

    }

    /**

     * 一点一点读，并且将读出来的东西写入到另一个文件中

     */

    public static void readerWriter() {

        FileReader fr = null;

        FileWriter fw = null;

        try {

            fr = new FileReader(new File("d:/reader.txt"));

            //第二个参数为true时，表示追加写入

            fw = new FileWriter(new File("d:/writer.txt"),true);

            //建立缓冲区

            char []c = new char[2];

            //实际读取的字符的个数

            int n = 0;

            //一点一点读出字符，放到char数组中，直到末尾

            while((n = fr.read(c)) != -1) {

                //将char数组中的字符写入文件中

                fw.write(c, 0, n);

            }

            System.out.println("写入成功！");

        } catch (FileNotFoundException e) {

            // TODO 自动生成的 catch 块

            e.printStackTrace();

        } catch (IOException e) {

            // TODO 自动生成的 catch 块

            e.printStackTrace();

        }

        finally {

            try {

                fw.flush();

                fw.close();

                fr.close();

            } catch (IOException e) {

                // TODO 自动生成的 catch 块

                e.printStackTrace();

            }

        }

    }

    /**

     * 通过BufferedReader来一行一行读取

     * @return 如果正常则返回字符串，如果出错返回null

     */

    public static String bufferedReader() {

        String result = null;

        FileReader fr = null;

        BufferedReader br = null;

        try {

            fr = new FileReader("d:/reader.txt");

            //将File进行包装，可以一行一行的读取了

            br = new BufferedReader(fr);

            String line = null;//定义读取一行字符后存储的String对象

            //用这个来暂时存放string对象

            StringBuilder sb = new StringBuilder("");

            //一行一行读取，读取的东西每次存放到line中

            while((line = br.readLine()) != null){

                //result += line;

                sb.append(line);//将读取的每一行补到StringBuilder后面

            }

            result = sb.toString().trim();

            System.out.println("【"+result+"】");

        } catch (FileNotFoundException e) {

            // TODO 自动生成的 catch 块

            e.printStackTrace();

        } catch (IOException e) {

            // TODO 自动生成的 catch 块

            e.printStackTrace();

        }

        finally {

            try {

                br.close();

                fr.close();

            } catch (IOException e) {

                // TODO 自动生成的 catch 块

                e.printStackTrace();

            }

        }

        return result;

    }

}