複製代碼代碼如下：
導入java.io.io.bufferedinputstream;
導入java.io.io.bufferedoutputstream;
導入java.io..bufferedreader;
導入java.io.file;
導入java.io.io.fileinputstream;
導入java.io.filenotfoundexception;
導入java.io.io.fileoutputstream;
導入java.io..filewriter;
導入java.io.ioexception;
導入java.io.inputstream;
導入java.io.io.inputStreamReader;
導入java.io.outputstream;
導入java.text.dateformat;
導入java.text.messageformat;
導入java.util.arraylist;
導入java.util.date;
導入Java.util.Enumeration;
導入java.util.list;
導入Java.util.locale;
導入Java.util.StringTokenizer;
導入java.util.zip.zipentry;
導入java.util.zip.zipfile;
/**
*
* @author IBM
*
*/
公共類Fileutil {
公共靜態字符串dirsplit =“ //”; // Linux Windows
/**
*將累積的文件保存到物理目錄信息中
*
* @param物理dir
*物理目錄
* @param fname
*目的地的文件名
* @param istream
*目標文件的輸入流
* @返回
*/
public static boolean savefilebyphysicaldir（字符串物理路徑，
inputstream istream）{
boolean flag = false;
嘗試 {
outputStream OS = new FileOutputStream（物理路徑）;
int readbytes = 0;
字節緩衝區[] = 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（）;
}
返回標誌；
}
public static boolean createRectory（string dir）{
文件f =新文件（dir）;
如果（！f.exists（））{
f.mkdirs（）;
}
返回true;
}
public static void saveasfileoutputputstream（字符串物理路徑，字符串內容）{
文件文件=新文件（物理路徑）;
boolean b = file.getParentFile（）。isDirectory（）;
如果（！b）{
file tem = new file（file.getParent（））;
// tem.getParentFile（）。setWritable（true）;
tem.mkdirs（）; //創建目錄
}
//log.info(file.getParent（）+“;”+file.getParentFile（）。isDirectory（））;
fileOutputStream foutput = null;
嘗試 {
foutput = new fileOutputStream（物理路徑）;
foutput.write（content.getBytes（“ utf-8”））;
//foutput.write（content.getBytes（））;
} catch（ioexception ex）{
ex.printstacktrace（）;
投擲新的RuntimeException（ex）;
}最後{
嘗試 {
foutput.flush（）;
foutput.close（）;
} catch（ioexception ex）{
ex.printstacktrace（）;
投擲新的RuntimeException（ex）;
}
}
//log.info（“文件保存成功：”+物理路徑）;
}
/**
*複製文件
* @param srcfile字符串
* @param desfile字符串
* @return布爾
*/
public boolean copytofile（字符串srcfile，string desfile）{
文件scrfile =新文件（srcfile）;
if（scrfile.isfile（）== true）{
int長度；
FileInputStream fis = null;
嘗試 {
fis = new fileInputStream（scrfile）;
}
catch（filenotfoundexception ex）{
ex.printstacktrace（）;
}
文件desfile =新文件（desfile）;
fileOutputStream fos = null;
嘗試 {
fos = new fileOutputStream（desfile，false）;
}
catch（filenotfoundexception ex）{
ex.printstacktrace（）;
}
desfile = null;
長度=（int）scrfile.length（）;
字節[] b = new byte [length];
嘗試 {
fis.Read（b）;
fis.close（）;
fos.write（b）;
fos.close（）;
}
捕獲（ioexception e）{
e.printstacktrace（）;
}
} 別的 {
scrfile = null;
返回false;
}
scrfile = null;
返回true;
}
/**
*複製文件夾
* @param Sourcedir字符串
* @param Destdir字符串
* @return布爾
*/
public boolean copydir（字符串sourcedir，字符串destdir）{
文件sourcefile = new File（sourcedir）;
字符串tempsource;
字符串tempdest;
字符串文件名;
file [] files = sourcefile.listfiles（）;
for（int i = 0; i <files.length; i ++）{
filename = files [i] .getName（）;
tempsource = sourcedir +“/” +文件名;
tempdest = destdir +“/” +文件名;
如果（文件[i] .file（））{
copytofile（tempsource，tempdest）;
} 別的 {
COPPERDIR（Tempsource，Tempdest）;
}
}
sourceFile = null;
返回true;
}
/**
*刪除指定目錄及其中的所有內容。
* @param dir要刪除的目錄
* @return刪除成功時返回
*/
public boolean deetedirectory（file dir）{
文件[]條目= dir.listfiles（）;
int sz = entries.length;
for（int i = 0; i <sz; i ++）{
if（entries [i] .isdirectory（））{
if（！deletedirectory（entries [i]））{
返回false;
}
} 別的 {
如果（！entries [i] .delete（））{
返回false;
}
}
}
如果（！dir.delete（））{
返回false;
}
返回true;
}
/**
*文件存在檢查
*
* @param sfilename文件名
* @return boolean true-存在<br>
*錯誤 - 不存在
*/
public static boolean checkexist（string sfileName）{
布爾結果= false;
嘗試 {
文件f =新文件（sfilename）;
// if（f.exists（）&& f.isfile（）&& f.canread（））{
if（f.exists（）&& f.isfile（））{
結果= true;
} 別的 {
結果= false;
}
} catch（異常E）{
結果= false;
}
/* 返回 */
返回結果；
}
/**
*獲取文件大小
*
* @param sfilename文件名
* @return long文件的大小（字節）當文件不存在時返回-1
*/
公共靜態長getize（字符串sfileName）{
長LSize = 0;
嘗試 {
文件f =新文件（sfilename）;
//存在
如果（f.exists（））{
if（f.Isfile（）&& f.canread（））{
lsize = f.length（）;
} 別的 {
lsize = -1;
}
//不存在
} 別的 {
lsize = 0;
}
} catch（異常E）{
lsize = -1;
}
/* 返回 */
返回lsize;
}
/**
*文件刪除
*
* @param sfilename文件nmae
* @return boolean true-刪除成功<br>
* false-刪除失敗
*/
public static boolean deletefromname（string sfileName）{
布萊恩·布雷特恩= true;
嘗試 {
文件ofile =新文件（sfileName）;
//存在
如果（ofile.exists（））{
//刪除文件
boolean bresult = ofile.delete（）;
//刪除失敗
如果（bresult == false）{
breturn = false;
}
//不存在
} 別的 {
}
} catch（異常E）{
breturn = false;
}
//返回
返回布雷特恩；
}
/**
*文件解壓縮
*
* @param stopath unzip目錄路徑
* @param szipfile unzip文件名
*/
@suppresswarnings（“ rawtypes”）
公共靜態void Releasezip（String stopath，string szipfile）拋出異常{
if（null == stopath ||（“”）。equals（stopath.trim（）））{
文件objzipfile =新文件（szipfile）;
stopath = objzipfile.getParent（）;
}
Zipfile Zfile =新Zipfile（szipfile）;
枚舉zlist = zfile.entries（）;
zipentry ze = null;
字節[] buf = new Byte [1024];
while（zlist.hasmoreelements（））{
ze =（zipentry）zlist.nextlement（）;
如果（ze.isdirectory（））{
繼續;
}
outputStream OS =
新的bufferedOutputstream（
new FileOutputStream（getRealFilename（stopath，ze.getName（）））;
InputStream IS =新的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基於根目錄
* @param absfileName絕對目錄文件名
* @return java.io.file返回文件
*/
@suppresswarnings（{“ rawTypes”，“ unconted”}）
私有靜態文件getRealFilename（基於字符串，字符串absfileName）引發異常{
文件ret = null;
列表dirs = new ArrayList（）;
StringTokenizer st = new StringTokenizer（absfileName，system.getProperty（“ file.separator”））;
而（St.Hasmoretokens（））{
dirs.add（st.nexttoken（））;
}
ret = new File（基於）;
if（dirs.size（）> 1）{
for（int i = 0; i <dirs.size（） - 1; i ++）{
ret = new文件（ret，（string）dirs.get（i））;
}
}
如果（！ret.exists（））{
ret.mkdirs（）;
}
ret = new文件（ret，（string）dirs.get（dirs.size（） - 1））;
返回ret;
}
/**
* COPYFILE
*
* @param srcfile源文件
* @Param TargetFile目標文件
*/
@suppresswarnings（“資源”）
靜態public void copyfile（字符串srcfile，字符串targetFile）拋出ioexception
{
FileInputStream reader = new FileInputStream（srcfile）;
FileOutputStream writer = new FileOutputStream（targetFile）;
字節[] buffer = new Byte [4096];
int len;
嘗試
{
Reader = new FileInputStream（srcfile）;
writer = new FileOutputStream（targetFile）;
while（（len = reader.read（buffer））> 0）
{
Writer.Write（Buffer，0，Len）;
}
}
捕獲（ioexception e）
{
扔e;
}
最後
{
如果（writer！= null）writer.close（）;
如果（讀取器！= null）reader.close（）;
}
}
/**
* Renamefile
*
* @param srcfile源文件
* @Param TargetFile目標文件
*/
靜態public void renamefile（字符串srcfile，字符串targetFile）拋出ioexception
{
嘗試 {
CopyFile（Srcfile，TargetFile）;
deletefromname（srcfile）;
} catch（ioexception e）{
扔e;
}
}
public static void寫入（字符串tivolimsg，字符串logfileName）{
嘗試{
byte [] bmsg = tivolimsg.getBytes（）;
FileOutputStream fout = new FileOutputStream（LogFileName，true）;
fout.write（bmsg）;
fout.close（）;
} catch（ioexception e）{
//放置例外
}
}
/**
*此方法用於使用時間戳，錯誤代碼和方法詳細信息記錄消息
* @param errorcd字符串
* @param className字符串
* @param MethodName字符串
* @param msg字符串
*/
public static void writelog（字符串logfile，string batchid，string exceptioninfo）{
dateFormat df = dateFormat.getDateTimeInstance（dateformat.default，dateformat.default，locale.japanese）;
對象args [] = {df.format（new Date（）），batchID，excebionInfo};
字符串fmtmsg = messageFormat.format（“ {0}：{1}：{2}”，args）;
嘗試 {
文件logFile = new File（logFile）;
如果（！logfile.exists（））{
logfile.createnewfile（）;
}
FileWriter fw = new FileWriter（logFile，true）;
fw.write（fmtmsg）;
fw.write（system.getProperty（“ line.separator”））;
fw.flush（）;
fw.close（）;
} catch（異常E）{
}
}
公共靜態字符串readTextfile（字符串realpath）拋出異常{
文件file = new File（realPath）;
如果（！file.exists（））{
system.out.println（“不存在文件！”）;
返回null;
}
BufferedReader br = new BufferedReader（new InputStreamReader（new FileInputStream（realPath），“ UTF-8”））;
字符串temp =“”;
字符串txt =“”;
while（（temp = br.readline（））！= null）{
txt+= temp;
}
br.close（）;
返回txt;
}
}