java辅助文件_java文件处理工具类详解

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileFilter;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.ObjectInputStream;

import java.io.ObjectOutput;

import java.io.ObjectOutputStream;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.io.Writer;

import java.net.URL;

import java.net.URLEncoder;

import java.text.DecimalFormat;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Enumeration;

import java.util.List;

import java.util.Properties;

import javax.servlet.ServletOutputStream;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

public class FileUtil

{

private static Log logger = LogFactory.getLog(FileUtil.class);

public static void writeFile(String paramString1, String paramString2)

{

writeFile(paramString1, paramString2, "utf-8");

}

public static void writeFile(String paramString1, String paramString2, String paramString3)

{

try

{

createFolder(paramString1, true);

BufferedWriter localBufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(paramString1), paramString3));

localBufferedWriter.write(paramString2);

localBufferedWriter.close();

}

catch (IOException localIOException)

{

localIOException.printStackTrace();

}

}

public static void writeFile(String paramString, InputStream paramInputStream)

throws IOException

{

FileOutputStream localFileOutputStream = new FileOutputStream(paramString);

byte[] arrayOfByte = new byte['Ȁ'];

int i = 0;

while ((i = paramInputStream.read(arrayOfByte)) != -1) {

localFileOutputStream.write(arrayOfByte, 0, i);

}

paramInputStream.close();

localFileOutputStream.close();

}

public static String readFile(String paramString)

throws IOException

{

try

{

File localFile = new File(paramString);

String str1 = getCharset(localFile);

StringBuffer localStringBuffer = new StringBuffer();

BufferedReader localBufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(paramString), str1));

String str2;

while ((str2 = localBufferedReader.readLine()) != null) {

localStringBuffer.append(str2 + "\r\n");

}

localBufferedReader.close();

return localStringBuffer.toString();

}

catch (IOException localIOException)

{

throw localIOException;

}

}

public static boolean isExistFile(String paramString)

{

boolean bool = false;

File localFile = new File(paramString);

if (localFile.isDirectory())

{

File[] arrayOfFile = localFile.listFiles();

if ((arrayOfFile != null) && (arrayOfFile.length != 0)) {

bool = true;

}

}

return bool;

}

public static String getCharset(File paramFile)

{

String str = "GBK";

byte[] arrayOfByte = new byte[3];

try

{

int i = 0;

BufferedInputStream localBufferedInputStream = new BufferedInputStream(new FileInputStream(paramFile));

localBufferedInputStream.mark(0);

int j = localBufferedInputStream.read(arrayOfByte, 0, 3);

if (j == -1) {

return str;

}

if ((arrayOfByte[0] == -1) && (arrayOfByte[1] == -2))

{

str = "UTF-16LE";

i = 1;

}

else if ((arrayOfByte[0] == -2) && (arrayOfByte[1] == -1))

{

str = "UTF-16BE";

i = 1;

}

else if ((arrayOfByte[0] == -17) && (arrayOfByte[1] == -69) && (arrayOfByte[2] == -65))

{

str = "UTF-8";

i = 1;

}

localBufferedInputStream.reset();

if (i == 0)

{

int k = 0;

while ((j = localBufferedInputStream.read()) != -1)

{

k++;

if ((j < 240) && ((128 > j) || (j > 191))) {

if ((192 <= j) && (j <= 223))

{

j = localBufferedInputStream.read();

if (128 > j) {

break;

}

if (j > 191) {

break;

}

}

else if ((224 <= j) && (j <= 239))

{

j = localBufferedInputStream.read();

if ((128 <= j) && (j <= 191))

{

j = localBufferedInputStream.read();

if ((128 <= j) && (j <= 191)) {

str = "UTF-8";

}

}

}

}

}

}

localBufferedInputStream.close();

}

catch (Exception localException)

{

localException.printStackTrace();

}

return str;

}

public static byte[] readByte(InputStream paramInputStream)

{

try

{

byte[] arrayOfByte = new byte[paramInputStream.available()];

paramInputStream.read(arrayOfByte);

return arrayOfByte;

}

catch (FileNotFoundException localFileNotFoundException)

{

logger.error("文件路径不存在：" + localFileNotFoundException.getMessage());

}

catch (Exception localException)

{

localException.printStackTrace();

}

return null;

}

public static byte[] readByte(String paramString)

