Java回顾之I/O

这篇文章主要回顾Java中和I/O操作相关的内容，I/O也是编程语言的一个基础特性，Java中的I/O分为两种类型，一种是顺序读取，一种是随机读取。

　　我们先来看顺序读取，有两种方式可以进行顺序读取，一种是InputStream/OutputStream，它是针对字节进行操作的输入输出流；另外一种是Reader/Writer，它是针对字符进行操作的输入输出流。

　　下面我们画出InputStream的结构

　　aaarticlea/png;base64,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" alt="" width="633" height="301" />

• FileInputStream：操作文件，经常和BufferedInputStream一起使用
• PipedInputStream：可用于线程间通信
• ObjectInputStream：可用于对象序列化
• ByteArrayInputStream：用于处理字节数组的输入
• LineNumberInputStream：可输出当前行数，并且可以在程序中进行修改

　　下面是OutputStream的结构

　　aaarticlea/png;base64,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" alt="" width="567" height="264" />

• PrintStream：提供了类似print和println的接口去输出数据

　　下面我们来看如何使用Stream的方式来操作输入输出

• 使用InputStream读取文件
   

   public static byte[] readFileByFileInputStream(File file) throws IOException
   {
       ByteArrayOutputStream output = new ByteArrayOutputStream();
       FileInputStream fis = null;
       try
       {
           fis = new FileInputStream(file);
           byte[] buffer = new byte[1024];
           int bytesRead = 0;
           while((bytesRead = fis.read(buffer, 0, buffer.length)) != -1)
           {
               output.write(buffer, 0, bytesRead);
           }
       }
       catch(Exception ex)
       {
           System.out.println("Error occurs during reading " + file.getAbsoluteFile());
       }
       finally
       {
           if (fis !=null) fis.close();
           if (output !=null) output.close();
       }
       return output.toByteArray();
   }

  
  

   public static byte[] readFileByBufferedInputStream(File file) throws Exception
   {
       FileInputStream fis = null;
       BufferedInputStream bis = null;
       ByteArrayOutputStream output = new ByteArrayOutputStream();
       try
       {
           fis = new FileInputStream(file);
           bis = new BufferedInputStream(fis);
           byte[] buffer = new byte[1024];
           int bytesRead = 0;
           while((bytesRead = bis.read(buffer, 0, buffer.length)) != -1)
           {
               output.write(buffer, 0, bytesRead);
           }
       }
       catch(Exception ex)
       {
           System.out.println("Error occurs during reading " + file.getAbsoluteFile());
       }
       finally
       {
           if (fis != null) fis.close();
           if (bis != null) bis.close();
           if (output != null) output.close();
       }
       return output.toByteArray();
   }

   
• 使用OutputStream复制文件
   

   public static void copyFileByFileOutputStream(File file) throws IOException
   {
       FileInputStream fis = null;
       FileOutputStream fos = null;
       try
       {
           fis = new FileInputStream(file);
           fos = new FileOutputStream(file.getName() + ".bak");
           byte[] buffer = new byte[1024];
           int bytesRead = 0;
           while((bytesRead = fis.read(buffer,0,buffer.length)) != -1)
           {
               fos.write(buffer, 0, bytesRead);
           }
           fos.flush();
       }
       catch(Exception ex)
       {
           System.out.println("Error occurs during copying " + file.getAbsoluteFile());
       }
       finally
       {
           if (fis != null) fis.close();
           if (fos != null) fos.close();
       }
   }

   
   

   public static void copyFilebyBufferedOutputStream(File file)throws IOException
   {
       FileInputStream fis = null;
       BufferedInputStream bis = null;
       FileOutputStream fos = null;
       BufferedOutputStream bos = null;
       try
       {
           fis = new FileInputStream(file);
           bis = new BufferedInputStream(fis);
           fos = new FileOutputStream(file.getName() + ".bak");
           bos = new BufferedOutputStream(fos);
           byte[] buffer = new byte[1024];
           int bytesRead = 0;
           while((bytesRead = bis.read(buffer, 0, buffer.length)) != -1)
           {
               bos.write(buffer, 0, bytesRead);
           }
           bos.flush();
       }
       catch(Exception ex)
       {
           System.out.println("Error occurs during copying " + file.getAbsoluteFile());
       }
       finally
       {
           if (fis != null) fis.close();
           if (bis != null) bis.close();
           if (fos != null) fos.close();
           if (bos != null) bos.close();
       }
   }

   

  这里的代码对异常的处理非常不完整，稍后我们会给出完整严谨的代码。

