读写文件使用

package com.dzf.file;
 
 
 
import java.io.BufferedReader;
 
import java.io.File;
 
import java.io.FileInputStream;
 
import java.io.FileNotFoundException;
 
import java.io.FileOutputStream;
 
import java.io.FileWriter;
 
import java.io.IOException;
 
import java.io.InputStream;
 
import java.io.InputStreamReader;
 
import java.io.PrintWriter;
 
import java.io.UnsupportedEncodingException;
 
import java.text.SimpleDateFormat;
 
import java.util.ArrayList;
 
import java.util.Date;
 
import java.util.Iterator;
 
 
 
public class FileUtil {
 
 
 
  /**
   * 删除某个文件夹下的所有文件夹和文件
   * 
   * @param delpath
   *            String
   * @throws FileNotFoundException
   * @throws IOException
   * @return boolean
   */
 
  public static boolean deletefile(String delpath)
 
      throws FileNotFoundException, IOException {
 
    try {
 
 
 
      File file = new File(delpath);
 
      if (!file.isDirectory()) {
 
        System.out.println("1");
 
        file.delete();
 
      } else if (file.isDirectory()) {
 
        System.out.println("2");
 
        String[] filelist = file.list();
 
        for (int i = 0; i < filelist.length; i++) {
 
          File delfile = new File(delpath + "//" + filelist[i]);
 
          if (!delfile.isDirectory()) {
 
            System.out.println("path=" + delfile.getPath());
 
            System.out.println("absolutepath="
 
                + delfile.getAbsolutePath());
 
            System.out.println("name=" + delfile.getName());
 
            delfile.delete();
 
            System.out.println("删除文件成功");
 
          } else if (delfile.isDirectory()) {
 
            deletefile(delpath + "//" + filelist[i]);
 
          }
 
        }
 
        file.delete();
 
 
 
      }
 
 
 
    } catch (FileNotFoundException e) {
 
      System.out.println("deletefile()   Exception:" + e.getMessage());
 
    }
 
    return true;
 
  }
 
 
 
  /**
   * 读取某个文件夹下的所有文件的内容
   * 
   * @param filepath
   *            String
   * @throws FileNotFoundException
   * @throws IOException
   * @return boolean
   */
 
  public static ArrayList getContent(String filepath, ArrayList listResult)
 
      throws FileNotFoundException, IOException {
 
    try {
 
      File file = new File(filepath);
 
      if (!file.isDirectory()) {
 
 
 
        // System.out.println("文件");
 
        // System.out.println("path=" + file.getPath());
 
        // System.out.println("absolutepath=" + file.getAbsolutePath());
 
        // if (file.getName().indexOf(".txt") > 0) {//用于取某类型的文件
 
        System.out.println("name=" + file.getName());
 
        // result = result + fileToString(file);
 
        fileToString(file, listResult);
 
        // }
 
 
 
      } else if (file.isDirectory()) {
 
        String[] filelist = file.list();
 
        for (int i = 0; i < filelist.length; i++) {
 
          File readfile = new File(filepath + "//" + filelist[i]);
 
          if (!readfile.isDirectory()) {
 
 
 
            System.out.println("path=" + readfile.getPath());
 
            System.out.println("absolutepath="
 
                + readfile.getAbsolutePath());
 
            // if (readfile.getName().indexOf(".txt") > 0) {
 
            System.out.println("name=" + readfile.getName());
 
            fileToString(readfile, listResult);
 
            // }
 
 
 
          } else if (readfile.isDirectory()) {
 
            getContent(filepath + "//" + filelist[i], listResult);
 
          }
 
        }
 
      }
 
 
 
    } catch (FileNotFoundException e) {
 
      System.out.println("readfile()   Exception:" + e.getMessage());
 
    }
 
    return listResult;
 
  }
 
 
 
  /**
   * 获取某个文件夹下所有的文件名
   * 
   * @param aDir
   * @return
   */
 
  @SuppressWarnings("unchecked")
 
  public static ArrayList getFiles(String aDir) {
 
    ArrayList files = new ArrayList();
 
    File dirx = new File(aDir);
 
    File[] dirFilesx = dirx.listFiles();
 
 
 
    for (int k = 0; k < dirFilesx.length; k++) {
 
      System.out.print("|");
 
      File file = dirFilesx[k];
 
      String fileName = file.getName();
 
      System.out.println("-" + fileName);
 
      if (file.isDirectory()) {
 
        String dirx1 = aDir + "//" + fileName;
 
        getFiles(dirx1);
 
      } else {
 
        files.add(file);
 
      }
 
 
 
    }
 
    return files;
 
  }
 
 
 
  /**
   * 创建目录
   * 
   * @param folderPath:目录路径
   * @return
   * @throws IOException
   */
 
  public static boolean createFolder(String folderPath) throws IOException {
 
    boolean result = false;
 
    File f = new File(folderPath);
 
    result = f.mkdirs();
 
    return result;
 
  }
 
 
 
  /**
   * 删除目录下所有文件
   * 
   * @param directory
   *            (File 对象)
   */
 
  public void emptyDirectory(File directory) {
 
    File[] entries = directory.listFiles();
 
    for (int i = 0; i < entries.length; i++) {
 
      entries[i].delete();
 
    }
 
  }
 
 
 
  /**
   * 创建文件
   * 
   * @param filepath:文件所在目录路径,比如:c:/test/test.txt
   * @return
   */
 
