Java常用工具类总结(三)
1.File
package com.gootrip.util;
/*
* Static File routines.
* Copyright (C) 2002 Stephen Ostermiller
* http://ostermiller.org/contact.pl?regarding=Java+Utilities
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* See COPYING.TXT for details.
*/
import java.io.*;
import java.text.MessageFormat;
import java.util.ResourceBundle;
import java.util.Locale;
/**
* Utilities for File manipulation.
* More information about this class is available from ostermiller.org.
*
* @author Stephen Ostermiller http://ostermiller.org/contact.pl?regarding=Java+Utilities
* @since ostermillerutils 1.00.00
*/
public class FileHelper {
/**
* Locale specific strings displayed to the user.
*
* @since ostermillerutils 1.00.00
*/
protected static ResourceBundle labels = ResourceBundle.getBundle("com.Ostermiller.util.FileHelper", Locale.getDefault());
/**
* Move a file from one location to another. An attempt is made to rename
* the file and if that fails, the file is copied and the old file deleted.
*
* If the destination file already exists, an exception will be thrown.
*
* @param from file which should be moved.
* @param to desired destination of the file.
* @throws IOException if an error occurs.
*
* @since ostermillerutils 1.00.00
*/
public static void move(File from, File to) throws IOException {
move(from, to, false);
}
/**
* Move a file from one location to another. An attempt is made to rename
* the file and if that fails, the file is copied and the old file deleted.
*
* @param from file which should be moved.
* @param to desired destination of the file.
* @param overwrite If false, an exception will be thrown rather than overwrite a file.
* @throws IOException if an error occurs.
*
* @since ostermillerutils 1.00.00
*/
public static void move(File from, File to, boolean overwrite) throws IOException {
if (to.exists()){
if (overwrite){
if (!to.delete()){
throw new IOException(
MessageFormat.format(
labels.getString("deleteerror"),
(Object[])new String[] {
to.toString()
}
)
);
}
} else {
throw new IOException(
MessageFormat.format(
labels.getString("alreadyexistserror"),
(Object[])new String[] {
to.toString()
}
)
);
}
}
if (from.renameTo(to)) return;
InputStream in = null;
OutputStream out = null;
try {
in = new FileInputStream(from);
out = new FileOutputStream(to);
copy(in, out);
in.close();
in = null;
out.flush();
out.close();
out = null;
if (!from.delete()){
throw new IOException(
MessageFormat.format(
labels.getString("deleteoriginalerror"),
(Object[])new String[] {
from.toString(),
to.toString()
}
)
);
}
} finally {
if (in != null){
in.close();
in = null;
}
if (out != null){
out.flush();
out.close();
out = null;
}
}
}
/**
* Buffer size when reading from input stream.
*
* @since ostermillerutils 1.00.00
*/
private final static int BUFFER_SIZE = 1024;
/**
* Copy the data from the input stream to the output stream.
*
* @param in data source
* @param out data destination
* @throws IOException in an input or output error occurs
*
* @since ostermillerutils 1.00.00
*/
private static void copy(InputStream in, OutputStream out) throws IOException {
byte[] buffer = new byte[BUFFER_SIZE];
int read;
while((read = in.read(buffer)) != -1){
out.write(buffer, 0, read);
}
}
}import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.UUID;
public class FileUtil
{
public static boolean copyFile(String paramString1, String paramString2)
{
try
{
File localFile1 = new File(paramString1);
File localFile2 = new File(paramString2);
FileInputStream localFileInputStream = new FileInputStream(localFile1);
FileOutputStream localFileOutputStream = new FileOutputStream(localFile2);
byte[] arrayOfByte = new byte[1024];
while (true)
{
int i = localFileInputStream.read(arrayOfByte);
if (i == -1)
{
((byte[])null);
localFileInputStream.close();
localFileOutputStream.close();
return true;
}
localFileOutputStream.write(arrayOfByte, 0, i);
}
}
catch (IOException localIOException)
{
}
return false;
}
public static boolean deleteFile(String paramString)
{
File localFile = new File(paramString);
if (localFile.exists())
return localFile.delete();
return true;
}
public static boolean exist(String paramString)
{
if (paramString == null)
return false;
return new File(paramString).exists();
}
public static void generateOtherImg(String paramString)
{
}
public static byte[] getBytesFromFile(File paramFile)
throws IOException
{
FileInputStream localFileInputStream = new FileInputStream(paramFile);
long l = paramFile.length();
if (l > 2147483647L)
{
localFileInputStream.close();
throw new IOException("File is to large " + paramFile.getName());
}
byte[] arrayOfByte = new byte[(int)l];
int i = 0;
try
{
if (i < arrayOfByte.length)
{
j = localFileInputStream.read(arrayOfByte, i, arrayOfByte.length - i);
if (j >= 0);
}
else
{
if (i >= arrayOfByte.length)
break label145;
throw new IOException("Could not completely read file " + paramFile.getName());
}
}
catch (Exception localException)
{
while (true)
{
int j;
return null;
i += j;
}
label145: localFileInputStream.close();
return arrayOfByte;
}
finally
{
((byte[])null);
}
}
public static byte[] getBytesFromFile(String paramString)
throws IOException
{
return getBytesFromFile(new File(paramString));
}
public static int getFileLength(String paramString)
{
File localFile = new File(paramString);
if (localFile.exists())
return (int)localFile.length();
return -1;
}
public static String getStrFromFile(File paramFile)
throws IOException
{
FileInputStream localFileInputStream = new FileInputStream(paramFile);
if (paramFile.length() > 2147483647L)
{
localFileInputStream.close();
throw new IOException("File is to large " + paramFile.getName());
}
StringBuffer localStringBuffer = new StringBuffer();
BufferedReader localBufferedReader = new BufferedReader(new InputStreamReader(localFileInputStream, "GBK"));
while (true)
{
String str1 = localBufferedReader.readLine();
if (str1 == null)
{
String str2 = localStringBuffer.toString();
localFileInputStream.close();
return str2;
}
localStringBuffer.append(str1);
localStringBuffer.append("\n");
}
}
public static boolean isDirectory(String paramString)
{
return new File(paramString).isDirectory();
}
public static boolean makeSureDirExist(String paramString)
{
boolean bool = true;
File localFile = new File(paramString);
if (!localFile.exists())
bool = localFile.mkdir();
return bool;
}
public static boolean makeSureFileExist(String paramString)
{
boolean bool1 = true;
File localFile = new File(paramString);
if (!localFile.exists());
try
{
boolean bool2 = localFile.createNewFile();
bool1 = bool2;
return bool1;
}
catch (IOException localIOException)
{
}
return false;
}
public static int makeSureFileExistEx(String paramString)
{
int i = -1;
File localFile = new File(paramString);
if (!localFile.exists())
try
{
boolean bool = localFile.createNewFile();
if (bool)
i = 0;
return i;
}
catch (IOException localIOException)
{
return -1;
}
return (int)localFile.length();
}
public static String newImageName()
{
return UUID.randomUUID().toString().replaceAll("-", "") + ".jpg";
}
public void finalize()
{
}
}2.文件上传
package com.gootrip.util;
import java.io.File;
import java.util.*;
import org.apache.commons.fileupload.*;
import javax.servlet.http.HttpServletRequest;
import java.util.regex.Pattern;
import java.io.IOException;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import java.util.regex.Matcher;
/**
* @author
*
* TODO
*
*/
public class FileUploadUtil {
//当上传文件超过限制时设定的临时文件位置，注意是绝对路径
private String tempPath = null;
//文件上传目标目录，注意是绝对路径
private String dstPath = null;
//新文件名称，不设置时默认为原文件名
private String newFileName = null;
//获取的上传请求
private HttpServletRequest fileuploadReq = null;
//设置最多只允许在内存中存储的数据,单位:字节，这个参数不要设置太大
private int sizeThreshold = 4096;
//设置允许用户上传文件大小,单位:字节
//共10M
private long sizeMax = 10485760;
//图片文件序号
private int picSeqNo = 1;
private boolean isSmallPic = false;
public FileUploadUtil(){
}
public FileUploadUtil(String tempPath, String destinationPath){
this.tempPath = tempPath;
this.dstPath = destinationPath;
}
public FileUploadUtil(String tempPath, String destinationPath, HttpServletRequest fileuploadRequest){
this.tempPath = tempPath;
this.dstPath = destinationPath;
this.fileuploadReq = fileuploadRequest;
}
/** 文件上载
* @return true —— success; false —— fail.
*/
public boolean Upload(){
DiskFileItemFactory factory = new DiskFileItemFactory();
try {
//如果没有上传目的目录，则创建它
FileUtil.makeDirectory(dstPath+"/ddd");
/*if (!FileUtil.makeDirectory(dstPath+"/ddd")) {
throw new IOException("Create destination Directory Error.");
}*/
//如果没有临时目录，则创建它
FileUtil.makeDirectory(tempPath+"/ddd");
/*if (!FileUtil.makeDirectory(tempPath+"/ddd")) {
throw new IOException("Create Temp Directory Error.");
}*/
//上传项目只要足够小，就应该保留在内存里。
//较大的项目应该被写在硬盘的临时文件上。
//非常大的上传请求应该避免。
//限制项目在内存中所占的空间，限制最大的上传请求，并且设定临时文件的位置。
//设置最多只允许在内存中存储的数据,单位:字节
factory.setSizeThreshold(sizeThreshold);
// the location for saving data that is larger than getSizeThreshold()
factory.setRepository(new File(tempPath));
ServletFileUpload upload = new ServletFileUpload(factory);
//设置允许用户上传文件大小,单位:字节
upload.setSizeMax(sizeMax);
List fileItems = upload.parseRequest(fileuploadReq);
// assume we know there are two files. The first file is a small
// text file, the second is unknown and is written to a file on
// the server
Iterator iter = fileItems.iterator();
// 正则匹配，过滤路径取文件名
String regExp = ".+\\\\(.+)$";
// 过滤掉的文件类型
String[] errorType = {".exe", ".com", ".cgi", ".asp", ".php", ".jsp"};
Pattern p = Pattern.compile(regExp);
while (iter.hasNext()) {
System.out.println("++00++====="+newFileName);
FileItem item = (FileItem) iter.next();
//忽略其他不是文件域的所有表单信息
if (!item.isFormField()) {
String name = item.getName();
System.out.println("++++====="+name);
long size = item.getSize();
//有多个文件域时，只上传有文件的
if ((name == null || name.equals("")) && size == 0)
continue;
Matcher m = p.matcher(name);
boolean result = m.find();
if (result) {
for (int temp = 0; temp < errorType.length; temp++) {
if (m.group(1).endsWith(errorType[temp])) {
throw new IOException(name + ": Wrong File Type");
}
}
String ext = "."+FileUtil.getTypePart(name);
try {
//保存上传的文件到指定的目录
//在下文中上传文件至数据库时，将对这里改写
//没有指定新文件名时以原文件名来命名
if (newFileName == null || newFileName.trim().equals(""))
{
item.write(new File(dstPath +"/"+ m.group(1)));
}
else
{
String uploadfilename = "";
if (isSmallPic)
{
uploadfilename = dstPath +"/"+ newFileName+"_"+picSeqNo+"_small"+ext;
}
else
{
uploadfilename = dstPath +"/"+ newFileName+"_"+picSeqNo+ext;
}
//生成所有未生成的目录
System.out.println("++++====="+uploadfilename);
FileUtil.makeDirectory(uploadfilename);
//item.write(new File(dstPath +"/"+ newFileName));
item.write(new File(uploadfilename));
}
picSeqNo++;
//out.print(name + " " + size + "
");
} catch (Exception e) {
//out.println(e);
throw new IOException(e.getMessage());
}
} else {
throw new IOException("fail to upload");
}
}
}
} catch (IOException e) {
System.out.println(e);
} catch (FileUploadException e) {
System.out.println(e);
}
return true;
}
/**从路径中获取单独文件名
* @author
*
* TODO 要更改此生成的类型注释的模板，请转至
* 窗口 － 首选项 － Java － 代码样式 － 代码模板
*/
public String GetFileName(String filepath)
{
String returnstr = "*.*";
int length = filepath.trim().length();
filepath = filepath.replace('\\', '/');
if(length >0)
{
int i = filepath.lastIndexOf("/");
if (i >= 0)
{
filepath = filepath.substring(i + 1);
returnstr = filepath;
}
}
return returnstr;
}
/**
* 设置临时存贮目录
*/
public void setTmpPath(String tmppath)
{
this.tempPath = tmppath;
}
/**
* 设置目标目录
*/
public void setDstPath(String dstpath) {
this.dstPath = dstpath;
}
/**
* 设置最大上传文件字节数，不设置时默认10M
*/
public void setFileMaxSize(long maxsize) {
this.sizeMax = maxsize;
}
/**
* 设置Http 请求参数，通过这个能数来获取文件信息
*/
public void setHttpReq(HttpServletRequest httpreq) {
this.fileuploadReq = httpreq;
}
/**
* 设置Http 请求参数，通过这个能数来获取文件信息
*/
public void setNewFileName(String filename) {
this.newFileName = filename;
}
/**
* 设置此上传文件是否是缩略图文件，这个参数主要用于缩略图命名
*/
public void setIsSmalPic(boolean isSmallPic) {
this.isSmallPic = isSmallPic;
}
/**
* 设置Http 请求参数，通过这个能数来获取文件信息
*/
public void setPicSeqNo(int seqNo) {
this.picSeqNo = seqNo;
}
}3.FileUtil
package com.gootrip.util;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Hashtable;
import javax.swing.filechooser.FileFilter;
/**
* 此类中封装一些常用的文件操作。
* 所有方法都是静态方法，不需要生成此类的实例，
* 为避免生成此类的实例，构造方法被申明为private类型的。
* @since 1.0
*/
public class FileUtil {
/**
* 私有构造方法，防止类的实例化，因为工具类不需要实例化。
*/
private FileUtil() {
}
/**
* 修改文件的最后访问时间。
* 如果文件不存在则创建该文件。
* 目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考虑中。
* @param file 需要修改最后访问时间的文件。
* @since 1.0
*/
public static void touch(File file) {
long currentTime = System.currentTimeMillis();
if (!file.exists()) {
System.err.println("file not found:" + file.getName());
System.err.println("Create a new file:" + file.getName());
try {
if (file.createNewFile()) {
System.out.println("Succeeded!");
}
else {
System.err.println("Create file failed!");
}
}
catch (IOException e) {
System.err.println("Create file failed!");
e.printStackTrace();
}
}
boolean result = file.setLastModified(currentTime);
if (!result) {
System.err.println("touch failed: " + file.getName());
}
}
/**
* 修改文件的最后访问时间。
* 如果文件不存在则创建该文件。
* 目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考虑中。
* @param fileName 需要修改最后访问时间的文件的文件名。
* @since 1.0
*/
public static void touch(String fileName) {
File file = new File(fileName);
touch(file);
}
/**
* 修改文件的最后访问时间。
* 如果文件不存在则创建该文件。
* 目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考虑中。
* @param files 需要修改最后访问时间的文件数组。
* @since 1.0
*/
public static void touch(File[] files) {
for (int i = 0; i < files.length; i++) {
touch(files[i]);
}
}
/**
* 修改文件的最后访问时间。
* 如果文件不存在则创建该文件。
* 目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考虑中。
* @param fileNames 需要修改最后访问时间的文件名数组。
* @since 1.0
*/
public static void touch(String[] fileNames) {
File[] files = new File[fileNames.length];
for (int i = 0; i < fileNames.length; i++) {
files[i] = new File(fileNames[i]);
}
touch(files);
}
/**
* 判断指定的文件是否存在。
* @param fileName 要判断的文件的文件名
* @return 存在时返回true，否则返回false。
* @since 1.0
*/
public static boolean isFileExist(String fileName) {
return new File(fileName).isFile();
}
/**
* 创建指定的目录。
* 如果指定的目录的父目录不存在则创建其目录书上所有需要的父目录。
* 注意：可能会在返回false的时候创建部分父目录。
* @param file 要创建的目录
* @return 完全创建成功时返回true，否则返回false。
* @since 1.0
*/
public static boolean makeDirectory(File file) {
File parent = file.getParentFile();
if (parent != null) {
return parent.mkdirs();
}
return false;
}
/**
* 创建指定的目录。
* 如果指定的目录的父目录不存在则创建其目录书上所有需要的父目录。
* 注意：可能会在返回false的时候创建部分父目录。
* @param fileName 要创建的目录的目录名
* @return 完全创建成功时返回true，否则返回false。
* @since 1.0
*/
public static boolean makeDirectory(String fileName) {
File file = new File(fileName);
return makeDirectory(file);
}
/**
* 清空指定目录中的文件。
* 这个方法将尽可能删除所有的文件，但是只要有一个文件没有被删除都会返回false。
* 另外这个方法不会迭代删除，即不会删除子目录及其内容。
* @param directory 要清空的目录
* @return 目录下的所有文件都被成功删除时返回true，否则返回false.
* @since 1.0
*/
public static boolean emptyDirectory(File directory) {
boolean result = true;
File[] entries = directory.listFiles();
for (int i = 0; i < entries.length; i++) {
if (!entries[i].delete()) {
result = false;
}
}
return result;
}
/**
* 清空指定目录中的文件。
* 这个方法将尽可能删除所有的文件，但是只要有一个文件没有被删除都会返回false。
* 另外这个方法不会迭代删除，即不会删除子目录及其内容。
* @param directoryName 要清空的目录的目录名
* @return 目录下的所有文件都被成功删除时返回true，否则返回false。
* @since 1.0
*/
public static boolean emptyDirectory(String directoryName) {
File dir = new File(directoryName);
return emptyDirectory(dir);
}
/**
* 删除指定目录及其中的所有内容。
* @param dirName 要删除的目录的目录名
* @return 删除成功时返回true，否则返回false。
* @since 1.0
*/
public static boolean deleteDirectory(String dirName) {
return deleteDirectory(new File(dirName));
}
/**
* 删除指定目录及其中的所有内容。
* @param dir 要删除的目录
* @return 删除成功时返回true，否则返回false。
* @since 1.0
*/
public static boolean deleteDirectory(File dir) {
if ( (dir == null) || !dir.isDirectory()) {
throw new IllegalArgumentException("Argument " + dir +
" is not a directory. ");
}
File[] entries = dir.listFiles();
int sz = entries.length;
for (int i = 0; i < sz; i++) {
if (entries[i].isDirectory()) {
if (!deleteDirectory(entries[i])) {
return false;
}
}
else {
if (!entries[i].delete()) {
return false;
}
}
}
if (!dir.delete()) {
return false;
}
return true;
}
/**
* 列出目录中的所有内容，包括其子目录中的内容。
* @param fileName 要列出的目录的目录名
* @return 目录内容的文件数组。
* @since 1.0
*/
/*public static File[] listAll(String fileName) {
return listAll(new File(fileName));
}*/
/**
* 列出目录中的所有内容，包括其子目录中的内容。
* @param file 要列出的目录
* @return 目录内容的文件数组。
* @since 1.0
*/
/*public static File[] listAll(File file) {
ArrayList list = new ArrayList();
File[] files;
if (!file.exists() || file.isFile()) {
return null;
}
list(list, file, new AllFileFilter());
list.remove(file);
files = new File[list.size()];
list.toArray(files);
return files;
}*/
/**
* 列出目录中的所有内容，包括其子目录中的内容。
* @param file 要列出的目录
* @param filter 过滤器
* @return 目录内容的文件数组。
* @since 1.0
*/
public static File[] listAll(File file,
javax.swing.filechooser.FileFilter filter) {
ArrayList list = new ArrayList();
File[] files;
if (!file.exists() || file.isFile()) {
return null;
}
list(list, file, filter);
files = new File[list.size()];
list.toArray(files);
return files;
}
/**
* 将目录中的内容添加到列表。
* @param list 文件列表
* @param filter 过滤器
* @param file 目录
*/
private static void list(ArrayList list, File file,
javax.swing.filechooser.FileFilter filter) {
if (filter.accept(file)) {
list.add(file);
if (file.isFile()) {
return;
}
}
if (file.isDirectory()) {
File files[] = file.listFiles();
for (int i = 0; i < files.length; i++) {
list(list, files[i], filter);
}
}
}
/**
* 返回文件的URL地址。
* @param file 文件
* @return 文件对应的的URL地址
* @throws MalformedURLException
* @since 1.0
* @deprecated 在实现的时候没有注意到File类本身带一个toURL方法将文件路径转换为URL。
* 请使用File.toURL方法。
*/
public static URL getURL(File file) throws MalformedURLException {
String fileURL = "file:/" + file.getAbsolutePath();
URL url = new URL(fileURL);
return url;
}
/**
* 从文件路径得到文件名。
* @param filePath 文件的路径，可以是相对路径也可以是绝对路径
* @return 对应的文件名
* @since 1.0
*/
public static String getFileName(String filePath) {
File file = new File(filePath);
return file.getName();
}
/**
* 从文件名得到文件绝对路径。
* @param fileName 文件名
* @return 对应的文件路径
* @since 1.0
*/
public static String getFilePath(String fileName) {
File file = new File(fileName);
return file.getAbsolutePath();
}
/**
* 将DOS/Windows格式的路径转换为UNIX/Linux格式的路径。
* 其实就是将路径中的"\"全部换为"/"，因为在某些情况下我们转换为这种方式比较方便，
* 某中程度上说"/"比"\"更适合作为路径分隔符，而且DOS/Windows也将它当作路径分隔符。
* @param filePath 转换前的路径
* @return 转换后的路径
* @since 1.0
*/
public static String toUNIXpath(String filePath) {
return filePath.replace('\\', '/');
}
/**
* 从文件名得到UNIX风格的文件绝对路径。
* @param fileName 文件名
* @return 对应的UNIX风格的文件路径
* @since 1.0
* @see #toUNIXpath(String filePath) toUNIXpath
*/
public static String getUNIXfilePath(String fileName) {
File file = new File(fileName);
return toUNIXpath(file.getAbsolutePath());
}
/**
* 得到文件的类型。
* 实际上就是得到文件名中最后一个“.”后面的部分。
* @param fileName 文件名
* @return 文件名中的类型部分
* @since 1.0
*/
public static String getTypePart(String fileName) {
int point = fileName.lastIndexOf('.');
int length = fileName.length();
if (point == -1 || point == length - 1) {
return "";
}
else {
return fileName.substring(point + 1, length);
}
}
/**
* 得到文件的类型。
* 实际上就是得到文件名中最后一个“.”后面的部分。
* @param file 文件
* @return 文件名中的类型部分
* @since 1.0
*/
public static String getFileType(File file) {
return getTypePart(file.getName());
}
/**
* 得到文件的名字部分。
* 实际上就是路径中的最后一个路径分隔符后的部分。
* @param fileName 文件名
* @return 文件名中的名字部分
* @since 1.0
*/
public static String getNamePart(String fileName) {
int point = getPathLsatIndex(fileName);
int length = fileName.length();
if (point == -1) {
return fileName;
}
else if (point == length - 1) {
int secondPoint = getPathLsatIndex(fileName, point - 1);
if (secondPoint == -1) {
if (length == 1) {
return fileName;
}
else {
return fileName.substring(0, point);
}
}
else {
return fileName.substring(secondPoint + 1, point);
}
}
else {
return fileName.substring(point + 1);
}
}
/**
* 得到文件名中的父路径部分。
* 对两种路径分隔符都有效。
* 不存在时返回""。
* 如果文件名是以路径分隔符结尾的则不考虑该分隔符，例如"/path/"返回""。
* @param fileName 文件名
* @return 父路径，不存在或者已经是父目录时返回""
* @since 1.0
*/
public static String getPathPart(String fileName) {
int point = getPathLsatIndex(fileName);
int length = fileName.length();
if (point == -1) {
return "";
}
else if (point == length - 1) {
int secondPoint = getPathLsatIndex(fileName, point - 1);
if (secondPoint == -1) {
return "";
}
else {
return fileName.substring(0, secondPoint);
}
}
else {
return fileName.substring(0, point);
}
}
/**
* 得到路径分隔符在文件路径中首次出现的位置。
* 对于DOS或者UNIX风格的分隔符都可以。
* @param fileName 文件路径
* @return 路径分隔符在路径中首次出现的位置，没有出现时返回-1。
* @since 1.0
*/
public static int getPathIndex(String fileName) {
int point = fileName.indexOf('/');
if (point == -1) {
point = fileName.indexOf('\\');
}
return point;
}
/**
* 得到路径分隔符在文件路径中指定位置后首次出现的位置。
* 对于DOS或者UNIX风格的分隔符都可以。
* @param fileName 文件路径
* @param fromIndex 开始查找的位置
* @return 路径分隔符在路径中指定位置后首次出现的位置，没有出现时返回-1。
* @since 1.0
*/
public static int getPathIndex(String fileName, int fromIndex) {
int point = fileName.indexOf('/', fromIndex);
if (point == -1) {
point = fileName.indexOf('\\', fromIndex);
}
return point;
}
/**
* 得到路径分隔符在文件路径中最后出现的位置。
* 对于DOS或者UNIX风格的分隔符都可以。
* @param fileName 文件路径
* @return 路径分隔符在路径中最后出现的位置，没有出现时返回-1。
* @since 1.0
*/
public static int getPathLsatIndex(String fileName) {
int point = fileName.lastIndexOf('/');
if (point == -1) {
point = fileName.lastIndexOf('\\');
}
return point;
}
/**
* 得到路径分隔符在文件路径中指定位置前最后出现的位置。
* 对于DOS或者UNIX风格的分隔符都可以。
* @param fileName 文件路径
* @param fromIndex 开始查找的位置
* @return 路径分隔符在路径中指定位置前最后出现的位置，没有出现时返回-1。
* @since 1.0
*/
public static int getPathLsatIndex(String fileName, int fromIndex) {
int point = fileName.lastIndexOf('/', fromIndex);
if (point == -1) {
point = fileName.lastIndexOf('\\', fromIndex);
}
return point;
}
/**
* 将文件名中的类型部分去掉。
* @param filename 文件名
* @return 去掉类型部分的结果
* @since 1.0
*/
public static String trimType(String filename) {
int index = filename.lastIndexOf(".");
if (index != -1) {
return filename.substring(0, index);
}
else {
return filename;
}
}
/**
* 得到相对路径。
* 文件名不是目录名的子节点时返回文件名。
* @param pathName 目录名
* @param fileName 文件名
* @return 得到文件名相对于目录名的相对路径，目录下不存在该文件时返回文件名
* @since 1.0
*/
public static String getSubpath(String pathName,String fileName) {
int index = fileName.indexOf(pathName);
if (index != -1) {
return fileName.substring(index + pathName.length() + 1);
}
else {
return fileName;
}
}
/**
* 检查给定目录的存在性
* 保证指定的路径可用，如果指定的路径不存在，那么建立该路径，可以为多级路径
* @param path
* @return 真假值
* @since 1.0
*/
public static final boolean pathValidate(String path)
{
//String path="d:/web/www/sub";
//System.out.println(path);
//path = getUNIXfilePath(path);
//path = ereg_replace("^\\/+", "", path);
//path = ereg_replace("\\/+$", "", path);
String[] arraypath = path.split("/");
String tmppath = "";
for (int i = 0; i < arraypath.length; i++)
{
tmppath += "/" + arraypath[i];
File d = new File(tmppath.substring(1));
if (!d.exists()) { //检查Sub目录是否存在
System.out.println(tmppath.substring(1));
if (!d.mkdir())
{
return false;
}
}
}
return true;
}
/**
* 读取文件的内容
* 读取指定文件的内容
* @param path 为要读取文件的绝对路径
* @return 以行读取文件后的内容。
* @since 1.0
*/
public static final String getFileContent(String path) throws IOException
{
String filecontent = "";
try {
File f = new File(path);
if (f.exists()) {
FileReader fr = new FileReader(path);
BufferedReader br = new BufferedReader(fr); //建立BufferedReader对象，并实例化为br
String line = br.readLine(); //从文件读取一行字符串
//判断读取到的字符串是否不为空
while (line != null) {
filecontent += line + "\n";
line = br.readLine(); //从文件中继续读取一行数据
}
br.close(); //关闭BufferedReader对象
fr.close(); //关闭文件
}
}
catch (IOException e) {
throw e;
}
return filecontent;
}
/**
* 根据内容生成文件
* @param path要生成文件的绝对路径，
* @param 文件的内容。
* @return 真假值
* @since 1.0
*/
public static final boolean genModuleTpl(String path, String modulecontent) throws IOException
{
path = getUNIXfilePath(path);
String[] patharray = path.split("\\/");
String modulepath = "";
for (int i = 0; i < patharray.length - 1; i++) {
modulepath += "/" + patharray[i];
}
File d = new File(modulepath.substring(1));
if (!d.exists()) {
if (!pathValidate(modulepath.substring(1))) {
return false;
}
}
try {
FileWriter fw = new FileWriter(path); //建立FileWriter对象，并实例化fw
//将字符串写入文件
fw.write(modulecontent);
fw.close();
}
catch (IOException e) {
throw e;
}
return true;
}
/**
* 获取图片文件的扩展名（发布系统专用）
* @param picname 为图片名称加上前面的路径不包括扩展名
* @return 图片的扩展名
* @since 1.0
*/
public static final String getPicExtendName(String pic_path)
{
pic_path = getUNIXfilePath(pic_path);
String pic_extend = "";
if (isFileExist(pic_path + ".gif"))
{
pic_extend = ".gif";
}
if (isFileExist(pic_path + ".jpeg"))
{
pic_extend = ".jpeg";
}
if (isFileExist(pic_path + ".jpg"))
{
pic_extend = ".jpg";
}
if (isFileExist(pic_path + ".png"))
{
pic_extend = ".png";
}
return pic_extend; //返回图片扩展名
}
//拷贝文件
public static final boolean CopyFile(File in, File out) throws Exception {
try {
FileInputStream fis = new FileInputStream(in);
FileOutputStream fos = new FileOutputStream(out);
byte[] buf = new byte[1024];
int i = 0;
while ((i = fis.read(buf)) != -1) {
fos.write(buf, 0, i);
}
fis.close();
fos.close();
return true;
} catch (IOException ie) {
ie.printStackTrace();
return false;
}
}
//拷贝文件
public static final boolean CopyFile(String infile, String outfile) throws Exception {
try {
File in = new File(infile);
File out = new File(outfile);
return CopyFile(in, out);
} catch (IOException ie) {
ie.printStackTrace();
return false;
}
}
/**
* 计算图片数量
* @param id
* @param dtime
* @return
*/
public static final int countPics(String id,String dtime,String extensions){
int counts = 0;
MyFileFilter mfilter = new MyFileFilter(extensions.split(","));
PropsUtil pu = new PropsUtil();
String PICROOT = pu.readSingleProps("DestinationsPICROOT").trim();
String path = PICROOT + "/"+dtime.substring(0, 10) + "/";
File lfile = new File(path);
String filename;
if(lfile.isDirectory()){
File[] files = lfile.listFiles(mfilter);
for(int i=0;i-1))
counts ++;
}
files = null;
}
filename = null;
lfile = null;
pu = null;
mfilter = null;
return counts;
}
} 4.IP处理类
/**
* IP处理类
*/
package com.gootrip.util;
/**
* @author advance
*
*/
import com.gootrip.database.*;
import java.sql.*;
public class IPDeal {
/**
* 通过ip地址查询地区名称
* @param strip
* @return ip所在地区名称
*/
public static String getArea(String strip){
Connection conn = null;
PreparedStatement pstmt = null;
String sql;
String strRtn = null;
try{
MyJdbc myjdbc = new MyJdbc();
conn = myjdbc.getConn();
sql = "select * from fullip where startip<='" + strip + "' and endip>='" + strip + "'";
pstmt = conn.prepareStatement(sql);
ResultSet rs = pstmt.executeQuery();
if(rs.next()){
strRtn = rs.getString("country");
}else{
strRtn = "未确定";
}
rs.close();
rs = null;
}catch(Exception e){
e.printStackTrace();
}finally{
if (pstmt != null)
try{
pstmt.close();
pstmt = null;
}catch(Exception e){}
if (conn != null)
try{
conn.close();
conn = null;
}catch(Exception e){}
}
return strRtn;
}
/**
* 把ip地址格式化为：000.000.000.000
* @param ip
* @return 返回规格ip
*/
public static String strfullip(String ip){
StringBuffer buff = new StringBuffer();
buff.append("");
String strzero = "000";
int ilen = 0;
if(ip != null){
String[] arrip = ip.split("\\.");
if(arrip.length == 4){
for(int i = 0; i < 4; i++){
if (i==0){
ilen = arrip[i].length();
if(ilen < 3){
buff.append(strzero.substring(0,3-ilen)).append(arrip[i]);
}else{
buff.append(arrip[i]);
}
}else{
ilen = arrip[i].length();
if(ilen < 3){
buff.append(".").append(strzero.substring(0,3-ilen)).append(arrip[i]);
}else{
buff.append(".").append(arrip[i]);
}
}
}
}
}
return buff.toString();
}
/**
* @param args
*/
public static void main(String[] args) {
String strip = "202.108.33.32";
System.out.println(IPDeal.strfullip(strip));
System.out.println(System.currentTimeMillis());
System.out.println("ip" + strip + "所在地区：" + IPDeal.getArea(IPDeal.strfullip(strip)));
System.out.println(System.currentTimeMillis());
}
}5.正则表达式应用类
package com.gootrip.util;
import java.util.*;
import java.util.regex.*;
/**
* 这是个正则表达式应用类，用来匹配和替换字串用的
* @author
* @version
*/
public class RegExUtil {
/**
* 要求大小写都匹配正则表达式
* @param pattern 正则表达式模式
* @param str 要匹配的字串
* @return boolean值
* @since 1.0
*/
public static final boolean ereg(String pattern, String str) throws PatternSyntaxException
{
try
{
Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher(str);
return m.find();
}
catch (PatternSyntaxException e)
{
throw e;
}
}
/**
* 匹配且替换字串
* @param pattern 正则表达式模式
* @param newstr 要替换匹配到的新字串
* @param str 原始字串
* @return 匹配后的字符串
* @since 1.0
*/
public static final String ereg_replace(String pattern, String newstr, String str) throws PatternSyntaxException
{
try
{
Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher(str);
return m.replaceAll(newstr);
}
catch (PatternSyntaxException e)
{
throw e;
}
}
/**
* 主要用于模板中模块标记分析函数 把查找到的元素加到vector中
* @param pattern为正则表达式模式
* @param str 原始字串
* @return vector
* @since 1.0
*/
public static final Vector splitTags2Vector(String pattern, String str) throws PatternSyntaxException
{
Vector vector = new Vector();
try {
Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher(str);
while (m.find())
{
vector.add(ereg_replace("(\\[\\#)|(\\#\\])", "", m.group()));
}
return vector;
}
catch (PatternSyntaxException e) {
throw e;
}
}
/**
* 模块标记分析函数
* 功能主要是把查找到的元素加到vector中
* @param pattern为正则表达式模式
* @param str 原始字串
* @since 1.0
*/
public static final String[] splitTags(String pattern, String str)
{
try {
Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher(str);
String[] array = new String[m.groupCount()];
int i = 0;
while (m.find())
{
array[i] = ereg_replace("(\\[\\#)|(\\#\\])", "", m.group());
i++;
}
return array;
}
catch (PatternSyntaxException e) {
throw e;
}
}
/**
* 匹配所有符合模式要求的字串并加到矢量vector数组中
* @param pattern为正则表达式模式
* @param str 原始字串
* @return vector
* @since 1.0
*/
public static final Vector regMatchAll2Vector(String pattern, String str) throws PatternSyntaxException
{
Vector vector = new Vector();
try
{
Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher(str);
while (m.find())
{
vector.add(m.group());
}
return vector;
}
catch (PatternSyntaxException e)
{
throw e;
}
}
/**
* 匹配所有符合模式要求的字串并加到字符串数组中
* @param pattern为正则表达式模式
* @param str 原始字串
* @return array
* @since 1.0
*/
public static final String[] regMatchAll2Array(String pattern, String str) throws PatternSyntaxException
{
try
{
Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher(str);
String[] array = new String[m.groupCount()];
int i = 0;
while (m.find())
{
array[i] = m.group();
i++;
}
return array;
}
catch (PatternSyntaxException e)
{
throw e;
}
}
/**
* 转义正则表达式字符(之所以需要将\和$字符用escapeDollarBackslash方法的方式是因为用repalceAll是不行的，简单的试试"$".repalceAll("\\$","\\\\$")你会发现这个调用会导致数组越界错误)
* @param pattern为正则表达式模式
* @param str 原始字串
* @return array
* @since 1.0
*/
public static String escapeDollarBackslash(String original) {
StringBuffer buffer=new StringBuffer(original.length());
for (int i=0;i6.上传文件类
/**
* 上传文件类
*/
package com.gootrip.util;
/**
* @author advance
*
*/
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.io.PrintWriter;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class UploadHelper {
public final static String separator = "/";
public final static String split = "_";
protected final Log log = LogFactory.getLog(getClass());
class FilenameFilterImpl implements FilenameFilter
{
private String filter = ".";
public FilenameFilterImpl(String aFilter)
{
filter = aFilter;
}
public boolean accept(File dir, String name)
{
return name.startsWith(filter);
}
};
/**
* 获得当前的文件路径（通过当前日期生成）
* @param basePath
* @return
*/
public static String getNowFilePath(String basePath){
SimpleDateFormat formater =new SimpleDateFormat("yyyy-MM-dd");
String pathName = formater.format(new Date());
File dir = new File(basePath + separator + pathName);
if(!dir.exists())
dir.mkdir();
return pathName;
}
public static String getNewFileName(String oldFileName){
oldFileName = oldFileName.replaceAll("'", "").replaceAll("\"", "");
Calendar date = Calendar.getInstance();
int hour = date.get(Calendar.HOUR_OF_DAY);
int minute = date.get(Calendar.MINUTE);
int second = date.get(Calendar.SECOND);
if(oldFileName.length()>30)
oldFileName = oldFileName.substring(oldFileName.length()-30);
return (new Integer(hour*3600 + minute*60 + second).toString())
+ split + oldFileName;
}
public static String getThumbFileName(String fileName){
int pos = fileName.lastIndexOf(".");
if(pos>=0)
return fileName.substring(0, pos) + "s" + fileName.substring(pos);
else
return fileName + "s";
}
/**
* This method checks if the given file exists on disk. If it does it's ignored because
* that means that the file is allready cached on the server. If not we dump
* the text on it.
*/
public void dumpAttributeToFile(String attributeValue, String fileName, String filePath) throws Exception
{
File outputFile = new File(filePath + separator + fileName);
PrintWriter pw = new PrintWriter(new FileWriter(outputFile));
pw.println(attributeValue);
pw.close();
}
/**
* 保存文件
* This method checks if the given file exists on disk. If it does it's ignored because
* that means that the file is allready cached on the server. If not we take out the stream from the
* digitalAsset-object and dumps it.
*/
public void dumpAsset(File file, String fileName, String filePath) throws Exception
{
long timer = System.currentTimeMillis();
File outputFile = new File(filePath + separator + fileName);
if(outputFile.exists())
{
log.info("The file allready exists so we don't need to dump it again..");
return;
}
FileOutputStream fis = new FileOutputStream(outputFile);
BufferedOutputStream bos = new BufferedOutputStream(fis);
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
int character;
while ((character = bis.read()) != -1)
{
bos.write(character);
}
bos.flush();
bis.close();
fis.close();
bos.close();
log.info("Time for dumping file " + fileName + ":" + (System.currentTimeMillis() - timer));
}
/**
* 保存缩略图
* This method checks if the given file exists on disk. If it does it's ignored because
* that means that the file is allready cached on the server. If not we take out the stream from the
* digitalAsset-object and dumps a thumbnail to it.
*/
public void dumpAssetThumbnail(File file, String fileName, String thumbnailFile, String filePath, int width, int height, int quality) throws Exception
{
long timer = System.currentTimeMillis();
log.info("fileName:" + fileName);
log.info("thumbnailFile:" + thumbnailFile);
File outputFile = new File(filePath + separator + thumbnailFile);
if(outputFile.exists())
{
log.info("The file allready exists so we don't need to dump it again..");
return;
}
ThumbnailGenerator tg = new ThumbnailGenerator();
tg.transform(filePath + separator + fileName, filePath + separator + thumbnailFile, width, height, quality);
log.info("Time for dumping file " + fileName + ":" + (System.currentTimeMillis() - timer));
}
/**
* This method removes all images in the digitalAsset directory which belongs to a certain digital asset.
*/
public void deleteDigitalAssets(String filePath, String filePrefix) throws Exception
{
try
{
File assetDirectory = new File(filePath);
File[] files = assetDirectory.listFiles(new FilenameFilterImpl(filePrefix));
for(int i=0; i7.StringUtils
import java.io.UnsupportedEncodingException;
public class StringUtil
{
public static String convertAscIIToUnicode(byte[] paramArrayOfByte)
{
try
{
byte[] arrayOfByte = filterAndCut(paramArrayOfByte);
String str2;
if (arrayOfByte != null)
str2 = new String(arrayOfByte, "ISO-8859-1");
for (str1 = str2; ; str1 = "")
return str1.trim();
}
catch (UnsupportedEncodingException localUnsupportedEncodingException)
{
while (true)
String str1 = null;
}
}
public static String convertBig5ToUnicode(byte[] paramArrayOfByte)
{
try
{
byte[] arrayOfByte = filterAndCut(paramArrayOfByte);
String str2;
if (arrayOfByte != null)
str2 = new String(arrayOfByte, "big5");
for (str1 = str2; ; str1 = "")
return str1.trim();
}
catch (UnsupportedEncodingException localUnsupportedEncodingException)
{
while (true)
String str1 = null;
}
}
public static String convertGbkToUnicode(byte[] paramArrayOfByte)
{
try
{
byte[] arrayOfByte = filterAndCut(paramArrayOfByte);
String str2;
if (arrayOfByte != null)
str2 = new String(arrayOfByte, "GBK");
for (str1 = str2; ; str1 = "")
return str1.trim();
}
catch (UnsupportedEncodingException localUnsupportedEncodingException)
{
while (true)
String str1 = null;
}
}
public static byte[] convertToUnicode(String paramString)
{
((byte[])null);
try
{
byte[] arrayOfByte1 = paramString.getBytes("utf-8");
int i = arrayOfByte1.length;
byte[] arrayOfByte2 = new byte[i + 1];
for (int j = 0; ; j++)
{
if (j >= i)
{
arrayOfByte2[i] = 0;
return arrayOfByte2;
}
arrayOfByte2[j] = arrayOfByte1[j];
}
}
catch (UnsupportedEncodingException localUnsupportedEncodingException)
{
}
return (byte[])null;
}
public static byte[] convertUnicodeToAscii(String paramString)
{
((byte[])null);
try
{
int i = paramString.length();
byte[] arrayOfByte1 = paramString.getBytes("US-ASCII");
byte[] arrayOfByte2 = new byte[i + 1];
for (int j = 0; ; j++)
{
if (j >= i)
{
arrayOfByte2[i] = 0;
return arrayOfByte2;
}
arrayOfByte2[j] = arrayOfByte1[j];
}
}
catch (UnsupportedEncodingException localUnsupportedEncodingException)
{
}
return (byte[])null;
}
public static byte[] convertUnicodeToGbk(String paramString)
{
((byte[])null);
try
{
byte[] arrayOfByte1 = paramString.getBytes("GBK");
int i = arrayOfByte1.length;
byte[] arrayOfByte2 = new byte[i + 1];
for (int j = 0; ; j++)
{
if (j >= i)
{
arrayOfByte2[i] = 0;
return arrayOfByte2;
}
arrayOfByte2[j] = arrayOfByte1[j];
}
}
catch (UnsupportedEncodingException localUnsupportedEncodingException)
{
}
return (byte[])null;
}
public static byte[] filter(byte[] paramArrayOfByte)
{
int i = paramArrayOfByte.length;
byte[] arrayOfByte = new byte[i];
int j = 0;
int k = 0;
if (j >= i)
return arrayOfByte;
int m;
if (paramArrayOfByte[j] == 13)
m = k;
while (true)
{
j++;
k = m;
break;
m = k + 1;
arrayOfByte[k] = paramArrayOfByte[j];
}
}
public static byte[] filterAndCut(byte[] paramArrayOfByte)
{
int i = strlen(paramArrayOfByte);
if (i < 1)
{
arrayOfByte = null;
return arrayOfByte;
}
byte[] arrayOfByte = new byte[i];
int j = 0;
int k = 0;
label23: int m;
if (j < i)
{
if (paramArrayOfByte[j] != 13)
break label50;
m = k;
}
while (true)
{
j++;
k = m;
break label23;
break;
label50: m = k + 1;
arrayOfByte[k] = paramArrayOfByte[j];
}
}
public static int strlen(byte[] paramArrayOfByte)
{
int i = -1;
if (paramArrayOfByte != null)
{
if (paramArrayOfByte.length != 0)
break label15;
i = 0;
}
while (true)
{
return i;
label15: for (int j = 0; j < paramArrayOfByte.length; j++)
if (paramArrayOfByte[j] == 0)
return j;
}
}
public void finalize()
{
}
}