　　下面我们来看Reader的结构

　　aaarticlea/png;base64,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" alt="" width="549" height="235" />

　　这里的Reader基本上和InputStream能够对应上。　　

　　Writer的结构如下

　　aaarticlea/png;base64,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" alt="" width="604" height="257" />

　　下面我们来看一些使用Reader或者Writer的例子

• 使用Reader读取文件内容
   

   public static String readFile(String file)throws IOException
   {
       BufferedReader br = null;
       StringBuffer sb = new StringBuffer();
       try
       {
           br = new BufferedReader(new FileReader(file));
           String line = null;
  
           while((line = br.readLine()) != null)
           {
               sb.append(line);
           }
       }
       catch(Exception ex)
       {
           System.out.println("Error occurs during reading " + file);
       }
       finally
       {
           if (br != null) br.close();
       }
       return sb.toString();
   }

   
• 使用Writer复制文件
   

   public static void copyFile(String file) throws IOException
   {
       BufferedReader br = null;
       BufferedWriter bw = null;
       try
       {
           br = new BufferedReader(new FileReader(file));
           bw = new BufferedWriter(new FileWriter(file + ".bak"));
           String line = null;
           while((line = br.readLine())!= null)
           {
               bw.write(line);
           }
       }
       catch(Exception ex)
       {
           System.out.println("Error occurs during copying " + file);
       }
       finally
       {
           if (br != null) br.close();
           if (bw != null) bw.close();
       }
   }

   

　　下面我们来看如何对文件进行随机访问，Java中主要使用RandomAccessFile来对文件进行随机操作。

• 创建一个大小固定的文件
   

   public static void createFile(String file, int size) throws IOException
   {
       File temp = new File(file);
       RandomAccessFile raf = new RandomAccessFile(temp, "rw");
       raf.setLength(size);
       raf.close();
   }

   
• 向文件中随机写入数据
   

   public static void writeFile(String file, byte[] content, int startPos, int contentLength) throws IOException
   {
       RandomAccessFile raf = new RandomAccessFile(new File(file), "rw");
       raf.seek(startPos);
       raf.write(content, 0, contentLength);
       raf.close();
   }

   

　　接下里，我们来看一些其他的常用操作

• 移动文件
   

   public static boolean moveFile(String sourceFile, String destFile)
   {
       File source = new File(sourceFile);
       if (!source.exists()) throw new RuntimeException("source file does not exist.");
       File dest = new File(destFile);
       if (!(new File(dest.getPath()).exists())) new File(dest.getParent()).mkdirs();
       return source.renameTo(dest);
   }

   
• 复制文件
   

   public static void copyFile(String sourceFile, String destFile) throws IOException
   {
       File source = new File(sourceFile);
       if (!source.exists()) throw new RuntimeException("File does not exist.");
       if (!source.isFile()) throw new RuntimeException("It is not file.");
       if (!source.canRead()) throw new RuntimeException("File cound not be read.");
       File dest = new File(destFile);
       if (dest.exists())
       {
           if (dest.isDirectory()) throw new RuntimeException("Destination is a folder.");
           else
           {
               dest.delete();
           }
       }
       else
       {
           File parentFolder = new File(dest.getParent());
           if (!parentFolder.exists()) parentFolder.mkdirs();
           if (!parentFolder.canWrite()) throw new RuntimeException("Destination can not be written.");
       }
       FileInputStream fis = null;
       FileOutputStream fos = null;
       try
       {
           fis = new FileInputStream(source);
           fos = new FileOutputStream(dest);
           byte[] buffer = new byte[1024];
           int bytesRead = 0;
           while((bytesRead = fis.read(buffer, 0, buffer.length)) != -1)
           {
               fos.write(buffer, 0, bytesRead);
           }
           fos.flush();
       }
       catch(IOException ex)
       {
           System.out.println("Error occurs during copying " + sourceFile);
       }
       finally
       {
           if (fis != null) fis.close();
           if (fos != null) fos.close();
       }
   }

   
• 复制文件夹
   

   public static void copyDir(String sourceDir, String destDir) throws IOException
   {
  
       File source = new File(sourceDir);
       if (!source.exists()) throw new RuntimeException("Source does not exist.");
       if (!source.canRead()) throw new RuntimeException("Source could not be read.");
       File dest = new File(destDir);
       if (!dest.exists()) dest.mkdirs();
  
       File[] arrFiles = source.listFiles();
       for(int i = 0; i < arrFiles.length; i++)
       {
           if (arrFiles[i].isFile())
           {
               BufferedReader reader = new BufferedReader(new FileReader(arrFiles[i]));
               BufferedWriter writer = new BufferedWriter(new FileWriter(destDir + "/" + arrFiles[i].getName()));
               String line = null;
               while((line = reader.readLine()) != null) writer.write(line);
               writer.flush();
               reader.close();
               writer.close();
           }
           else
           {
               copyDir(sourceDir + "/" + arrFiles[i].getName(), destDir + "/" + arrFiles[i].getName());
           }
       }
   }

   