{

try

{

FileInputStream localFileInputStream = new FileInputStream(paramString);

byte[] arrayOfByte = new byte[localFileInputStream.available()];

localFileInputStream.read(arrayOfByte);

localFileInputStream.close();

return arrayOfByte;

}

catch (FileNotFoundException localFileNotFoundException)

{

logger.error("文件路径不存在：" + paramString);

}

catch (Exception localException)

{

localException.printStackTrace();

}

return null;

}

public static boolean writeByte(String paramString, byte[] paramArrayOfByte)

{

try

{

BufferedOutputStream localBufferedOutputStream = new BufferedOutputStream(new FileOutputStream(paramString));

localBufferedOutputStream.write(paramArrayOfByte);

localBufferedOutputStream.close();

return true;

}

catch (Exception localException)

{

localException.printStackTrace();

}

return false;

}

public static boolean deleteDir(File paramFile)

{

if (paramFile.isDirectory())

{

String[] arrayOfString = paramFile.list();

for (int i = 0; i < arrayOfString.length; i++)

{

boolean bool = deleteDir(new File(paramFile, arrayOfString[i]));

if (!bool) {

return false;

}

}

}

return paramFile.delete();

}

public static void serializeToFile(Object paramObject, String paramString)

{

try

{

ObjectOutputStream localObjectOutputStream = new ObjectOutputStream(new FileOutputStream(paramString));

localObjectOutputStream.writeObject(paramObject);

localObjectOutputStream.close();

}

catch (IOException localIOException)

{

localIOException.printStackTrace();

}

}

public static Object deserializeFromFile(String paramString)

{

try

{

File localFile = new File(paramString);

ObjectInputStream localObjectInputStream = new ObjectInputStream(new FileInputStream(localFile));

Object localObject = localObjectInputStream.readObject();

localObjectInputStream.close();

return localObject;

}

catch (Exception localException)

{

localException.printStackTrace();

}

return null;

}

public static String inputStream2String(InputStream paramInputStream, String paramString)

throws IOException

{

BufferedReader localBufferedReader = new BufferedReader(new InputStreamReader(paramInputStream, paramString));

StringBuffer localStringBuffer = new StringBuffer();

String str = "";

while ((str = localBufferedReader.readLine()) != null) {

localStringBuffer.append(str + "\n");

}

return localStringBuffer.toString();

}

public static String inputStream2String(InputStream paramInputStream)

throws IOException

{

return inputStream2String(paramInputStream, "utf-8");

}

public static File[] getFiles(String paramString)

{

File localFile = new File(paramString);

return localFile.listFiles();

}

public static void createFolderFile(String paramString)

{

createFolder(paramString, true);

}

public static void createFolder(String paramString, boolean paramBoolean)

{

if (paramBoolean) {

paramString = paramString.substring(0, paramString.lastIndexOf(File.separator));

}

File localFile = new File(paramString);

if (!localFile.exists()) {

localFile.mkdirs();

}

}

public static void createFolder(String paramString1, String paramString2)

{

paramString1 = StringUtil.trimSufffix(paramString1, File.separator) + File.separator + paramString2;

File localFile = new File(paramString1);

localFile.mkdir();

}

public static void renameFolder(String paramString1, String paramString2)

{

File localFile = new File(paramString1);

if (localFile.exists()) {

localFile.renameTo(new File(paramString2));

}

}

public static ArrayList getDiretoryOnly(File paramFile)

{

ArrayList localArrayList = new ArrayList();

if ((paramFile != null) && (paramFile.exists()) && (paramFile.isDirectory()))

{

File[] arrayOfFile = paramFile.listFiles(new FileFilter()

{

public boolean accept(File paramAnonymousFile)

{

return paramAnonymousFile.isDirectory();

}

});

for (int i = 0; i < arrayOfFile.length; i++) {

localArrayList.add(arrayOfFile[i]);

}

}

return localArrayList;

}

public ArrayList getFileOnly(File paramFile)

{

ArrayList localArrayList = new ArrayList();

File[] arrayOfFile = paramFile.listFiles(new FileFilter()

{

public boolean accept(File paramAnonymousFile)

{

return paramAnonymousFile.isFile();

}

});

for (int i = 0; i < arrayOfFile.length; i++) {

localArrayList.add(arrayOfFile[i]);

}

return localArrayList;

}

public static boolean deleteFile(String paramString)

{

File localFile = new File(paramString);

return localFile.delete();

}

public static boolean copyFile(String paramString1, String paramString2)

