Java之IO操作-读写文件

字节流

最原始，能用字符流不用字节流。

//读文件
private static void read() {
   FileInputStream fis = null;
   try {
       fis = new FileInputStream("data/wc.data");
       //TODO...
       byte[] buffer = new byte[1024];
       int length = 0;
       while ((length = fis.read(buffer, 0, buffer.length)) != -1) {
           String result = new String(buffer, 0, length);
           System.out.println(result);
       }
   } catch (Exception e) {
       e.printStackTrace();
   } finally {
       try {
           if (null != fis) {
               fis.close();
           }
       } catch (IOException e) {
           e.printStackTrace();
       }
   }
}

//写文件
private static void write() {
    FileInputStream fis = null;
    FileOutputStream fos = null;

    try {
        fis = new FileInputStream("data/wc.data");
        fos = new FileOutputStream("out/wc-out.data");
        //todo...
        byte[] buffer = new byte[1024];
        int length = 0;
        while ((length = fis.read(buffer, 0, buffer.length)) != -1) {
            fos.write(buffer, 0, length);
            fos.flush();
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        if (null != fos) {
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (null != fis) {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字符流

比于字节流简单，但过程也很复杂。

//读文件
private static void read() {
    FileReader reader = null;
    try {
        reader = new FileReader("data/wc.data");
        char[] buffer = new char[1024];
        int length = 0;
        while ((length = reader.read(buffer, 0, buffer.length)) != -1) {
            String result = new String(buffer, 0, length);
            System.out.println(result);
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (null != reader) {
                reader.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

//写文件
private static void write() {
    FileWriter writer = null;
    try {
        writer = new FileWriter("out/wc-out2.data", true);
        writer.write("若泽数据2。。。\n");
        writer.flush();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (null != writer) {
                writer.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

装饰类

利用装饰类将字节流转化为字符流，并引入buffer机制，不再对字节或字符进行操作，而是一行一行的，提高了读写效率。

//读文件
private static void read() {
    //字节流 --> 字符流
    BufferedReader bufferedReader = null;
    try {
        bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream("data/wc.data")));
        String message = null;
        while((message = bufferedReader.readLine())!= null){
            System.out.println(message);
        }

    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (null != bufferedReader) {
                bufferedReader.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
//写文件
private static void write() {
    BufferedWriter bufferedWriter = null;
    try {
        bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("out/wc-out3.data")));
        bufferedWriter.write("ruozedata...");
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (null != bufferedWriter) {
                bufferedWriter.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

实际生产上，以上方案都不是最优的，还有效率更高的方式 ------ NIO。