FileUtil（File处理工具类，copy，压缩，删除等）

 

File处理工具

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
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.OutputStream;
import java.text.DateFormat;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Enumeration;
import java.util.List;
import java.util.Locale;
import java.util.StringTokenizer;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

/**
 *
 * @author IBM
 *
 */

public class FileUtil {

    public static String dirSplit = "\\";//linux windows
    /**
     * save file accroding to physical directory infomation
     *
     * @param physicalDir
     *            physical directory
     * @param fname
     *            file name of destination
     * @param istream
     *            input stream of destination file
     * @return
     */

    public static boolean SaveFileByPhysicalDir(String physicalPath,
            InputStream istream) {

        boolean flag = false;
        try {
            OutputStream os = new FileOutputStream(physicalPath);
            int readBytes = 0;
            byte buffer[] = new byte[8192];
            while ((readBytes = istream.read(buffer, 0, 8192)) != -1) {
                os.write(buffer, 0, readBytes);
            }
            os.close();
            flag = true;
        } catch (FileNotFoundException e) {

            e.printStackTrace();
        } catch (IOException e) {

            e.printStackTrace();
        }
        return flag;
    }

    public static boolean CreateDirectory(String dir){
        File f = new File(dir);
        if (!f.exists()) {
            f.mkdirs();
        }
        return true;
    }


    public static void saveAsFileOutputStream(String physicalPath,String content) {
          File file = new File(physicalPath);
          boolean b = file.getParentFile().isDirectory();
          if(!b){
              File tem = new File(file.getParent());
              // tem.getParentFile().setWritable(true);
              tem.mkdirs();// 创建目录
          }
          //Log.info(file.getParent()+";"+file.getParentFile().isDirectory());
          FileOutputStream foutput =null;
          try {
              foutput = new FileOutputStream(physicalPath);

              foutput.write(content.getBytes("UTF-8"));
              //foutput.write(content.getBytes());
          }catch(IOException ex) {
              ex.printStackTrace();
              throw new RuntimeException(ex);
          }finally{
              try {
                  foutput.flush();
                  foutput.close();
              }catch(IOException ex){
                  ex.printStackTrace();
                  throw new RuntimeException(ex);
              }
          }
            //Log.info("文件保存成功:"+ physicalPath);
         }



