Java基础知识之文件操作

　　流与文件的操作在编程中经常遇到，与C语言只有单一类型File*即可工作良好不同，Java拥有一个包含各种流类型的流家族，其数量超过60个！当然我们没必要去记住这60多个类或接口以及它们的层次结构，理解和掌握其中比较常用的类和接口即可，必要的时候查询文档或API。我们把流家族成员按照它们的使用方法来进行划分，就形成了处理字节和字符的两个单独的层次结构。　　　　                                                                                                                                                     

　　　　　　　　　　　　　　　　常用的字节字符流　　　　　　　

本文主要总结了如何使用流对文件进行相应的操作。

新建文件(夹)

createFile(String path, String name)方法在指定路径path下创建文件，如果路径不存在，就创建路径，如果文件已存在，不做操作。

createDir(String name)方法创建指定的目录name。

createDir(String path, String name)方法在指定路径path下创建文件夹name。

 /**
  * @description 根据路径创建文件
  * @param path 路径 e.g. F:\temp
  * @param name 文件名 e.g. hello.txt
  * @return
  */
 public File createFile(String path, String name) {
     File file = new File(path);
     try {
         if(!file.exists()) {
             file.mkdirs();
         }
         file = new File(path + File.separator + name);
         if(!file.exists()) {
             file.createNewFile();
         }
     } catch (IOException e) {
         e.printStackTrace();
     }
     return file;
 }

 /**
  * @description 创建文件目录
  * @param name e.g. F:\temp\hello\world
  * @return
  * @throws IOException
  */
 public File createDir(String name) throws IOException {
     File file = new File(name);
     if(!file.exists()) {
         file.mkdirs();
     }
     return file;
 }

 /**
  * @description 根据路径创建文件夹
  * @param path 路径 e.g. F:\temp
  * @param name 文件夹名 e.g. hello
  * @return
  * @throws IOException
  */
 public File createDir(String path, String name) throws IOException {
     File file = new File(path + File.separator + name);
     if(!file.exists()) {
         file.mkdirs();
     }
     return file;
 }

删除文件(夹)

删除指定文件或文件夹，如果传入的参数是文件，则直接删除，如果是目录，递归调用方法，删除该目录下所有文件和目录。

 /**
  * @description 删除文件(夹)
  * @param file
  * @throws IOException
  */
 public void deleteFile(File file) throws IOException {
     if(file.exists()) {
         if(file.isFile()) {
             file.delete();
         }else if(file.isDirectory()){
             File[] files = file.listFiles();
             for(File item : files) {
                 deleteFile(item);
             }
             file.delete();
         }
     }else {
         throw new FileNotFoundException();
     }
 }

读写文件

文件的读操作，使用带缓冲的字节流，以字节的形式读取文件，并写到参数指定的输出流out。

文件的写操作，使用带缓冲的字节流，从参数指定的输入流in读取，并以字节形式写到目标文件。

 /**
  * @description 读文件
  * @param name 源文件
  * @param out 输出流
  * @throws FileNotFoundException
  */
 public void readFile(File name, OutputStream out) throws FileNotFoundException {
     BufferedInputStream bis = new BufferedInputStream(new FileInputStream(name));
     BufferedOutputStream bos = new BufferedOutputStream(out);
     int len = 0;
     byte[] buffer = new byte[1024];
     try {
         while((len = bis.read(buffer)) != -1) {
             bos.write(buffer, 0, len);
         }
     } catch (IOException e) {
         e.printStackTrace();
     } finally {
         try {
             bos.close();
             bis.close();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 }

 /**
  * @description 写文件
  * @param name 目标文件
  * @param in 输入流
  * @throws FileNotFoundException
  */
 public void writeFile(File name, InputStream in) throws FileNotFoundException {
     BufferedInputStream bis = new BufferedInputStream(in);
     BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(name));
     int len = 0;
     byte[] buffer = new byte[1024];
     try {
         while((len = bis.read(buffer)) != -1) {
             bos.write(buffer, 0, len);
         }
     } catch (IOException e) {
         e.printStackTrace();
     } finally {
         try {
             bos.close();
             bis.close();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 }

文件(夹)拷贝

文件拷贝，源文件src可以是文件或是目录，目标文件desc为目录。如果src是文件，直接拷贝到desc路径下；如果src是目录，首先在desc目录下创建该目录，然后遍历src目录下所有文件和目录，递归调用拷贝方法，最终实现整个文件的拷贝。

 /**
  * @description 拷贝文件
  * @param src 源文件(夹) e.g. F:\hello
  * @param desc 目标文件夹 e.g. F:\world
  */
 public void copyFile(File src, File desc){
     BufferedInputStream in = null;
     BufferedOutputStream out = null;
     try {
         if(src.isFile()) {
             desc = createFile(desc.getCanonicalPath(), src.getName());
             in = new BufferedInputStream(new FileInputStream(src));
             out = new BufferedOutputStream(new FileOutputStream(desc));
             int len = 0;
             byte[] buffer = new byte[1024];
             while((len = in.read(buffer)) != -1) {
                 out.write(buffer, 0, len);
                 out.flush();
             }
         } else if (src.isDirectory()) {
             desc = createDir(desc.getCanonicalPath(), src.getName());
             File[] files = src.listFiles();
             for(File item : files) {
                 copyFile(item, desc);
             }
         } else {
             throw new FileNotFoundException();
         }
     } catch (IOException e) {
         e.printStackTrace();
     } finally {
         try {
             if(out != null) {
                 out.close();
             }
             if(in != null) {
                 in.close();
             }
         } catch(IOException e) {
             e.printStackTrace();
         }
     }
 } 

文件目录遍历

遍历参数指定目录下的所有文件和目录，感兴趣可以做成树形结构。

 /**
  * @description 遍历文件目录
  * @param file
  * @throws IOException
  */
 public void traverseFile(File file) throws IOException {
     if(file.isFile()) {
         //do something you like
     } else if(file.isDirectory()) {
         File[] list = file.listFiles();
         for(File item : list) {
             traverseFile(item);
         }
     } else {
         throw new FileNotFoundException();
     }
 }