`

Java读写文件 FileOperate

    博客分类：
  • java
 
阅读更多

FileOperate.java


import     java.io.*;     
  
public     class     FileOperate     {     
      public     FileOperate()     {     
      }     
  
      /**     
          *     新建目录     
          *     @param     folderPath     String     如     c:/fqf     
          *     @return     boolean     
          */     
      public     void     newFolder(String     folderPath)     {     
              try     {     
                      String     filePath     =     folderPath;     
                      filePath     =     filePath.toString();     
                      java.io.File     myFilePath     =     new     java.io.File(filePath);     
                      if     (!myFilePath.exists())     {     
                              myFilePath.mkdir();     
                      }     
              }     
              catch     (Exception     e)     {     
                      System.out.println( "新建目录操作出错 ");     
                      e.printStackTrace();     
              }     
      }     
  
      /**     
          *     新建文件     
          *     @param     filePathAndName     String     文件路径及名称     如c:/fqf.txt     
          *     @param     fileContent     String     文件内容     
          *     @return     boolean     
          */     
      public     void     newFile(String     filePathAndName,     String     fileContent)     {     
  
              try     {     
                      String     filePath     =     filePathAndName;     
                      filePath     =     filePath.toString();     
                      File     myFilePath     =     new     File(filePath);     
                      if     (!myFilePath.exists())     {     
                              myFilePath.createNewFile();     
                      }     
                      FileWriter     resultFile     =     new     FileWriter(myFilePath);     
                      PrintWriter     myFile     =     new     PrintWriter(resultFile);     
                      String     strContent     =     fileContent;     
                      myFile.println(strContent);     
                      resultFile.close();     
  
              }     
              catch     (Exception     e)     {     
                      System.out.println( "新建目录操作出错 ");     
                      e.printStackTrace();     
  
              }     
  
      }     
  
      /**     
          *     删除文件     
          *     @param     filePathAndName     String     文件路径及名称     如c:/fqf.txt     
          *     @param     fileContent     String     
          *     @return     boolean     
          */     
      public     void     delFile(String     filePathAndName)     {     
              try     {     
                      String     filePath     =     filePathAndName;     
                      filePath     =     filePath.toString();     
                      java.io.File     myDelFile     =     new     java.io.File(filePath);     
                      myDelFile.delete();     
  
              }     
              catch     (Exception     e)     {     
                      System.out.println( "删除文件操作出错 ");     
                      e.printStackTrace();     
  
              }     
  
      }     
  
      /**     
          *     删除文件夹     
          *     @param     filePathAndName     String     文件夹路径及名称     如c:/fqf     
          *     @param     fileContent     String     
          *     @return     boolean     
          */     
      public     void     delFolder(String     folderPath)     {     
              try     {     
                      delAllFile(folderPath);     //删除完里面所有内容     
                      String     filePath     =     folderPath;     
                      filePath     =     filePath.toString();     
                      java.io.File     myFilePath     =     new     java.io.File(filePath);     
                      myFilePath.delete();     //删除空文件夹     
  
              }     
              catch     (Exception     e)     {     
                      System.out.println( "删除文件夹操作出错 ");     
                      e.printStackTrace();     
  
              }     
  
      }     
  
      /**     
          *     删除文件夹里面的所有文件     
          *     @param     path     String     文件夹路径     如     c:/fqf     
          */     
      public     void     delAllFile(String     path)     {     
              File     file     =     new     File(path);     
              if     (!file.exists())     {     
                      return;     
              }     
              if     (!file.isDirectory())     {     
                      return;     
              }     
              String[]     tempList     =     file.list();     
              File     temp     =     null;     
              for     (int     i     =     0;     i     <     tempList.length;     i++)     {     
                      if     (path.endsWith(File.separator))     {     
                              temp     =     new     File(path     +     tempList[i]);     
                      }     
                      else     {     
                              temp     =     new     File(path     +     File.separator     +     tempList[i]);     
                      }     
                      if     (temp.isFile())     {     
                              temp.delete();     
                      }     
                      if     (temp.isDirectory())     {     
                              delAllFile(path+ "/ "+     tempList[i]);//先删除文件夹里面的文件     
                              delFolder(path+ "/ "+     tempList[i]);//再删除空文件夹     
                      }     
              }     
      }     
  
      /**     
          *     复制单个文件     
          *     @param     oldPath     String     原文件路径     如：c:/fqf.txt     
          *     @param     newPath     String     复制后路径     如：f:/fqf.txt     
          *     @return     boolean     
          */     
      public     void     copyFile(String     oldPath,     String     newPath)     {     
              try     {     
                      int     bytesum     =     0;     
                      int     byteread     =     0;     
                      File     oldfile     =     new     File(oldPath);     
                      if     (oldfile.exists())     {     //文件存在时     
                              InputStream     inStream     =     new     FileInputStream(oldPath);     //读入原文件     
                              FileOutputStream     fs     =     new     FileOutputStream(newPath);     
                              byte[]     buffer     =     new     byte[1444];     
                              int     length;     
                              while     (     (byteread     =     inStream.read(buffer))     !=     -1)     {     
                                      bytesum     +=     byteread;     //字节数     文件大小     
                                      System.out.println(bytesum);     
                                      fs.write(buffer,     0,     byteread);     
                              }     
                              inStream.close();     
                      }     
              }     
              catch     (Exception     e)     {     
                      System.out.println( "复制单个文件操作出错 ");     
                      e.printStackTrace();     
  
              }     
  
      }     
  
      /**     
          *     复制整个文件夹内容     
          *     @param     oldPath     String     原文件路径     如：c:/fqf     
          *     @param     newPath     String     复制后路径     如：f:/fqf/ff     
          *     @return     boolean     
          */     
      public     void     copyFolder(String     oldPath,     String     newPath)     {     
  
              try     {     
                      (new     File(newPath)).mkdirs();     //如果文件夹不存在     则建立新文件夹     
                      File     a=new     File(oldPath);     
                      String[]     file=a.list();     
                      File     temp=null;     
                      for     (int     i     =     0;     i     <     file.length;     i++)     {     
                              if(oldPath.endsWith(File.separator)){     
                                      temp=new     File(oldPath+file[i]);     
                              }     
                              else{     
                                      temp=new     File(oldPath+File.separator+file[i]);     
                              }     
  
                              if(temp.isFile()){     
                                      FileInputStream     input     =     new     FileInputStream(temp);     
                                      FileOutputStream     output     =     new     FileOutputStream(newPath     +     "/ "     +     
                                                      (temp.getName()).toString());     
                                      byte[]     b     =     new     byte[1024     *     5];     
                                      int     len;     
                                      while     (     (len     =     input.read(b))     !=     -1)     {     
                                              output.write(b,     0,     len);     
                                      }     
                                      output.flush();     
                                      output.close();     
                                      input.close();     
                              }     
                              if(temp.isDirectory()){//如果是子文件夹     
                                      copyFolder(oldPath+ "/ "+file[i],newPath+ "/ "+file[i]);     
                              }     
                      }     
              }     
              catch     (Exception     e)     {     
                      System.out.println( "复制整个文件夹内容操作出错 ");     
                      e.printStackTrace();     
  
              }     
  
      }     
  
      /**     
          *     移动文件到指定目录     
          *     @param     oldPath     String     如：c:/fqf.txt     
          *     @param     newPath     String     如：d:/fqf.txt     
          */     
      public     void     moveFile(String     oldPath,     String     newPath)     {     
              copyFile(oldPath,     newPath);     
              delFile(oldPath);     
  
      }     
  
      /**     
          *     移动文件到指定目录     
          *     @param     oldPath     String     如：c:/fqf.txt     
          *     @param     newPath     String     如：d:/fqf.txt     
          */     
      public     void     moveFolder(String     oldPath,     String     newPath)     {     
              copyFolder(oldPath,     newPath);     
              delFolder(oldPath);     
  
      }     
}

 

MergeFile.java

import java.io.*;
import java.util.*;


public class MergeFile {

 //private String srcfile;
 private String descfile="E:\\merge";
 MergeFile(){
  
 }
 public void merge(List<File> srcfiles,String descfile){
  if(descfile!=null&&!descfile.isEmpty()){
   this.descfile=descfile;
  }
  File mergefile=new File(descfile);
  if(!mergefile.exists()){
   mergefile.mkdirs();
  }
  
  for(File file:srcfiles){
   if(file!=null){
    for(File fille2:file.listFiles()){
     try {
      recursion( file.getPath(), fille2);
     } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
     }
    }
   }
   
  }
 }
  
 public void recursion(String root,File vFile) throws IOException{
   if(vFile.isFile()){
   File descfile=new File(getRelativePath(root,vFile.getPath())); 
    
   copy(  vFile,  descfile);
    
   
   }
   else {
    /*System.out.println("         path="+vFile.getPath());
    System.out.println("CanonicalPath="+vFile.getCanonicalPath());
    System.out.println(" absolutePath="+vFile.getAbsolutePath());
    System.out.println(" relativePath="+getRelativePath(root,vFile.getPath()));*/
    File directoryFile=new File(getRelativePath(root,vFile.getPath()));
    if(!directoryFile.exists()){
     directoryFile.mkdir();
    }
    File[] files=vFile.listFiles();
     if(files!=null && files.length>0){
      for(File file:files){
        
       recursion(root,file);
      } 
     }
     else{
      return;
     } 
     
     
     
   }
    
    
 }
    /**     
     *     复制单个文件     
     *     @param     oldPath     String     原文件路径     如：c:/fqf.txt     
     *     @param     newPath     String     复制后路径     如：f:/fqf.txt     
     *     @return     boolean     
     */     
 public     void     copyFile(String     oldPath,     String     newPath)     {     
         try     {     
                 int     bytesum     =     0;     
                 int     byteread     =     0;     
                 File     oldfile     =     new     File(oldPath);     
                 if     (oldfile.exists())     {     //文件存在时     
                         InputStream     inStream     =     new     FileInputStream(oldPath);     //读入原文件     
                         FileOutputStream     fs     =     new     FileOutputStream(newPath);     
                         byte[]     buffer     =     new     byte[1444];     
                         int     length;     
                         while     (     (byteread     =     inStream.read(buffer))     !=     -1)     {     
                                 bytesum     +=     byteread;     //字节数     文件大小     
                                 System.out.println(bytesum);     
                                 fs.write(buffer,     0,     byteread);     
                         }     
                         inStream.close();     
                 }     
         }     
         catch     (Exception     e)     {     
                 System.out.println( "复制单个文件操作出错 ");     
                 e.printStackTrace();    

         }    

 }     
 public void copy(File srcFile,File descFile){
  copyFile(     srcFile.getPath(),           descFile.getPath()); 
  /*FileOutputStream out=null;
  FileInputStream in=null;
  try {
   out=new FileOutputStream(descFile);
   in=new FileInputStream(srcFile);
   byte[] buffer=new byte[1024*8];
   while(in.read(buffer)!=-1){
    out.write(buffer);
    out.flush();
   }
   
   
  } catch (FileNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  finally{
   
   try {
    if(in!=null){
     in.close();
    }
    if(out!=null){
     out.flush();
     out.close();
    }
    
   } catch (IOException e) {
     // TODO Auto-generated catch block
    e.printStackTrace();
   }
    
   
  }*/
  
 }
 public String getRelativePath(String root,String file){
  return descfile+file.substring(root.length());
 }
 public static void main(String[] args){
  List<File> files=new ArrayList<File>();
  /*files.add(new File("E:\\test\\AppFramework.src"));
  files.add(new File("E:\\test\\javaws.src"));
  files.add(new File("E:\\test\\swing-worker.src"));
  files.add(new File("E:\\test\\swingx.src"));
  files.add(new File("E:\\test\\TimingFramework.src"));
  files.add(new File("C:\\Documents and Settings\\Administrator\\桌面\\新建文件夹 (2)\\SwingSet3"));
  */
  files.add(new File("E:\\test2\\a"));
  files.add(new File("E:\\test2\\b"));
   
  new MergeFile().merge(files, "E:\\merge2");
  System.out.println("merge成功！");
 }
 
}

分享到：
| POI导出报表 ExcelUtil
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    JAVA FileOperate.zip_java_java zip_zip

    - **读取文件**：`BufferedReader`或`FileReader`类可用于读取文件内容。例如，`new BufferedReader(new FileReader("path/to/file.txt"))`可以打开一个文件并逐行读取。 - **写入文件**：`BufferedWriter`或`...

    file-Operate.zip_FileOperate

    这可能是一个读取或写入文件的程序，展示了如何打开文件、设置读写模式、处理文件内容以及关闭文件。分析这个代码可以帮助我们更好地掌握文件流的基本用法。 总结一下，文件流操作是编程中一个基础但重要的概念，它...

    自然语言处理课程设计 宋词自动生成项目源码+文档说明（高分项目）.zip

    在FileOperate类中实现readInput读取文件操作。其中solution是LineSolution类的对象，在LineSolution中调用，这是根据自然语言处理相关知识实现宋词自动生成系统和中文分词系统。实现语言为java，编译器eclipse，...

    Java大作业——课程表工具.zip

    3. **文件操作**：项目中的`Fileoperate.java`文件涉及到文件读写操作，可能包括读取和保存用户的课程信息。Java提供了丰富的文件操作API，如`File`、`BufferedReader`和`PrintWriter`等，用于处理文件的创建、读取...

    《Java程序设计》实验9[文].pdf

    此任务要求对比`FileInputStream`和`FileReader`类对象读取文件的区别。`FileInputStream`用于处理字节流，而`FileReader`处理字符流。比较两者性能差异有助于理解它们在不同场景下的适用性。 **任务三：读取并输出...

    FileOperate

    "FileOperate"很可能是一个关于Java文件操作的项目或者库，旨在提供方便、高效的文件处理功能。在这个项目中，我们可能会遇到一系列与文件和目录相关的操作，如创建、读取、写入、删除文件，以及遍历目录等。以下是...

    java课程设计报告——客户管理系统源代码.pdf

    - 类可能包含读取和写入文件的方法，如使用 `BufferedReader` 和 `FileReader` 读取文件，`PrintWriter` 写入文件。 - `Scanner` 可能用于获取用户输入，进行文件操作时的交互。 在实际运行中，`FileOperate` 类...

    《Java程序设计》实验9定义.pdf

    - 实验二：比较`FileInputStream`和`FileReader`读取文件的性能差异。 - 实验三：使用文件输入流读取特定文本文件的前5个字节并输出。 - 实验四：实现异常处理，确保用户输入的文件名有效，并将文件内容显示在...

    java课程设计——客户管理系统源代码.docx

    通常，这些方法会涉及读取文件内容，解析客户信息，更新数据，并将更改写回文件。 在实际的系统中，`FileOperate` 类可能会实现以下功能： - `addCustomer(Person p)`：将新客户信息写入文件。 - `deleteCustomer...

    java课程设计-客户管理系统源代码.docx

    getList方法读取文件内容，将每一行数据转化为Person对象并存入ArrayList中返回。saveList方法则将列表中的Person对象写回文件，以备后续查询和操作。 通过这三个类的协作，客户管理系统实现了对客户数据的增删改查...

    java课程设计——客户管理系统源代码.pdf

    虽然代码中没有直接展示，但通常会有一个`ArrayList`或`List`对象来保存所有的客户对象，然后在需要时读取文件中的数据填充列表，或者将列表中的数据写入文件。 5. **用户交互**： - `Menu` 类通过控制台输出和...

    java课程设计报告——客户管理系统源代码.docx

    在这个系统中，用户通过`Menu`类提供的菜单选择操作，然后`FileOperate`类根据用户的选择执行相应的文件操作，如读取、写入或更新客户数据。为了完整实现这个系统，还需要添加实际的业务逻辑，比如根据用户选择的...

    java课程设计客户管理系统源代码.pdf

    `FileOperate`类实现了文件操作，用于读取、写入和处理保存在文件中的客户数据。在这里，客户信息被存储在一个名为`info.dat`的文件中。类的构造函数检查文件是否存在，如果不存在，则创建一个新的文件。 `...

    java课程设计客户管理系统源代码.docx

    类中使用`FileReader`和`BufferedReader`读取文件，`PrintWriter`写入文件，实现了对文本文件的基本操作。`FileOperate`还包含了处理文件操作的其他方法，例如，可能包括添加客户、删除客户、修改客户信息以及查询...

    java课程设计——客户管理系统源代码.doc

    - 使用 `BufferedReader` 和 `FileReader` 读取文件，`PrintWriter` 写入文件，处理IO异常。 - `ArrayList` 和 `List` 用于存储客户对象，便于进行增删改查操作。 - 类中还可能包含其他方法，如添加客户、删除...

    java课程设计报告-客户管理系统源代码.docx

    - 类使用 `File` 对象来处理文件操作，`BufferedReader` 和 `FileReader` 用于读取文件，`PrintWriter` 用于写入文件。 - `Scanner` 对象用于从系统输入获取用户选择的操作或查询条件。 - 此类通常会包含方法来...

    Java实现单人信息管理程序

    通过`FileOperate`类进行文件的读写，`Person`类封装个人数据，而`Operate`类则提供了与用户交互的接口，实现信息的管理功能。这样的程序不仅锻炼了Java基本技能，还涉及到了面向对象编程、异常处理和文件操作等多个...

Magicbox
Global site tag (gtag.js) - Google Analytics