  public static boolean makeFile(String filepath) throws IOException {
 
    boolean result = false;
 
    File file = new File(filepath);
 
    result = file.createNewFile();
 
    file = null;
 
    return result;
 
  }
 
 
 
  /**
   * 删除文件
   * 
   * @param filepath:文件所在物理路径
   * @return
   */
 
  public static boolean isDel(String filepath) {
 
    boolean result = false;
 
    File file = new File(filepath);
 
    result = file.delete();
 
    file = null;
 
    return result;
 
  }
 
 
 
  /**
   * 文件重命名
   * 
   * @param filepath:文件所在物理路径
   * @param destname:新文件名
   * @return
   */
 
  public static boolean renamefile(String filepath, String destname) {
 
    boolean result = false;
 
    File f = new File(filepath);
 
    String fileParent = f.getParent();
 
    File rf = new File(fileParent + "//" + destname);
 
    if (f.renameTo(rf)) {
 
      result = true;
 
    }
 
    f = null;
 
    rf = null;
 
    return result;
 
  }
 
 
 
  /**
   * 将文件内容写入文件中
   * 
   * @param filepath:文件所在物理路径
   * @param content:写入内容
   * @throws Exception
   */
 
  public static void WriteFile(String filepath, String content)
 
      throws Exception {
 
    FileWriter filewriter = new FileWriter(filepath, true);// 写入多行
 
    PrintWriter printwriter = new PrintWriter(filewriter);
 
    printwriter.println(content);
 
    printwriter.flush();
 
    printwriter.close();
 
    filewriter.close();
 
  }
 
 
 
  /**
   * 日志备份
   * 
   * @param filePath:日志备份路径
   * @param baksize:日志备份大小参考值(字节大小)
   * @throws IOException
   */
 
  public static void logBak(String filePath, long baksize) throws IOException {
 
    File f = new File(filePath);
 
    long len = f.length();
 
    SimpleDateFormat simpledateformat = new SimpleDateFormat(
 
        "yyyyMMddHHmmss");
 
    String s = simpledateformat.format(new Date());
 
    String fileName = f.getName();
 
    int dot = fileName.indexOf(".");
 
    String bakName = s + fileName.substring(dot);
 
    System.out.println(bakName);
 
    if (len >= baksize) {
 
      renamefile(filePath, bakName);
 
      makeFile(filePath);
 
    }
 
    f = null;
 
  }
 
 
 
  /**
   * 新建目录
   * 
   * @param folderPath
   *            String 如 c:/dzf
   * @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:/dzf.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:/dzf.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:/dzf
   * @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:/dzf
   */
 
  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:/dzf.txt
   * @param newPath
   *            String 复制后路径 如：f:/dzf.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];
 
        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:/dzf
   * @param newPath
   *            String 复制后路径 如：f:/dzf/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:/dzf.txt
   * @param newPath
   *            String 如：d:/dzf.txt
   */
 
  public void moveFile(String oldPath, String newPath) {
 
    copyFile(oldPath, newPath);
 
    delFile(oldPath);
 
 
 
  }
 
 
 
  /**
   * 移动文件到指定目录
   * 
   * @param oldPath
   *            String 如：c:/dzf.txt
   * @param newPath
   *            String 如：d:/dzf.txt
   */
 
  public void moveFolder(String oldPath, String newPath) {
 
    copyFolder(oldPath, newPath);
 
    delFolder(oldPath);
 
  }
 
 
 
  public static void fileToString(File readfile, ArrayList result)
 
      throws UnsupportedEncodingException, FileNotFoundException,
 
      IOException {
 
    InputStreamReader read = new InputStreamReader(new FileInputStream(
 
        readfile), "utf-8");
 
    BufferedReader reader = new BufferedReader(read);
 
    String line = new String();
 
    while ((line = reader.readLine()) != null) {
 
      if (!line.equals("")) {
 
        // if (Pattern.compile(regEx).matcher(line).find())
 
        // {//使用正则表达式取所查找的内容
 
        result.add(line);
 
        // }
 
      }
 
    }
 
    reader.close();
 
    read.close();
 
  }
 
 
 
  /**
   * 读取文件内容
   * 
   * @param readfile
   * @return
   * @throws UnsupportedEncodingException
   * @throws FileNotFoundException
   * @throws IOException
   */
 
  public static void fileToString(String readfile, ArrayList result)
 
      throws UnsupportedEncodingException, FileNotFoundException,
 
      IOException {
 
    InputStreamReader read = new InputStreamReader(new FileInputStream(
 
        readfile), "UTF-8");
 
    BufferedReader reader = new BufferedReader(read);
 
    String line;
 
    while ((line = reader.readLine()) != null) {
 
      result.add(line);
 
    }
 
    reader.close();
 
    read.close();
 
  }
 
 
 
  public static void main(String[] args) {
 
    try {
 
      ArrayList al = new ArrayList();
 
      getContent("E:/ddd", al);
 
      System.out.println("/n/n/n/n/n/n/n/n/n/n");
 
      for (Iterator iter = al.iterator(); iter.hasNext();) {
 
        String element = (String) iter.next();
 
        System.out.print(element);
 
      }
 
      /*
       * ArrayList dd = getFiles("E:/ddd"); for (Iterator iter =
       * dd.iterator(); iter.hasNext();) { System.out.print(iter.next()); }
       */
 
    } catch (FileNotFoundException e) {
 
      e.printStackTrace();
 
    } catch (IOException e) {
 
      e.printStackTrace();
 
    }
 
  }
 
 
 
}