【java开发系列】—— java输入输出流

前言

　　任何语言输入输出流都是很重要的部分，比如从一个文件读入内容，进行分析，或者输出到另一个文件等等，都需要文件流的操作。这里简单介绍下reader,wirter,inputstream,outputstream的使用方法。其实Apache commons里面有个方法IOUtils可是实现方便快捷的流拷贝，感兴趣的可以参考官方文档。

　　JAVA的输入输出流有两种，一种是字节流（InPutStream,OutPutStream），一种是字符流(Reader,Writer)。

　　字节流是普遍适用的，比如我们读取一个视频，音乐，或者文本都可以用这种方式。

　　字符流只能读取类似文本这种文件。那么它们之间是什么关系呢？看下面这张图吧！

　　大致可以看到它们之间的关系，我们可以使用InPutStreamReader来实现字节流到字符流的转换。比如

Reader reader = new InputStreamReader(new FileInputStream(fileName));

　　也可以使用OutPutStreamWriter来实现字节流到字符流的转换，如

Writer writer = new OutputStreamWriter(new FileOutputStream(filePathName));

　　下面简单介绍下，文件读取和文件写入的样例！

　　按行读取文件！

 /**
      * 以行为单位读取文件，常用于读面向行的格式化文件
      *
      * @paramfileName:文件名
      */
     public static List<String> readFileByLines(String fileName) {
         List<String> list = new ArrayList<String>();
         if (fileName != null && !"".equals(fileName)) {
             File file = new File(fileName);
             BufferedReader reader = null;
             try {
                 System.out.println("以行为单位读取文件内容，一次读一整行：");
                 reader = new BufferedReader(new FileReader(file));
                 String tempString = null;
                 /* 一次读入一行，直到读入null为文件结束 */
                 while ((tempString = reader.readLine()) != null) {
                     System.out.println(tempString);
                     list.add(tempString);
                 }
             } catch (IOException e) {
                 System.out.println("读取文本文件异常" + e);
             } finally {
                 if (reader != null) {
                     try {
                         reader.close();
                     } catch (IOException e1) {
                         System.out.println("读取文本文件异常" + e1);
                     }
                 }
             }
         }
         return list;
     }

　　向文件中写入内容，直接覆盖掉原来的内容。

 /**
      * 把内容写到文件
      *
      * @paramfilePathName文件名
      * @paramList<String>文件内容
      */
     public static boolean writerFile(String filePathName, String content) {
         boolean flag = false;
         OutputStreamWriter osw = null;
         try {
             if (filePathName != null && !"".equals(filePathName)) {
                 osw = new OutputStreamWriter(new FileOutputStream(filePathName));
             }
         } catch (FileNotFoundException e1) {
             flag = false;
             e1.printStackTrace();
         }
         if (osw != null) {
             BufferedWriter bw = new BufferedWriter(osw);
             try {
                 if (content != null && !"".equals(content)) {
                     bw.write(content);
                     flag = true;
                 }
             } catch (IOException e) {
                 flag = false;
                 e.printStackTrace();
             } finally {
                 try {
                     bw.close();
                     osw.close();
                 } catch (IOException e) {
                     flag = false;
                     e.printStackTrace();
                 }
             }
         }
         return flag;
     }

　　向文件中追加内容，追加到末尾。

 /**
      * 把内容写到文件或追加到文件中
      *
      * @paramfilePathName文件名
      * @paramList<String>文件内容
      */
     public static boolean writerFileIsAppend(String filePathName, String content) {
         boolean flag = false;
         OutputStreamWriter osw = null;
         try {
             if (filePathName != null && !"".equals(filePathName)) {
                 osw = new OutputStreamWriter(new FileOutputStream(filePathName,
                         true));
             }
         } catch (Exception e1) {
             flag = false;
             e1.printStackTrace();
         }
         if (osw != null) {
             BufferedWriter bw = new BufferedWriter(osw);
             try {
                 if (content != null && !"".equals(content)) {
                     bw.write(content);
                     flag = true;
                 }
             } catch (IOException e) {
                 flag = false;
                 e.printStackTrace();
             } finally {
                 try {
                     bw.close();
                     osw.close();
                 } catch (IOException e) {
                     flag = false;
                     e.printStackTrace();
                 }
             }
         }
         return flag;
     }