• 删除文件夹
   

   public static void del(String filePath)
   {
       File file = new File(filePath);
       if (file == null || !file.exists()) return;
       if (file.isFile())
       {
           file.delete();
       }
       else
       {
           File[] arrFiles = file.listFiles();
           if (arrFiles.length > 0)
           {
               for(int i = 0; i < arrFiles.length; i++)
               {
                   del(arrFiles[i].getAbsolutePath());
               }
           }
           file.delete();
       }
   }

   
• 获取文件夹大小
   

   public static long getFolderSize(String dir)
   {
       long size = 0;
       File file = new File(dir);
       if (!file.exists()) throw new RuntimeException("dir does not exist.");
       if (file.isFile()) return file.length();
       else
       {
           String[] arrFileName = file.list();
           for (int i = 0; i < arrFileName.length; i++)
           {
               size += getFolderSize(dir + "/" + arrFileName[i]);
           }
       }
  
       return size;
   }

   
• 将大文件切分为多个小文件
   

   public static void splitFile(String filePath, long unit) throws IOException
   {
       File file = new File(filePath);
       if (!file.exists()) throw new RuntimeException("file does not exist.");
       long size = file.length();
       if (unit >= size) return;
       int count = size % unit == 0 ? (int)(size/unit) : (int)(size/unit) + 1;
       String newFile = null;
       FileOutputStream fos = null;
       FileInputStream fis =null;
       byte[] buffer = new byte[(int)unit];
       fis = new FileInputStream(file);
       long startPos = 0;
       String countFile = filePath + "_Count";
       PrintWriter writer = new PrintWriter(new FileWriter( new File(countFile)));
       writer.println(filePath + "\t" + size);
       for (int i = 1; i <= count; i++)
       {
           newFile = filePath + "_" + i;
           startPos = (i - 1) * unit;
           System.out.println("Creating " + newFile);
           fos = new FileOutputStream(new File(newFile));
           int bytesRead = fis.read(buffer, 0, buffer.length);
           if (bytesRead != -1)
           {
               fos.write(buffer, 0, bytesRead);
               writer.println(newFile + "\t" + startPos + "\t" + bytesRead);
           }
           fos.flush();
           fos.close();
           System.out.println("StartPos:" + i*unit + "; EndPos:" + (i*unit + bytesRead));
       }
       writer.flush();
       writer.close();
       fis.close();
   }

   
• 将多个小文件合并为一个大文件
   

   public static void linkFiles(String countFile) throws IOException
   {
       File file = new File(countFile);
       if (!file.exists()) throw new RuntimeException("Count file does not exist.");
       BufferedReader reader = new BufferedReader(new FileReader(file));
       String line = reader.readLine();
       String newFile = line.split("\t")[0];
       long size = Long.parseLong(line.split("\t")[1]);
       RandomAccessFile raf = new RandomAccessFile(newFile, "rw");
       raf.setLength(size);
       FileInputStream fis = null;
       byte[] buffer = null;
  
       while((line = reader.readLine()) != null)
       {
           String[] arrInfo = line.split("\t");
           fis = new FileInputStream(new File(arrInfo[0]));
           buffer = new byte[Integer.parseInt(arrInfo[2])];
           long startPos = Long.parseLong(arrInfo[1]);
           fis.read(buffer, 0, Integer.parseInt(arrInfo[2]));
           raf.seek(startPos);
           raf.write(buffer, 0, Integer.parseInt(arrInfo[2]));
           fis.close();
       }
       raf.close();
   }

   
• 执行外部命令
   

   public static void execExternalCommand(String command, String argument)
   {
       Process process = null;
       try
       {
           process = Runtime.getRuntime().exec(command + " " + argument);
           InputStream is = process.getInputStream();
           BufferedReader br = new BufferedReader(new InputStreamReader(is));
           String line = null;
           while((line = br.readLine()) != null)
           {
               System.out.println(line);
           }
       }
       catch(Exception ex)
       {
           System.err.println(ex.getMessage());
       }
       finally
       {
           if (process != null) process.destroy();
       }
   }