{

File localFile1 = new File(paramString1);

File localFile2 = new File(paramString2);

FileInputStream localFileInputStream = null;

FileOutputStream localFileOutputStream = null;

try

{

localFileInputStream = new FileInputStream(localFile1);

localFileOutputStream = new FileOutputStream(localFile2);

byte[] arrayOfByte = new byte['က'];

int i;

while ((i = localFileInputStream.read(arrayOfByte)) != -1) {

localFileOutputStream.write(arrayOfByte, 0, i);

}

localFileOutputStream.flush();

localFileOutputStream.close();

localFileInputStream.close();

}

catch (IOException localIOException)

{

localIOException.printStackTrace();

return false;

}

return true;

}

public static void backupFile(String paramString)

{

String str = paramString + ".bak";

File localFile = new File(str);

if (localFile.exists()) {

localFile.delete();

}

copyFile(paramString, str);

}

public static String getFileExt(File paramFile)

{

if (paramFile.isFile()) {

return getFileExt(paramFile.getName());

}

return "";

}

public static String getFileExt(String paramString)

{

int i = paramString.lastIndexOf(".");

if (i > -1) {

return paramString.substring(i + 1).toLowerCase();

}

return "";

}

public static void copyDir(String paramString1, String paramString2)

throws IOException

{

new File(paramString2).mkdirs();

File[] arrayOfFile = new File(paramString1).listFiles();

for (int i = 0; i < arrayOfFile.length; i++)

{

if (arrayOfFile[i].isFile())

{

String str1 = arrayOfFile[i].getAbsolutePath();

String str2 = paramString2 + "/" + arrayOfFile[i].getName();

copyFile(str1, str2);

}

if (arrayOfFile[i].isDirectory()) {

copyDirectiory(paramString1 + "/" + arrayOfFile[i].getName(), paramString2 + "/" + arrayOfFile[i].getName());

}

}

}

private static void copyDirectiory(String paramString1, String paramString2)

throws IOException

{

new File(paramString2).mkdirs();

File[] arrayOfFile = new File(paramString1).listFiles();

for (int i = 0; i < arrayOfFile.length; i++)

{

if (arrayOfFile[i].isFile())

{

String str1 = arrayOfFile[i].getAbsolutePath();

String str2 = paramString2 + "/" + arrayOfFile[i].getName();

copyFile(str1, str2);

}

if (arrayOfFile[i].isDirectory()) {

copyDirectiory(paramString1 + "/" + arrayOfFile[i].getName(), paramString2 + "/" + arrayOfFile[i].getName());

}

}

}

public static String getFileSize(File paramFile)

throws IOException

{

if (paramFile.isFile())

{

FileInputStream localFileInputStream = new FileInputStream(paramFile);

int i = localFileInputStream.available();

localFileInputStream.close();

return getSize(i);

}

return "";

}

public static String getSize(double paramDouble)

{

DecimalFormat localDecimalFormat = new DecimalFormat("0.00");

double d;

if (paramDouble > 1048576.0D)

{

d = paramDouble / 1048576.0D;

return localDecimalFormat.format(d) + " M";

}

if (paramDouble > 1024.0D)

{

d = paramDouble / 1024.0D;

return localDecimalFormat.format(d) + " KB";

}

return paramDouble + " bytes";

}

public static void downLoadFile(HttpServletRequest paramHttpServletRequest, HttpServletResponse paramHttpServletResponse, String paramString1, String paramString2)

throws IOException

{

ServletOutputStream localServletOutputStream = paramHttpServletResponse.getOutputStream();

File localFile = new File(paramString1);

if (localFile.exists())

{

paramHttpServletResponse.setContentType("APPLICATION/OCTET-STREAM");

String str1 = getFileExt(paramString1);

if ((!Validation.isEmpty(str1)) && (str1.toLowerCase().equals("apk"))) {

paramHttpServletResponse.setContentType("application/vnd.android.package-archive");

}

String str2 = paramString2;

String str3 = paramHttpServletRequest.getHeader("USER-AGENT");

if ((str3 != null) && (str3.indexOf("MSIE") == -1))

{

try

{

String localObject1 = transCharacter(paramHttpServletRequest, str2);

paramHttpServletResponse.setHeader("Content-Disposition", "attachment; filename=" + (String)localObject1);

}

catch (Exception localException1)

{

localException1.printStackTrace();

}

}

else

{

str2 = URLEncoder.encode(str2, "utf-8");

paramHttpServletResponse.addHeader("Content-Disposition", "attachment;filename=" + str2);

}

Object localObject1 = null;

try

{

localServletOutputStream = paramHttpServletResponse.getOutputStream();

localObject1 = new FileInputStream(paramString1);

byte[] arrayOfByte = new byte['Ѐ'];

int i = 0;

while ((i = ((FileInputStream)localObject1).read(arrayOfByte)) > 0) {

localServletOutputStream.write(arrayOfByte, 0, i);

}

localServletOutputStream.flush();

}

catch (Exception localException2)

{

localException2.printStackTrace();

}

finally

{

if (localObject1 != null)

{

((FileInputStream)localObject1).close();

localObject1 = null;

}

if (localServletOutputStream != null)

{

localServletOutputStream.close();

localServletOutputStream = null;

paramHttpServletResponse.flushBuffer();

}

}

}

else

{

localServletOutputStream.write("文件不存在!".getBytes("utf-8"));

}

}