　　全部代码

　　

 package testIO;

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.FileReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
 import java.io.Reader;
 import java.util.ArrayList;
 import java.util.List;

 public class testIO {
     public static void main(String[] args) {
         readFileByBytes("C:\\Users\\Administrator\\Desktop\\新建文本文档.txt");
         readFileByChars("C:\\Users\\Administrator\\Desktop\\新建文本文档.txt");
         readFileByLines("C:\\Users\\Administrator\\Desktop\\新建文本文档.txt");
         writerFile("C:\\Users\\Administrator\\Desktop\\新建文本文档.txt",
                 "BufferedWriter");
         writerFileIsAppend("C:\\Users\\Administrator\\Desktop\\新建文本文档.txt",
                 "Append");
     }

     /**
      * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
      *
      * @paramfileName:文件的名
      */
     public static void readFileByBytes(String fileName) {
         File file = new File(fileName);
         InputStream in = null;
         try {
             System.out.println("以字节为单位读取文件内容，一次读多个字节：");
             /* 一次读多个字节 */
             byte[] tempbytes = new byte[100];
             int byteread = 0;
             in = new FileInputStream(file);
             /* 读入多个字节到字节数组中，byteread为一次读入的字节数 */
             while ((byteread = in.read(tempbytes)) != -1) {
                 for (byte b : tempbytes) {
                     System.out.println((char) b);
                 }
                 System.out.println(byteread);
             }
         } catch (Exception e1) {
             System.out.println("读取文本文件异常" + e1);
         } finally {
             if (in != null) {
                 try {
                     in.close();
                 } catch (IOException e1) {
                     System.out.println("读取文本文件异常" + e1);
                 }
             }
         }
     }

     /**
      * 以字符为单位读取文件，常用于读文本，数字等类型的文件
      *
      * @paramfileName:文件名
      */
     public static void readFileByChars(String fileName) {
         Reader reader = null;
         try {
             System.out.println("以字符为单位读取文件内容，一次读多个字节：");
             /* 一次读多个字符 */
             char[] tempchars = new char[100];
             int charread = 0;
             if (fileName != null && !"".equals(fileName)) {
                 reader = new InputStreamReader(new FileInputStream(fileName));
                 /* 读入多个字符到字符数组中，charread为一次读取字符数 */
                 while ((charread = reader.read(tempchars)) != -1) {
                     for (char c : tempchars) {
                         System.out.println(c);
                     }
                 }
             }
         } catch (Exception e1) {
             System.out.println("读取文本文件异常" + e1);
         } finally {
             if (reader != null) {
                 try {
                     reader.close();
                 } catch (IOException e1) {
                     System.out.println("读取文本文件异常" + e1);
                 }
             }
         }
     }

     /**
      * 以行为单位读取文件，常用于读面向行的格式化文件
      *
      * @paramfileName:文件名
      */
     public static List<String> readFileByLines(String fileName) {
         List<String> list = new ArrayList<String>();
         if (fileName != null && !"".equals(fileName)) {
             File file = new File(fileName);
             BufferedReader reader = null;
             try {
                 System.out.println("以行为单位读取文件内容，一次读一整行：");
                 reader = new BufferedReader(new FileReader(file));
                 String tempString = null;
                 /* 一次读入一行，直到读入null为文件结束 */
                 while ((tempString = reader.readLine()) != null) {
                     System.out.println(tempString);
                     list.add(tempString);
                 }
             } catch (IOException e) {
                 System.out.println("读取文本文件异常" + e);
             } finally {
                 if (reader != null) {
                     try {
                         reader.close();
                     } catch (IOException e1) {
                         System.out.println("读取文本文件异常" + e1);
                     }
                 }
             }
         }
         return list;
     }

     /**
      * 把内容写到文件
      *
      * @paramfilePathName文件名
      * @paramList<String>文件内容
      */
     public static boolean writerFile(String filePathName, String content) {
         boolean flag = false;
         OutputStreamWriter osw = null;
         try {
             if (filePathName != null && !"".equals(filePathName)) {
                 osw = new OutputStreamWriter(new FileOutputStream(filePathName));
             }
         } catch (FileNotFoundException e1) {
             flag = false;
             e1.printStackTrace();
         }
         if (osw != null) {
             BufferedWriter bw = new BufferedWriter(osw);
             try {
                 if (content != null && !"".equals(content)) {
                     bw.write(content);
                     flag = true;
                 }
             } catch (IOException e) {
                 flag = false;
                 e.printStackTrace();
             } finally {
                 try {
                     bw.close();
                     osw.close();
                 } catch (IOException e) {
                     flag = false;
                     e.printStackTrace();
                 }
             }
         }
         return flag;
     }

     /**
      * 把内容写到文件或追加到文件中
      *
      * @paramfilePathName文件名
      * @paramList<String>文件内容
      */
     public static boolean writerFileIsAppend(String filePathName, String content) {
         boolean flag = false;
         OutputStreamWriter osw = null;
         try {
             if (filePathName != null && !"".equals(filePathName)) {
                 osw = new OutputStreamWriter(new FileOutputStream(filePathName,
                         true));
             }
         } catch (Exception e1) {
             flag = false;
             e1.printStackTrace();
         }
         if (osw != null) {
             BufferedWriter bw = new BufferedWriter(osw);
             try {
                 if (content != null && !"".equals(content)) {
                     bw.write(content);
                     flag = true;
                 }
             } catch (IOException e) {
                 flag = false;
                 e.printStackTrace();
             } finally {
                 try {
                     bw.close();
                     osw.close();
                 } catch (IOException e) {
                     flag = false;
                     e.printStackTrace();
                 }
             }
         }
         return flag;
     }
 }

　　内容参考

http://www.2cto.com/kf/201206/136072.html

http://blog.csdn.net/liuhenghui5201/article/details/8292552