复制代码代码如下：
导入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;
}
}