private static String transCharacter(HttpServletRequest paramHttpServletRequest, String paramString)

throws Exception

{

if (paramHttpServletRequest.getHeader("USER-AGENT").toLowerCase().indexOf("msie") > 0) {

return URLEncoder.encode(paramString, "UTF-8");

}

if (paramHttpServletRequest.getHeader("USER-AGENT").toLowerCase().indexOf("firefox") > 0) {

return new String(paramString.getBytes("UTF-8"), "ISO8859-1");

}

return new String(paramString.getBytes("gbk"), "ISO8859-1");

}

public static String getParentDir(String paramString1, String paramString2)

{

File localFile = new File(paramString2);

String str1 = localFile.getParent();

String str2 = str1.replace(paramString1, "");

return str2.replace(File.separator, "/");

}

public static String getClassesPath()

{

String str = StringUtil.trimSufffix(AppUtil.getRealPath("/"), File.separator) + "\\WEB-INF\\classes\\".replace("\\", File.separator);

return str;

}

public static String getRootPath()

{

String str = StringUtil.trimSufffix(AppUtil.getRealPath("/"), File.separator) + File.separator;

return str;

}

public static String readFromProperties(String paramString1, String paramString2)

{

String str1 = "";

BufferedInputStream localBufferedInputStream = null;

try

{

localBufferedInputStream = new BufferedInputStream(new FileInputStream(paramString1));

Properties localProperties = new Properties();

localProperties.load(localBufferedInputStream);

str1 = localProperties.getProperty(paramString2);

String str2 = str1;

return str2;

}

catch (Exception localException)

{

localException.printStackTrace();

}

finally

{

if (localBufferedInputStream != null) {

try

{

localBufferedInputStream.close();

}

catch (IOException localIOException3)

{

localIOException3.printStackTrace();

}

}

}

return str1;

}

public static boolean saveProperties(String paramString1, String paramString2, String paramString3)

{

StringBuffer localStringBuffer = new StringBuffer();

int i = 0;

BufferedReader localBufferedReader = null;

try

{

localBufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(paramString1), "utf-8"));

String str;

while ((str = localBufferedReader.readLine()) != null) {

if (str.startsWith(paramString2))

{

localStringBuffer.append(paramString2 + "=" + paramString3 + "\r\n");

i = 1;

}

else

{

localStringBuffer.append(str + "\r\n");

}

}

if (i == 0) {

localStringBuffer.append(paramString2 + "=" + paramString3 + "\r\n");

}

writeFile(paramString1, localStringBuffer.toString(), "utf-8");

boolean bool1 = true;

return bool1;

}

catch (Exception localException)

{

localException.printStackTrace();

boolean bool2 = false;

return bool2;

}

finally

{

if (localBufferedReader != null) {

try

{

localBufferedReader.close();

}

catch (IOException localIOException3)

{

localIOException3.printStackTrace();

}

}

}

}

public static boolean delProperties(String paramString1, String paramString2)

{

StringBuffer localStringBuffer = new StringBuffer();

BufferedReader localBufferedReader = null;

try

{

localBufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(paramString1), "utf-8"));

String str;

while ((str = localBufferedReader.readLine()) != null) {

if (!str.startsWith(paramString2)) {

localStringBuffer.append(str + "\r\n");

}

}

writeFile(paramString1, localStringBuffer.toString(), "utf-8");

boolean bool1 = true;

return bool1;

}

catch (Exception localException)

{

localException.printStackTrace();

boolean bool2 = false;

return bool2;

}

finally

