Java File工具类附带MYSQL SQL转HSQL SQL字符串处理

小乔

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.MalformedURLException;
import java.net.URL;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.List;
import java.util.Random;
import java.util.Vector;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;
/**
*
* 文件操作的工具类
*
* @version [8.0,2011-5-20 下午04:29:53]
*/
public class FileUtil {
private static final int DEFAULT_READING_SIZE = 8192;
public static void copyFile(File sourceFile, File destFile) throws IOException {
if (!destFile.exists()) {
File parent = destFile.getParentFile();
if (parent != null) {
if (!parent.exists()) {
parent.mkdirs();
}
}
destFile.createNewFile();
}
InputStream in = null;
OutputStream out = null;
try {
in = new FileInputStream(sourceFile);
out = new FileOutputStream(destFile);
copy(in, out);
} finally {
if (in != null)
in.close();
if (out != null)
out.close();
}
}
public static void copy(InputStream in, OutputStream out) throws IOException {
byte[] buf = new byte[1024];
int len = 0;
while ((len = in.read(buf, 0, buf.length)) != -1) {
out.write(buf, 0, len);
}
}
public static void writeFile(File file, byte[] contents) throws IOException {
if (!file.exists()) {
file.createNewFile();
}
if (!file.isFile()) {
throw new IOException("File to be written not exist, file path : " + file.getAbsolutePath());
}
FileOutputStream fileOut = null;
BufferedOutputStream bOutput = null;
try {
fileOut = new FileOutputStream(file);
bOutput = new BufferedOutputStream(fileOut);
bOutput.write(contents);
bOutput.flush();
} finally {
if (fileOut != null) {
try {
fileOut.close();
} catch (IOException e) {
}
}
if (bOutput != null) {
try {
bOutput.close();
} catch (IOException e) {
}
}
}
}
public static byte[] readFileContent(File file) throws IOException {
if (!file.exists() || !file.isFile()) {
throw new IOException("File to be readed not exist, file path : " + file.getAbsolutePath());
}
ByteArrayOutputStream out = new ByteArrayOutputStream();
FileInputStream in = new FileInputStream(file);
byte[] contents = null;
try {
copy(in, out);
contents = out.toByteArray();
} catch (IOException e) {
throw e;
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e) {
};
}
}
return contents;
}
public static String readFileContentAsString(File file) throws IOException {
return readFileContentAsString(file, null);
}
public static String readFileContentAsString(File file, String charsetName) throws IOException {
if (!file.exists() || !file.isFile()) {
throw new IOException("File to be readed not exist, file path : " + file.getAbsolutePath());
}
FileInputStream fileIn = null;
InputStreamReader inReader = null;
BufferedReader bReader = null;
try {
fileIn = new FileInputStream(file);
inReader = charsetName == null ? new InputStreamReader(fileIn) : new InputStreamReader(fileIn, charsetName);
bReader = new BufferedReader(inReader);
StringBuffer content = new StringBuffer();
char[] chBuffer = new char[1024];
int readedNum = -1;
while ((readedNum = bReader.read(chBuffer)) != -1) {
content.append(chBuffer, 0, readedNum);
}
return content.toString();
} finally {
if (fileIn != null) {
try {
fileIn.close();
} catch (IOException e) {
}
}
if (bReader != null) {
try {
bReader.close();
} catch (IOException e) {
}
}
}
}
/**
* 追加内容到文件里，会覆盖
*
* @param file
* @param content
* @throws IOException
*/
public static void writeStringAsFileContent(File file, String content) throws IOException {
writeStringAsFileContent(file, content, null);
}
public static void writeStringAsFileContent(File file, String content, String charsetName) throws IOException {
if (!file.exists() || !file.isFile()) {
throw new IOException("File to be written not exist, file path : " + file.getAbsolutePath());
}
FileOutputStream fileOut = null;
OutputStreamWriter outWriter = null;
BufferedWriter bWriter = null;
try {
fileOut = new FileOutputStream(file);
outWriter = charsetName == null ? new OutputStreamWriter(fileOut)
: new OutputStreamWriter(fileOut, charsetName);
bWriter = new BufferedWriter(outWriter);
bWriter.write(content);
bWriter.flush();
} finally {
if (fileOut != null) {
try {
fileOut.close();
} catch (IOException e) {
}
}
if (bWriter != null) {
try {
bWriter.close();
} catch (IOException e) {
}
}
}
}
/**
* 删除指定目录及其子目录下的指定文件
*
* @param dir
* @param filter
* @throws IOException
*/
public static void deleteWholeDirectory(File dir) throws IOException {
if (!dir.exists() || !dir.isDirectory()) {
throw new IOException("Directory to be deleted not exist, directory path : " + dir.getAbsolutePath());
}
File[] children = dir.listFiles();
for (File child : children) {
if (child.isDirectory()) {
deleteWholeDirectory(child);
} else {
child.delete();
}
}
dir.delete();
}
/**
* 删除指定目录及其子目录下的指定文件
*
* @param dir
* @param filter
* @throws IOException
*/
public static void deleteFilesInWholeDirectory(File dir, FilenameFilter filter) throws IOException {
if (!dir.exists() || !dir.isDirectory()) {
throw new IOException("Directory to be deleted not exist, directory path : " + dir.getAbsolutePath());
}
File[] children = dir.listFiles(filter);
for (File child : children) {
if (child.isDirectory()) {
deleteFilesInWholeDirectory(child, filter);
} else {
child.delete();
}
}
dir.delete();
}
/**
* 根据一个流计算出MD5，不负责关闭该流
*
* @param inputStream
* @return
* @throws IOException
*/
public final static String md5(InputStream inputStream) throws IOException {
try {
BufferedInputStream in = new BufferedInputStream(inputStream);
byte[] bytes = new byte[0];
int count = 1;
while (count != -1) {
byte[] temp = new byte[1024 * 8];
count = in.read(temp);
byte[] full = new byte[bytes.length + temp.length];
System.arraycopy(bytes, 0, full, 0, bytes.length);
System.arraycopy(temp, 0, full, bytes.length, temp.length);
bytes = full;
}
MessageDigest mdTemp = MessageDigest.getInstance("MD5");
mdTemp.update(bytes);
byte[] md = mdTemp.digest();
return StringUtil.getHexDigitsString(md);
} catch (NoSuchAlgorithmException ex) {
// will not happen
return null;
}
}
public final static String md5(File file) throws IOException {
FileInputStream fis = null;
try {
fis = new FileInputStream(file);
return md5(fis);
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException ignore) {
}
}
}
}
/**
* 从XML文件中获取字符串内容
*
* @param xmlFilePath
* @return
* @throws IOException
*/
public static String getStringFromXMLFile(String xmlFilePath) throws IOException {
File file = new File(xmlFilePath);
return getStringFromXMLFile(file);
}
/**
* 从XML文件中获取字符串内容
*
* @param xmlFile
* @return
* @throws IOException
*/
public static String getStringFromXMLFile(File xmlFile) throws IOException {
String temp = "";
String result = "";
if (xmlFile.exists()) {
BufferedReader reader = null;
try {
reader = new BufferedReader(new FileReader(xmlFile));
while ((temp = reader.readLine()) != null) {
result = result + temp;
}
} catch (FileNotFoundException e) {
throw new FileNotFoundException("file not found");
} catch (IOException e) {
throw new IOException();
} finally {
try {
reader.close();
reader = null;
} catch (IOException e) {
}
}
return result;
} else {
return null;
}
}
/**
*
* @param filePath 路径
* @param isExt 是否需要扩展名（如果有的话）
* @return
*/
public static String getFileNameFromPath(String filePath, boolean isExt) {
File file = new File(filePath);
return getFileNameFromPath(file, isExt);
}
// 不带扩展名
public static String getFileNameFromPath(String filePath) {
File file = new File(filePath);
return getFileNameFromPath(file, false);
}
public static String getFileNameFromPath(File file, boolean isExt) {
String filePath = file.getAbsolutePath();
int begin = filePath.lastIndexOf(File.separator);
int end = filePath.lastIndexOf(".");
String fileName = null;
// 处理没有扩展名的文件
if (end == -1 || end < begin) {
fileName = filePath.substring(begin + 1);
} else {
if (isExt) {
fileName = filePath.substring(begin + 1);
} else {
fileName = filePath.substring(begin + 1, end);
}
}
return fileName;
}
public static boolean exists(URL url) {
// check if a file exists
if (url.getProtocol().equals("file")) {
File f = new File(url.getFile());
return f.exists();
}
// check if a jar file entry exists
if (url.getProtocol().equals("jar")) {
String spec = url.getFile();
if (spec.startsWith("file:")) {
int separator = spec.indexOf('!');
if (separator == -1) {
return false;
}
String jarFileName = spec.substring(5, separator++);
String entryName = null;
// if ! is the last letter of the inner URL, entry not exist
if (++separator != spec.length()) {
entryName = spec.substring(separator, spec.length());
} else {
return false;
}
try {
JarFile jarFile = new JarFile(jarFileName);
JarEntry jarEntry = (JarEntry) jarFile.getEntry(entryName);
jarFile.close();
return jarEntry != null;
} catch (IOException ex) {
return false;
}
}
}
// check if a resource exists
try {
InputStream is = url.openStream();
is.close();
return true;
} catch (IOException e) {
return false;
}
}
/**
* 拷贝隐藏文件(文件名以.开头的文件)
*
* @param source
* @param dest
* @throws IOException
*/
public static void copyFilesIngoreHiddenFiles(File source, File dest) throws IOException {
if (source != null /*&& source.exists()*/&& dest != null /*&& dest.exists()*/) {
if (!source.getName().startsWith(".")) {
copyFile2(source, dest);
if (source.isDirectory()) {
File[] list = source.listFiles();
if (list != null) {
for (File file : list) {
copyFilesIngoreHiddenFiles(file, new File(dest.getAbsolutePath() + File.separator
+ file.getName()));
}
}
}
}
}
}
/**
* 复制文件夹
*
* @throws IOException
*/
public static void copyFolder(File srcDir, File destDir, List<?> excludedList) throws IOException {
if (destDir == null || !destDir.exists()) {
throw new FileNotFoundException("File destDir not existed");
}
if (srcDir == null || !srcDir.exists()) {
throw new FileNotFoundException("File srcDir not existed");
}
File[] files = srcDir.listFiles();
for (int i = 0; i < files.length; i++) {
if (excludedList != null && excludedList.contains(files)) {
continue;
}
String fileName = files.getName();
if (files.isFile()) {
copyFileToDir(files, destDir);
} else {
File file = new File(destDir, fileName);
file.mkdir();
copyFolder(files, file, excludedList);
}
}
}
public static void copyFileToDir(File sourceFile, File destDir) throws IOException {
String name = sourceFile.getName();
File destFile = new File(destDir, name);
if (sourceFile.isDirectory()) {
destFile.mkdirs();
return;
}
InputStream in = null;
OutputStream out = null;
try {
in = new FileInputStream(sourceFile);
out = new FileOutputStream(destFile);
copy(in, out);
} finally {
if (in != null)
in.close();
if (out != null)
out.close();
}
}
public static void copyFile2(File sourceFile, File destFile) throws IOException {
if (sourceFile.isDirectory()) {
destFile.mkdirs();
return;
}
InputStream in = null;
OutputStream out = null;
try {
in = new FileInputStream(sourceFile);
out = new FileOutputStream(destFile);
copy(in, out);
} finally {
if (in != null)
in.close();
if (out != null)
out.close();
}
}
public static void copyFile(File sourceFile, File destDir, String newFileName) throws IOException {
File destFile = new File(destDir, newFileName);
if (sourceFile.isDirectory()) {
destFile.mkdirs();
return;
}
InputStream in = null;
OutputStream out = null;
try {
in = new FileInputStream(sourceFile);
out = new FileOutputStream(destFile);
copy(in, out);
} finally {
if (in != null)
in.close();
if (out != null)
out.close();
}
}
public static byte[] toByteArray(String path) throws IOException {
File file = new File(path);
FileInputStream in = null;
try {
in = new FileInputStream(file);
byte[] data = new byte[(int) file.length()];
in.read(data);
return data;
} finally {
in.close();
}
}
/**
*
* @param sourceDir
* @param destDir
* @param excludedDirName
* @throws IOException
*/
public static void copyDir(File sourceDir, File destDir, String excludedDirName) throws IOException {
copyDir(sourceDir, destDir, true, excludedDirName);
}
public static void copyDir(File from, File to) throws IOException {
copyDir(from, to, true, null);
}
public static void copyDir(File from, File to, boolean includeSubdirs) throws IOException {
copyDir(from, to, includeSubdirs, null);
}
public static void copyDir(File from, File to, boolean includeSubdirs, String excludedDirName) throws IOException {
if (!to.exists()) {
to.mkdirs();
}
if (from == null || !from.isDirectory() || !to.isDirectory())
return;
File fs[] = from.listFiles();
if (fs == null)
return;
for (int i = 0; i < fs.length; i++) {
String n = fs.getName();
File c = new File(to, n);
if (fs.isDirectory() && !includeSubdirs)
continue;
if (fs.isDirectory()) {
if (fs.getName().equals(excludedDirName)) {
continue;
}
c.mkdirs();
copyDir(fs, c, includeSubdirs, excludedDirName);
continue;
}
copyFileToDir(fs, to);
}
}
public static File makeTempdir() throws IOException {
return makeTempDir((File) null, null, null);
}
public static File makeTempDir(File parentDir, String prefix, String suffix) throws IOException {
if (suffix == null)
suffix = ".tmp";
File tmpdir = null;
if (parentDir == null) {
tmpdir = new File(System.getProperty("java.io.tmpdir", "/temp"));
} else {
tmpdir = parentDir;
}
int counter = new Random().nextInt() & 0xffff;
File f;
do {
counter++;
f = new File(tmpdir, prefix + Integer.toString(counter) + suffix);
} while (f.exists() || !f.mkdirs());
return f;
}
public static File makeTempDir(String parentDir, String prefix, String suffix) throws IOException {
File fileParentDir = null;
if (parentDir != null)
fileParentDir = new File(System.getProperty("java.io.tmpdir", "/temp"), parentDir);
return makeTempDir(fileParentDir, prefix, suffix);
}
public static File getTempFile(File parentDir) {
if (parentDir == null)
parentDir = new File(System.getProperty("java.io.tmpdir", "/temp"));
int counter = new Random().nextInt() & 0xffff;
File f;
do {
counter++;
f = new File(parentDir, "tempfile" + Integer.toString(counter));
} while (f.exists());
return f;
}
/**
* get temp folder
*
* @return the temp folder may be null
*/
public static File getTempFolder() {
File parentDir = new File(System.getProperty("java.io.tmpdir", "/temp"));
int counter = new Random().nextInt() & 0xffff;
File f = null;
do {
counter++;
f = new File(parentDir, "tempfolder" + Integer.toString(counter));
} while (f.exists());
f.mkdir();
return f;
}
public static void unpackZipFile(File zipFile, File dir) throws IOException {
InputStream fis = new FileInputStream(zipFile);
ZipInputStream zis = new ZipInputStream(fis);
try {
for (ZipEntry e = zis.getNextEntry(); e != null; e = zis.getNextEntry()) {
File f = new File(dir, e.getName());
if (e.isDirectory()) {
if (!f.exists() && !f.mkdirs()) {
throw new IOException("Cannot make directory " + f.getPath());
}
} else {
File d = f.getParentFile();
if (d != null && !d.exists() && !d.mkdirs()) {
throw new IOException("Cannot make directory " + d.getPath());
}
OutputStream out = new FileOutputStream(f);
copy(zis, out);
out.close();
}
}
} finally {
zis.close();
fis.close();
}
}
public static void makeJarFile(File jarFile, File dir) throws IOException {
makeJarFile(jarFile, dir, null);
}
/**
*
* @param jarFile
* @param dir
* @param excludedList java.io.File
* @throws IOException
*/
public static void makeJarFile(File jarFile, File dir, Vector excludedList) throws IOException {
/*
* Create output jar file
*/
OutputStream fos = new FileOutputStream(jarFile);
ZipOutputStream zos = new ZipOutputStream(fos);
/*
* Add entries to jar file
*/
try {
addToJar(zos, dir, excludedList, new Vector());
} finally {
zos.close();
fos.close();
}
}
public static void addToJar(ZipOutputStream zos, File dir, Vector excludedList, Vector entriesAdded) throws IOException {
/*
* Expands list of files to process into full list of all files that can
* be found by recursively descending directories.
*/
Vector v = new Vector();
expand(dir, dir.list(), excludedList, v);
/*
* Add entries to jar file
*/
String path = dir.getPath();
if (!path.endsWith(File.separator)) {
path = path + File.separator;
}
path = path.replace(File.separatorChar, '/');
for (int i = 0; i < v.size(); i++) {
addFile(zos, path, (File) v.elementAt(i), entriesAdded);
}
}
private static void expand(File dir, String[] files, Vector excludeList, Vector v) {
if (files == null) {
return;
}
for (int i = 0; i < files.length; i++) {
File f = new File(dir, files);
if (excludeList == null || !excludeList.contains(f)) {
if (f.isFile()) {
v.addElement(f);
} else if (f.isDirectory()) {
v.addElement(f);
expand(f, f.list(), excludeList, v);
}
}
}
}
private static void addFile(ZipOutputStream zos, String path, File file, Vector entriesAdded) throws IOException {
String name = file.getPath();
boolean isDir = file.isDirectory();
if (isDir) {
if (!name.endsWith(File.separator)) {
name = name + File.separator;
}
}
name = name.replace(File.separatorChar, '/');
if (name.startsWith(path)) {
name = name.substring(path.length());
}
if (entriesAdded.contains(name)) {
return;
}
long size = isDir ? 0 : file.length();
ZipEntry e = new ZipEntry(name);
e.setTime(file.lastModified());
if (size == 0) {
e.setMethod(ZipEntry.STORED);
e.setSize(0);
e.setCrc(0);
}
zos.putNextEntry(e);
if (!isDir) {
InputStream in = new FileInputStream(file);
copy(in, zos);
in.close();
}
zos.closeEntry();
entriesAdded.addElement(name);
}
public static String getFileNameWithoutExt(String filePath) {
filePath = filePath.replace('\\', '/');
int pos = filePath.lastIndexOf('/');
String fileName = filePath.substring(pos + 1);
int pos2 = fileName.lastIndexOf('.');
if (pos2 == -1) {
return fileName;
} else {
return fileName.substring(0, pos2);
}
}
public static boolean isZipFile(File file) {
try {
ZipFile zip = new ZipFile(file);
zip.close();
return true;
} catch (IOException ex) {
return false;
}
}
public static void removeDir(File dir) {
if (dir.isDirectory()) {
removeFile(dir);
}
dir.delete();
}
public static void removeFile(File file) {
if (file.isFile()) {
} else if (file.isDirectory()) {
// Recursively remove all files in subdirectory.
String list[] = file.list();
if (list != null) {
for (int i = 0; i < list.length; i++) {
File f = new File(file, list);
removeFile(f);
}
}
}
file.delete();
}
public static URL getFileURL(File file) {
try {
file = file.getCanonicalFile();
} catch (IOException e) {
}
String path = file.getAbsolutePath();
if (File.separatorChar != '/') {
path = path.replace(File.separatorChar, '/');
}
if (!path.startsWith("/")) {
path = "/" + path;
}
if (!path.endsWith("/") && file.isDirectory()) {
path = path + "/";
}
try {
return new URL("file", "", -1, path);
} catch (MalformedURLException e) {
// Should never happen since we specified the protocol
throw new InternalError();
}
}
/**
* 读取文件内容并将其转换为String类型
*
* @param file
* @return
* @throws IOException
*/
public static String getFileStringContent(File file) throws IOException {
return new String(getFileByteContent(file));
}
/**
* 读取文件内容并按指定字符编码类型来将其转换成String类型
*
* @param file
* @param charsetName
* @return
* @throws IOException
*/
public static String getFileStringContent(File file, String charsetName) throws IOException {
return new String(getFileByteContent(file), charsetName);
}
/**
* 读取InputStream留的内容并将其转换为String类型
*
* @param inputStream
* @return
* @throws IOException
*/
public static String getInputStreamStringContent(InputStream inputStream) throws IOException {
return new String(getInputStreamAsByteArray(inputStream, -1));
}
/**
* Returns the contents of the given file as a byte array.
*
* @throws IOException if a problem occured reading the file.
*/
public static byte[] getFileByteContent(File file) throws IOException {
InputStream stream = null;
try {
stream = new BufferedInputStream(new FileInputStream(file));
return getInputStreamAsByteArray(stream, (int) file.length());
} finally {
if (stream != null) {
try {
stream.close();
} catch (IOException e) {
// ignore
}
}
}
}
/**
* Returns the given input stream's contents as a byte array. If a length is specified (ie. if length != -1), only
* length bytes are returned. Otherwise all bytes in the stream are returned. Note this doesn't close the stream.
*
* @throws IOException if a problem occured reading the stream.
*/
public static byte[] getInputStreamAsByteArray(InputStream stream, int length) throws IOException {
byte[] contents;
if (length == -1) {
contents = new byte[0];
int contentsLength = 0;
int amountRead = -1;
do {
int amountRequested = Math.max(stream.available(), DEFAULT_READING_SIZE); // read at least 8K
// resize contents if needed
if (contentsLength + amountRequested > contents.length) {
System.arraycopy(contents, 0, contents = new byte[contentsLength + amountRequested], 0, contentsLength);
}
// read as many bytes as possible
amountRead = stream.read(contents, contentsLength, amountRequested);
if (amountRead > 0) {
// remember length of contents
contentsLength += amountRead;
}
} while (amountRead != -1);
// resize contents if necessary
if (contentsLength < contents.length) {
System.arraycopy(contents, 0, contents = new byte[contentsLength], 0, contentsLength);
}
} else {
contents = new byte[length];
int len = 0;
int readSize = 0;
while ((readSize != -1) && (len != length)) {
// See PR 1FMS89U
// We record first the read size. In this case len is the actual read size.
len += readSize;
readSize = stream.read(contents, len, length - len);
}
}
return contents;
}
public static void main(String[] args) throws Exception {
File iniFile = new File(FileUtil.class.getResource("init.sql").toURI());
FileReader reader = new FileReader(iniFile);
BufferedReader bufferReader = new BufferedReader(reader);
String all = "";
String row;
while((row = bufferReader.readLine())!=null){
if (!row.contains("--")) {
row = row.replaceAll("\r\n", " ");
row = row.replaceAll("\r", " ");
row = row.replaceAll("\n", " ");
//             row = row.replaceAll(";", "\r\n");
if (row.endsWith(";")) {
row = row + " " + "\r\n";
} else {
row = row + " ";
}
all = all + row;
}
}
System.out.println(all);
}
}