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;  
 }  


}