{

if (localBufferedReader != null) {

try

{

localBufferedReader.close();

}

catch (IOException localIOException3)

{

localIOException3.printStackTrace();

}

}

}

}

public static List> getAllClassesByInterface(Class> paramClass, boolean paramBoolean)

throws IOException, ClassNotFoundException, IllegalStateException

{

if (!paramClass.isInterface()) {

throw new IllegalStateException("Class not a interface.");

}

ClassLoader localClassLoader = paramClass.getClassLoader();

String str = paramBoolean ? paramClass.getPackage().getName() : "/";

return findClasses(paramClass, localClassLoader, str);

}

private static List> findClasses(Class> paramClass, ClassLoader paramClassLoader, String paramString)

throws IOException, ClassNotFoundException

{

ArrayList localArrayList = new ArrayList();

String str = paramString.replace(".", "/");

Object localObject;

if (!str.equals("/"))

{

localObject = paramClassLoader.getResources(str);

while (((Enumeration)localObject).hasMoreElements())

{

URL localURL = (URL)((Enumeration)localObject).nextElement();

localArrayList.addAll(findResources(paramClass, new File(localURL.getFile()), paramString));

}

}

else

{

localObject = paramClassLoader.getResource("").getPath();

localArrayList.addAll(findResources(paramClass, new File((String)localObject), paramString));

}

return localArrayList;

}

private static List> findResources(Class> paramClass, File paramFile, String paramString)

throws ClassNotFoundException

{

ArrayList localArrayList = new ArrayList();

if (!paramFile.exists()) {

return Collections.EMPTY_LIST;

}

File[] arrayOfFile1 = paramFile.listFiles();

for (File localFile : arrayOfFile1) {

if (localFile.isDirectory())

{

if (!localFile.getName().contains(".")) {

if (!paramString.equals("/")) {

localArrayList.addAll(findResources(paramClass, localFile, paramString + "." + localFile.getName()));

} else {

localArrayList.addAll(findResources(paramClass, localFile, localFile.getName()));

}

}

}

else if (localFile.getName().endsWith(".class"))

{

Class localClass = null;

if (!paramString.equals("/")) {

localClass = Class.forName(paramString + "." + localFile.getName().substring(0, localFile.getName().length() - 6));

} else {

localClass = Class.forName(localFile.getName().substring(0, localFile.getName().length() - 6));

}

if ((paramClass.isAssignableFrom(localClass)) && (!paramClass.equals(localClass))) {

localArrayList.add(localClass);

}

}

}

return localArrayList;

}

public static Object cloneObject(Object paramObject)

throws Exception

{

ByteArrayOutputStream localByteArrayOutputStream = new ByteArrayOutputStream();

ObjectOutputStream localObjectOutputStream = new ObjectOutputStream(localByteArrayOutputStream);

localObjectOutputStream.writeObject(paramObject);

ByteArrayInputStream localByteArrayInputStream = new ByteArrayInputStream(localByteArrayOutputStream.toByteArray());

ObjectInputStream localObjectInputStream = new ObjectInputStream(localByteArrayInputStream);

return localObjectInputStream.readObject();

}

public static boolean isFileType(String paramString1, String paramString2)

{

boolean bool = false;

if (("IMAGE".equals(paramString2)) && ((paramString1.toUpperCase().equals("JPG")) || (paramString1.toUpperCase().equals("PNG")) || (paramString1.toUpperCase().equals("GIF")) || (paramString1.toUpperCase().equals("JPEG")))) {

bool = true;

}

return bool;

}

public static boolean isFileType(String paramString, String[] paramArrayOfString)

{

boolean bool = false;

if ((paramArrayOfString != null) && (paramArrayOfString.length > 0)) {

for (int i = 0; i < paramArrayOfString.length; i++) {

if (paramString.toUpperCase().equals(paramArrayOfString[i].toUpperCase())) {

return true;

}

}

}

return bool;

}

public static boolean isErrorFileType(String paramString)

{

String[] arrayOfString = null;

String str = AppConfigUtil.get("File_Filter_Val");

if ((AppConfigUtil.getICache("FILEFILTER_KEY") == null) && (str != null))

{

arrayOfString = str.split("\\|");

AppConfigUtil.setICache("FILEFILTER_KEY", arrayOfString);

}

else

{

arrayOfString = (String[])AppConfigUtil.getICache("FILEFILTER_KEY");

}

return isFileType(paramString, arrayOfString);

}

}