     /**
     * COPY文件
     * @param srcFile String
     * @param desFile String
     * @return boolean
     */
    public boolean copyToFile(String srcFile, String desFile) {
        File scrfile = new File(srcFile);
        if (scrfile.isFile() == true) {
            int length;
            FileInputStream fis = null;
            try {
                fis = new FileInputStream(scrfile);
            }
            catch (FileNotFoundException ex) {
                ex.printStackTrace();
            }
            File desfile = new File(desFile);

            FileOutputStream fos = null;
            try {
                fos = new FileOutputStream(desfile, false);
            }
            catch (FileNotFoundException ex) {
                ex.printStackTrace();
            }
            desfile = null;
            length = (int) scrfile.length();
            byte[] b = new byte[length];
            try {
                fis.read(b);
                fis.close();
                fos.write(b);
                fos.close();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            scrfile = null;
            return false;
        }
        scrfile = null;
        return true;
    }

    /**
     * COPY文件夹
     * @param sourceDir String
     * @param destDir String
     * @return boolean
     */
    public boolean copyDir(String sourceDir, String destDir) {
        File sourceFile = new File(sourceDir);
        String tempSource;
        String tempDest;
        String fileName;
        File[] files = sourceFile.listFiles();
        for (int i = 0; i < files.length; i++) {
            fileName = files[i].getName();
            tempSource = sourceDir + "/" + fileName;
            tempDest = destDir + "/" + fileName;
            if (files[i].isFile()) {
                copyToFile(tempSource, tempDest);
            } else {
                copyDir(tempSource, tempDest);
            }
        }
        sourceFile = null;
        return true;
    }

    /**
     * 删除指定目录及其中的所有内容。
     * @param dir 要删除的目录
     * @return 删除成功时返回true，否则返回false。
     */
    public boolean deleteDirectory(File dir) {
        File[] entries = dir.listFiles();
        int sz = entries.length;
        for (int i = 0; i < sz; i++) {
            if (entries[i].isDirectory()) {
                if (!deleteDirectory(entries[i])) {
                    return false;
                }
            } else {
                if (!entries[i].delete()) {
                    return false;
                }
            }
        }
        if (!dir.delete()) {
            return false;
        }
        return true;
    }



    /**
     * File exist check
     *
     * @param sFileName File Name
     * @return boolean true - exist<br>
     *                 false - not exist
     */
    public static boolean checkExist(String sFileName) {

     boolean result = false;

       try {
           File f = new File(sFileName);

           //if (f.exists() && f.isFile() && f.canRead()) {
       if (f.exists() && f.isFile()) {
            result = true;
       } else {
            result = false;
       }
       } catch (Exception e) {
            result = false;
       }

        /* return */
        return result;
    }

    /**
     * Get File Size
     *
     * @param sFileName File Name
     * @return long File's size(byte) when File not exist return -1
     */
    public static long getSize(String sFileName) {

        long lSize = 0;

        try {
            File f = new File(sFileName);

                    //exist
            if (f.exists()) {
                if (f.isFile() && f.canRead()) {
                 lSize = f.length();
                } else {
                 lSize = -1;
                }
                    //not exist
            } else {
                lSize = 0;
            }
       } catch (Exception e) {
            lSize = -1;
       }
       /* return */
       return lSize;
    }

 /**
  * File Delete
  *
  * @param sFileName File Nmae
  * @return boolean true - Delete Success<br>
  *                 false - Delete Fail
  */
    public static boolean deleteFromName(String sFileName) {

        boolean bReturn = true;

        try {
            File oFile = new File(sFileName);

           //exist
           if (oFile.exists()) {
               //Delete File
               boolean bResult = oFile.delete();
               //Delete Fail
               if (bResult == false) {
                   bReturn = false;
               }

               //not exist
           } else {

           }

      } catch (Exception e) {
          bReturn = false;
      }

      //return
      return bReturn;
    }

 /**
  * File Unzip
  *
  * @param sToPath  Unzip Directory path
  * @param sZipFile Unzip File Name
  */
 @SuppressWarnings("rawtypes")
public static void releaseZip(String sToPath, String sZipFile) throws Exception {

  if (null == sToPath ||("").equals(sToPath.trim())) {
       File objZipFile = new File(sZipFile);
       sToPath = objZipFile.getParent();
  }
  ZipFile zfile = new ZipFile(sZipFile);
  Enumeration zList = zfile.entries();
  ZipEntry ze = null;
  byte[] buf = new byte[1024];
  while (zList.hasMoreElements()) {

       ze = (ZipEntry) zList.nextElement();
       if (ze.isDirectory()) {
        continue;
       }

       OutputStream os =
       new BufferedOutputStream(
       new FileOutputStream(getRealFileName(sToPath, ze.getName())));
       InputStream is = new BufferedInputStream(zfile.getInputStream(ze));
       int readLen = 0;
       while ((readLen = is.read(buf, 0, 1024)) != -1) {
           os.write(buf, 0, readLen);
       }
       is.close();
       os.close();
  }
  zfile.close();
 }

 /**
  * getRealFileName
  *
  * @param  baseDir   Root Directory
  * @param  absFileName  absolute Directory File Name
  * @return java.io.File     Return file
  */
 @SuppressWarnings({ "rawtypes", "unchecked" })
private static File getRealFileName(String baseDir, String absFileName) throws Exception {

  File ret = null;

  List dirs = new ArrayList();
  StringTokenizer st = new StringTokenizer(absFileName, System.getProperty("file.separator"));
  while (st.hasMoreTokens()) {
      dirs.add(st.nextToken());
  }

  ret = new File(baseDir);
  if (dirs.size() > 1) {
      for (int i = 0; i < dirs.size() - 1; i++) {
          ret = new File(ret, (String) dirs.get(i));
      }
  }
  if (!ret.exists()) {
      ret.mkdirs();
  }
  ret = new File(ret, (String) dirs.get(dirs.size() - 1));
  return ret;
 }

 /**
  * copyFile
  *
  * @param  srcFile   Source File
  * @param  targetFile   Target file
  */
 @SuppressWarnings("resource")
 static public void copyFile(String srcFile , String targetFile) throws IOException
  {

   FileInputStream reader = new FileInputStream(srcFile);
   FileOutputStream writer = new FileOutputStream(targetFile);

   byte[] buffer = new byte [4096];
   int len;

   try
   {
       reader = new FileInputStream(srcFile);
       writer = new FileOutputStream(targetFile);

       while((len = reader.read(buffer)) > 0)
       {
           writer.write(buffer , 0 , len);
       }
   }
   catch(IOException e)
   {
       throw e;
   }
   finally
   {
       if (writer != null)writer.close();
       if (reader != null)reader.close();
   }
  }

 /**
  * renameFile
  *
  * @param  srcFile   Source File
  * @param  targetFile   Target file
  */
 static public void renameFile(String srcFile , String targetFile) throws IOException
  {
   try {
       copyFile(srcFile,targetFile);
       deleteFromName(srcFile);
   } catch(IOException e){
       throw e;
   }
  }


 public static void write(String tivoliMsg,String logFileName) {
  try{
       byte[]  bMsg = tivoliMsg.getBytes();
       FileOutputStream fOut = new FileOutputStream(logFileName, true);
       fOut.write(bMsg);
       fOut.close();
  } catch(IOException e){
   //throw the exception
  }

 }
 /**
 * This method is used to log the messages with timestamp,error code and the method details
 * @param errorCd String
 * @param className String
 * @param methodName String
 * @param msg String
 */
 public static void writeLog(String logFile, String batchId, String exceptionInfo) {

  DateFormat df = DateFormat.getDateTimeInstance(DateFormat.DEFAULT, DateFormat.DEFAULT, Locale.JAPANESE);

  Object args[] = {df.format(new Date()), batchId, exceptionInfo};

  String fmtMsg = MessageFormat.format("{0} : {1} : {2}", args);

  try {

   File logfile = new File(logFile);
   if(!logfile.exists()) {
    logfile.createNewFile();
   }

      FileWriter fw = new FileWriter(logFile, true);
      fw.write(fmtMsg);
      fw.write(System.getProperty("line.separator"));

      fw.flush();
      fw.close();

  } catch(Exception e) {
  }
 }

 public static String readTextFile(String realPath) throws Exception {
     File file = new File(realPath);
        if (!file.exists()){
            System.out.println("File not exist!");
            return null;
      }
      BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(realPath),"UTF-8"));
      String temp = "";
      String txt="";
      while((temp = br.readLine()) != null){
          txt+=temp;
       }
      br.close();
     return txt;
 }


}