Java中IO的简单举例

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

}