复制代码代码如下:
Importer java.io.BufferedInputStream;
Importer java.io.BufferedOutputStream;
Importer java.io.bufferedReader;
Importer java.io.file;
import java.io.fileInputStream;
import java.io.filenotfoundException;
Importer java.io.fileOutputStream;
import java.io.filewriter;
Importer java.io.ioException;
import java.io.inputStream;
Importer java.io.inputStreamReader;
import java.io.outputStream;
import java.text.dateformat;
import java.text.messageFormat;
import java.util.arraylist;
Importer java.util.date;
Importer Java.util.Enumeration;
Importer java.util.list;
import java.util.locale;
import java.util.stringtokenizer;
Importer java.util.zip.zipentry;
import java.util.zip.zipfile;
/ **
*
* @author ibm
*
* /
classe publique FileUtil {
String statique public dirSplit = "//"; // Windows Linux
/ **
* Enregistrer le fichier Acroding to Physical Directory Information
*
* @param physiquedir
* Répertoire physique
* @param fname
* Nom du fichier de la destination
* @param iStream
* flux d'entrée du fichier de destination
* @retour
* /
public static booléen SaveFileByphysicaldir (String PhysicalPath,
InputStream iStream) {
booléen drapeau = false;
essayer {
OutputStream OS = new FileOutputStream (PhysicalPath);
int readBytes = 0;
tampon d'octet [] = nouveau octet [8192];
while ((readBytes = isttream.read (tampon, 0, 8192))! = -1) {
OS.Write (Buffer, 0, ReadBytes);
}
os.close ();
Flag = true;
} catch (filenotfoundException e) {
e.printStackTrace ();
} catch (ioexception e) {
e.printStackTrace ();
}
drapeau de retour;
}
public static booléen crééirectory (string dir) {
Fichier f = nouveau fichier (dir);
if (! f.exists ()) {
f.mkDirs ();
}
Retour Vrai;
}
public static void SaveAsFileOutputStream (String PhysicalPath, String Content) {
Fichier fichier = nouveau fichier (physique);
booléen b = file.getParentFile (). IsDirectory ();
if (! b) {
File tem = new File (file.getParent ());
// tem.getParentFile (). setWitable (true);
Tem.mkDirs (); // 创建目录
}
//Log.info(file.getParent () + ";" + file.getParentFile (). IsDirectory ());
FileoutputStream foutput = null;
essayer {
foutput = new FileOutputStream (PhysicalPath);
foutput.write (content.getBytes ("utf-8"));
//foutput.write (content.getBytes ());
} catch (ioException ex) {
ex.printStackTrace ();
lancer un nouveau RuntimeException (ex);
}enfin{
essayer {
foutput.flush ();
foutput.close ();
} catch (ioException ex) {
ex.printStackTrace ();
lancer un nouveau RuntimeException (ex);
}
}
//Log.info ("文件保存成功:" + PhysicalPath);
}
/ **
* Copier 文件
* @param srcfile String
* @Param Desfile String
* @return boolean
* /
public boolean copyTofile (String srcfile, String Desfile) {
File scrfile = nouveau fichier (srcfile);
if (scrfile.isfile () == true) {
longueur int;
FileInputStream fis = null;
essayer {
fis = new FileInputStream (scrfile);
}
catch (filenotfoundException ex) {
ex.printStackTrace ();
}
Fichier DesFile = nouveau fichier (DesFile);
FileoutputStream fos = null;
essayer {
fos = new FileOutputStream (Desfile, false);
}
catch (filenotfoundException ex) {
ex.printStackTrace ();
}
Desfile = null;
length = (int) scrfile.length ();
octet [] b = nouveau octet [longueur];
essayer {
fis.read (b);
fis.close ();
fos.write (b);
fos.close ();
}
catch (ioexception e) {
e.printStackTrace ();
}
} autre {
scrfile = null;
retourne false;
}
scrfile = null;
Retour Vrai;
}
/ **
* Copier 文件夹
* @param Sourcedir String
* @param destdir String
* @return boolean
* /
public boolean copydir (String Sourcedir, String destdir) {
Fichier sourcefile = nouveau fichier (Sourcedir);
String tempsource;
String tempdest;
String File Name;
File [] files = sourcefile.listFiles ();
for (int i = 0; i <files.length; i ++) {
filename = files [i] .getName ();
tempsource = Sourcedir + "/" + nom de fichier;
tempdest = destdir + "/" + nom de fichier;
if (fichiers [i] .isfile ()) {
CopyTofile (Tempsource, TempDest);
} autre {
CopyDir (Tempsource, TempDest);
}
}
SourceFile = null;
Retour Vrai;
}
/ **
* 删除指定目录及其中的所有内容。
* @param dir 要删除的目录
* @return 删除成功时返回 true ， 否则返回 false。
* /
public boolean DeleteDirectory (fichier dir) {
File [] entrées = dir.listFiles ();
int sz = entrées.length;
pour (int i = 0; i <sz; i ++) {
if (entrées [i] .isDirectory ()) {
if (! DeleteDirectory (entrées [i])) {
retourne false;
}
} autre {
if (! Entrées [i] .delete ()) {
retourne false;
}
}
}
if (! dir.delete ()) {
retourne false;
}
Retour Vrai;
}
/ **
* Fichier existant chèque
*
* @param sfilename nom du fichier
* @return booléen true - exister <br>
* Faux - ne pas exister
* /
public static booléen CheckExist (String sFileName) {
Résultat booléen = false;
essayer {
Fichier f = nouveau fichier (sFileName);
// if (f.exists () && f.isfile () && f.canread ()) {
if (f.exists () && f.isfile ()) {
résultat = true;
} autre {
résultat = false;
}
} catch (exception e) {
résultat = false;
}
/* retour */
Résultat de retour;
}
/ **
* Obtenez la taille du fichier
*
* @param sfilename nom du fichier
* Taille du fichier long @return (octet) lorsque le fichier n'existe pas renvoyer -1
* /
public static long getSize (String sFileName) {
long lSize = 0;
essayer {
Fichier f = nouveau fichier (sFileName);
//exister
if (f.exists ()) {
if (f.isfile () && f.canread ()) {
lsize = f.length ();
} autre {
lsize = -1;
}
// n'existe pas
} autre {
lSize = 0;
}
} catch (exception e) {
lsize = -1;
}
/* retour */
retourner lsize;
}
/ **
* Fichier Supprimer
*
* @param sfilename fichier nmae
* @return boolean true - supprimer le succès <br>
* false - supprimer l'échec
* /
public static boolean DeleteFromName (String sFileName) {
Boolean Breturn = true;
essayer {
Fichier ofile = nouveau fichier (sFileName);
//exister
if (ofile.exists ()) {
// Supprimer le fichier
Boolean Bresult = odile.delete ();
// Supprimer l'échec
if (Bresult == false) {
Breturn = false;
}
// n'existe pas
} autre {
}
} catch (exception e) {
Breturn = false;
}
//retour
retour Breturn;
}
/ **
* Fichier dézip
*
* @Param Stopath Unzip Directory Chemin
* @param szipfile Unzip Nom du fichier
* /
@SuppressWarnings ("RawTypes")
public static void releasezip (String stopath, String szipfile) lève l'exception {
if (null == stopath || (""). equals (stopath.trim ())) {
Fichier objzipfile = nouveau fichier (szipfile);
stopath = objzipfile.getparent ();
}
Zipfile zfile = nouveau zipfile (szipfile);
Énumération zlist = zfile.entries ();
Zipentry ze = null;
octet [] buf = nouveau octet [1024];
while (zList.hasmoreElements ()) {
ze = (zipentry) zList.Nexttelement ();
if (ze.isdirectory ()) {
continuer;
}
OUTSTRETREAM OS =
Nouveau tampon de tampon (
Nouveau fileOutputStream (getRealFileName (stopath, ze.getName ())));
InputStream est = 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 Nom du fichier du répertoire absolu
* @return java.io.file Fichier de retour
* /
@SuppressWarnings ({"RawTypes", "Unchecked"})
Fichier statique privé getRealFileName (String Basedir, String AbsFileName) lève l'exception {
Fichier ret = null;
List dirrs = new ArrayList ();
StringTokenizer st = new StringTokenizer (ABSFILENAME, System.getProperty ("file.separator"));
tandis que (St.Hasmoretokens ()) {
dirs.add (St.NextToken ());
}
ret = nouveau fichier (basé basé);
if (dirs.size ()> 1) {
pour (int i = 0; i <dirs.size () - 1; i ++) {
ret = nouveau fichier (ret, (string) dirs.get (i));
}
}
if (! ret.exists ()) {
ret.mkDirs ();
}
ret = new File (ret, (string) dirs.get (dirs.size () - 1));
return ret;
}
/ **
* CopyFile
*
* Fichier source @param srcfile
* Fichier cible @param TargetFile
* /
@SuppressWarnings ("Resource")
STATIC PUBLIC VOID COPYFILE (String Srcfile, String TargetFile) lève IOException
{
FileInputStream Reader = new FileInputStream (srcfile);
FileOutputStream Writer = new FileOutputStream (TargetFile);
octet [] tampon = nouveau octet [4096];
int len;
essayer
{
Reader = new FileInputStream (srcfile);
writer = new FileOutputStream (TargetFile);
while ((Len = reader.read (tampon))> 0)
{
écrivain.write (Buffer, 0, Len);
}
}
Catch (ioexception e)
{
jeter e;
}
enfin
{
if (writer! = null) writer.close ();
if (Reader! = null) Reader.close ();
}
}
/ **
* Renamefile
*
* Fichier source @param srcfile
* Fichier cible @param TargetFile
* /
STATIC PUBLIC VOID RENAMEFILE (String Srcfile, String TargetFile) lève IOException
{
essayer {
CopyFile (Srcfile, TargetFile);
DeleteFromName (srcfile);
} catch (ioexception e) {
jeter e;
}
}
public static void write (String Tivolimsg, String logFileName) {
essayer{
octet [] bmsg = Tivolimsg.getBytes ();
FileOutputStream fout = new FileOutputStream (logFileName, true);
fout.write (bmsg);
fout.close ();
} catch (ioexception e) {
// lance l'exception
}
}
/ **
* Cette méthode est utilisée pour enregistrer les messages avec l'horodatage, le code d'erreur et les détails de la méthode
* chaîne @param errorcd
* @param className String
* @param MethodName String
* String msg @param
* /
public static void writeLog (String logfile, String BatchId, String exceptionInfo) {
DATEFORMAT DF = DATEFORMAT.GetDateTimeInstance (DateFormat.default, DateFormat.Default, Locale.Japanais);
Objet args [] = {df.format (new Date ()), BatchId, exceptionInfo};
String fmtmsg = messageFormat.format ("{0}: {1}: {2}", args);
essayer {
Fichier logfile = nouveau fichier (logfile);
if (! logfile.exists ()) {
logfile.CreateEnewFile ();
}
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) lève l'exception {
Fichier file = nouveau fichier (realPath);
if (! file.exists ()) {
System.out.println ("Fichier n'existe pas!");
retourner 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 ();
retour txt;
}
}