java 常用工具类
1.UUID工具类
import java.util.UUID;
/**
* UUID工具类
* @author wbw
*
*/
public class UUIDUtil {
public static String uuid(){
return UUID.randomUUID().toString().replaceAll("-", "");
}
}import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import org.springframework.util.StringUtils;
public class DateUtil {
public static final String yyyy_MM_dd="yyyy-MM-dd";
public static final String yyyy_MM_dd_ZN="yyyy 年 MM 月 dd 日";
public static final String yyyy_MM_dd_ZN1="yyyy年MM月dd日";
public static final String yyyy_MM_dd_ZN2="yyyy年M月d日";
public static final String yyyy_MM_dd_HH="yyyy 年 MM 月 dd 日 HH 时";
public static final String yyyy_MM_dd_HH_mm="yyyy 年 MM 月 dd 日 HH 时mm分";
public static final String yyyy_MM_dd_HH_mm_ss="yyyy-MM-dd HH:mm:ss";
public static final String HH_mm_ss="HH:mm:ss";
public static final String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";
public static String dateToStr(String pattern){
SimpleDateFormat sdf = new SimpleDateFormat(pattern);
String str = sdf.format(new Date());
return str;
}
public static String dateToStr(){
return dateToStr(yyyy_MM_dd_HH_mm_ss);
}
public static String dateToStr(Date date){
return dateToStr(date, yyyy_MM_dd);
}
public static String dateToStr(Date date,String pattern){
if(date == null){
return "";
}
SimpleDateFormat sdf = new SimpleDateFormat(pattern);
String str = sdf.format(date);
return str;
}
/**
* 时间String转Date
* @param date
* @param pattern
* @return
* @throws ParseException
* @throws Exception
*/
public static Date strToDate(String date,String pattern) throws ParseException{
DateFormat format = new SimpleDateFormat(pattern);
return format.parse(date);
}
/**
* 时间String转Date
* 默认 转化类型 yyyy-MM-dd
* @param date
* @return
* @throws Exception
*/
public static Date strToDate(String date)throws Exception{
return strToDate(date, yyyy_MM_dd);
}
/**
* 得到当前时间
* @return yyyy-MM-dd HH:mm:ss
* @throws Exception
*/
public static Date getCurrDate() throws Exception{
String dateStr = dateToStr(yyyy_MM_dd_HH_mm_ss);
SimpleDateFormat sdf = new SimpleDateFormat(yyyy_MM_dd_HH_mm_ss);
return sdf.parse(dateStr);
}
public static int getLastDayOfMonth(int year, int month) {
Calendar cal = Calendar.getInstance();
cal.set(Calendar.YEAR, year);
cal.set(Calendar.MONTH, month);
return cal.getActualMaximum(Calendar.DATE);
}
public static int getFirstDayOfMonth(int year, int month) {
Calendar cal = Calendar.getInstance();
cal.set(Calendar.YEAR, year);
cal.set(Calendar.MONTH, month);
return cal.getMinimum(Calendar.DATE);
}
/**
* 比较两个日期
* @param start
* @param end
* @return
* start > end 则返回 1
* start = end 则返回 0
* start < end 则返回 -1
*/
public static int dateCompare(Date start, Date end) throws Exception{
if(start == null && end == null){
return 0;
}
if(start == null && end != null){
return -1;
}
if(start != null && end == null){
return 1;
}
Calendar cal= Calendar.getInstance();
cal.setTime(start);
Calendar ca2 = Calendar.getInstance();
ca2.setTime(end);
return cal.compareTo(ca2);
}
/**
* 判断一个时间是否在一段时间内
* @param start
* @param date 比较的日期
* @param end
* @return
* start <= date <= end 则返回 true
* 其他则返回false
*/
public static boolean dateInTwoDays(Date start, Date date, Date end) throws Exception{
if(start == null || end == null || date == null){
return false;
}
Calendar ca1= Calendar.getInstance();
ca1.setTime(start);
Calendar ca2 = Calendar.getInstance();
ca2.setTime(end);
Calendar ca3= Calendar.getInstance();
ca3.setTime(date);
if( ca2.compareTo(ca1) > -1 && ca3.compareTo(ca1) > -1 && ca2.compareTo(ca3) > -1){
return true;
}
return false;
}
/**
* 得到当前月的最后一天
* @return yyyy-MM-dd HH:mm:ss
*/
public static String getLastDayOfMonth() {
Calendar cal = Calendar.getInstance();
String yearMonth = cal.get(Calendar.YEAR)+ "-";
if((cal.get(Calendar.MONTH)+1) < 10){
yearMonth += "0"+(cal.get(Calendar.MONTH)+1);
}else{
yearMonth += (cal.get(Calendar.MONTH)+1);
}
return yearMonth + "-" + cal.getActualMaximum(Calendar.DATE) + " 23:59:59";
}
/**
* 得到当前月的第一天
* @return yyyy-MM-dd HH:mm:ss
*/
public static String getFirstDayOfMonth() {
Calendar cal = Calendar.getInstance();
String yearMonth = cal.get(Calendar.YEAR)+ "-";
if((cal.get(Calendar.MONTH)+1) < 10){
yearMonth += "0"+(cal.get(Calendar.MONTH)+1);
}else{
yearMonth += (cal.get(Calendar.MONTH)+1);
}
return yearMonth + "-01 00:00:00";
}
/**
* 得到当前年
* @return yyyy
*/
public static String getNowYear() {
Calendar cal = Calendar.getInstance();
return cal.get(Calendar.YEAR) + "";
}
public static int getYearByDate(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
return cal.get(Calendar.YEAR);
}
/**
* 得到当前月
* @return mm
*/
public static String getNowMonth() {
Calendar cal = Calendar.getInstance();
return cal.get(Calendar.MONTH) + "";
}
public static int getMonthByDate(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
return cal.get(Calendar.MONTH);
}
/**
* 得到当前日
* @return mm
*/
public static String getNowDay() {
Calendar cal = Calendar.getInstance();
return cal.get(Calendar.DATE) + "";
}
public static int getDayByDate(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
return cal.get(Calendar.DATE);
}
/**
* 根据年月日得到日期
* @return mm
*/
public static Date getDate(int year,int month, int date) {
Calendar cal = Calendar.getInstance();
cal.set(year, month, date);
return cal.getTime();
}
/**
* 计算两个日期将的天数
* @param startDate
* @param endDate
* @return 天数
*/
public static int daysBetween(Date startDate, Date endDate) {
try {
if(startDate == null || endDate == null){
return 0;
}
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
startDate = sdf.parse(sdf.format(startDate));
endDate = sdf.parse(sdf.format(endDate));
Calendar cal = Calendar.getInstance();
cal.setTime(startDate);
long time1 = cal.getTimeInMillis ();
cal.setTime(endDate);
long time2 = cal.getTimeInMillis ();
long between_days=(time2-time1)/ (1000*3600*24);
return Integer.parseInt(String.valueOf (between_days));
} catch (Exception e) {
e.printStackTrace();
}
return 0;
}
/**
* 计算年龄
* @param csrq 出生日期
* @return
*/
public static int calculationAge(Date csrq) {
try {
if(csrq == null ){
return 0;
}
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
String csyear = sdf.format(csrq).substring(0, 4);
String nowYear = getNowYear();
return Integer.valueOf(nowYear) - Integer.valueOf(csyear);
} catch (Exception e) {
e.printStackTrace();
}
return 0;
}
/**
* 验证开始时间是否小于结束时间
* @param startDate
* 开始时间
* @param endDate
* 结束时间
* @throws Exception
*/
public static void checkTime(Date startDate, Date endDate) throws Exception {
if(startDate==null){
throw new RuntimeException("开始时间不能为空");
}
if(endDate==null){
throw new RuntimeException("结束时间不能为空");
}
if(startDate.after(endDate)){
throw new RuntimeException("开始时间不能大于结束时间");
}
}
}
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
public class SpringWebUtil {
/**
* 全局删除id标示
*/
public static String GLOB_DELETE_ID_VAL = "globDeleteIdVal";
public static HttpServletRequest getRequest(){
ServletRequestAttributes requestAttributes = (ServletRequestAttributes)RequestContextHolder.getRequestAttributes();
return requestAttributes==null? null : requestAttributes.getRequest();
}
public static HttpSession getSession(){
return getRequest().getSession(false);
}
public static String getRealRootPath(){
return getRequest().getServletContext().getRealPath("/");
}
public static String getIp() {
ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder
.getRequestAttributes();
if(servletRequestAttributes!=null){
HttpServletRequest request = servletRequestAttributes.getRequest();
return request.getRemoteAddr();
}
return null;
}
public static Object getSessionAttribute(String name){
HttpServletRequest request = getRequest();
return request == null?null:request.getSession().getAttribute(name);
}
public static void setSessionAttribute(String name,Object value){
HttpServletRequest request = getRequest();
if(request!=null){
request.getSession().setAttribute(name, value);
}
}
public static Object getRequestAttribute(String name){
HttpServletRequest request = getRequest();
return request == null?null:request.getAttribute(name);
}
public static void setRequestAttribute(String name,Object value){
HttpServletRequest request = getRequest();
if(request!=null){
request.setAttribute(name, value);
}
}
public static String getContextPath() {
return getRequest().getContextPath();
}
public static void removeSessionAttribute(String name) {
getRequest().getSession().removeAttribute(name);
}
}4.Bean工具类：
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.List;
import org.springframework.beans.BeansException;
import org.springframework.beans.FatalBeanException;
import org.springframework.util.Assert;
public class BeanUtils extends org.springframework.beans.BeanUtils {
public static void copyNotNullProperties(Object source, Object target){
copyNotNullProperties(source, target,null,null);
}
public static void copyNotNullProperties(Object source, Object target, String...ignoreProperties)
throws BeansException {
copyNotNullProperties(source, target, null, ignoreProperties);
}
public static void copyNotNullProperties(Object source, Object target, Class editable, String[] ignoreProperties){
Assert.notNull(source, "Source must not be null");
Assert.notNull(target, "Target must not be null");
Class actualEditable = target.getClass();
if (editable != null) {
if (!editable.isInstance(target)) {
throw new IllegalArgumentException("Target class [" + target.getClass().getName() +
"] not assignable to Editable class [" + editable.getName() + "]");
}
actualEditable = editable;
}
PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);
List ignoreList = (ignoreProperties != null) ? Arrays.asList(ignoreProperties) : null;
for (PropertyDescriptor targetPd : targetPds) {
if (targetPd.getWriteMethod() != null &&
(ignoreProperties == null || (!ignoreList.contains(targetPd.getName())))) {
PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());
if (sourcePd != null && sourcePd.getReadMethod() != null) {
try {
Method readMethod = sourcePd.getReadMethod();
if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {
readMethod.setAccessible(true);
}
Object value = readMethod.invoke(source);
if(value!=null){
Method writeMethod = targetPd.getWriteMethod();
if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {
writeMethod.setAccessible(true);
}
writeMethod.invoke(target, value);
}
}
catch (Throwable ex) {
throw new FatalBeanException("Could not copy properties from source to target", ex);
}
}
}
}
}
}
import java.util.Map;
import org.springframework.cglib.beans.BeanGenerator;
import org.springframework.cglib.beans.BeanMap;
public class CglibBeanUtil {
/**
* 实体Object
*/
public Object object = null;
/**
* 属性map
*/
public BeanMap beanMap = null;
public CglibBeanUtil() {
}
public CglibBeanUtil(Map> propertyMap) {
this.object = generateBean(propertyMap);
this.beanMap = BeanMap.create(this.object);
}
/**
* 给bean属性赋值
* @param property 属性名
* @param value 值
*/
public void setValue(String property, Object value) {
beanMap.put(property, value);
}
/**
* 通过属性名得到属性值
* @param property 属性名
* @return 值
*/
public Object getValue(String property) {
return beanMap.get(property);
}
/**
* 得到该实体bean对象
* @return
*/
public Object getObject() {
return this.object;
}
private Object generateBean(Map> propertyMap) {
BeanGenerator generator = new BeanGenerator();
for (String key : propertyMap.keySet()) {
generator.addProperty(key, propertyMap.get(key));
}
return generator.create();
}
}
public class ExceptionUtil {
/**
*
* 将异常堆栈信息以字符串的格式返回
*
*
* @param e 异常对象
* @return
*/
public static String createStackTrackMessage(Exception e) {
StringBuffer messsage = new StringBuffer();
if (e != null) {
messsage.append(e.getClass()).append(": ").append(e.getMessage()).append("\n");
StackTraceElement[] elements = e.getStackTrace();
for (StackTraceElement stackTraceElement : elements) {
messsage.append("\t").append(stackTraceElement.toString()).append("\n");
}
}
return messsage.toString();
}
}
import javax.servlet.http.Cookie;
import com.bjhy.platform.commons.consist.CommonConsist;
public class CookieUtil {
public static String getProperty(Cookie[] cookies, String name){
if(cookies == null) return null;
for (Cookie cookie : cookies) {
if(cookie.getName().equals(name)){
return cookie.getValue();
}
}
return null;
}
public static String getAppToken(Cookie[] cookies){
return getProperty(cookies, CommonConsist.TOKEN_COOKIE);
}
public static boolean containsPropery(Cookie[] cookies, String name){
if(cookies == null) return false;
for (Cookie cookie : cookies) {
if(cookie.getName().equals(name)){
return true;
}
}
return false;
}
public static boolean containsAppToken(Cookie[] cookies){
return containsPropery(cookies, CommonConsist.TOKEN_COOKIE);
}
}
package com.my.hibernate;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
/**
* hibernate4工具类
* @author wbw
*
*/
@SuppressWarnings("deprecation")
public class Hibernate4Util {
private static final SessionFactory sessionFactory;
/**
* 初始化hibernate
*/
static
{
try
{
Configuration cfg = new Configuration().configure();
ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(cfg.getProperties()).build();
sessionFactory = cfg.buildSessionFactory(serviceRegistry);
}
catch (Throwable e)
{
throw new ExceptionInInitializerError(e);
}
}
private Hibernate4Util(){}
/**
* 获取开着的session
* @return
*/
public static Session getSession(){
//*openSession必须关闭，currentSession在事务结束后自动关闭
// *openSession没有和当前线程绑定，currentSession和当前线程绑定
// return sessionFactory.openSession();
return sessionFactory.getCurrentSession();
}
/**
* 关闭sessionFactory
*/
public static void closeSession(){
sessionFactory.close();
}
/**
* 获取SessionFactory
* @return
*/
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
}package com.my.hibernate;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
/**
* hibernate4工具类
* @author wbw
*
*/
@SuppressWarnings("deprecation")
public class Hibernate3Util {
private static final SessionFactory sessionFactory;
/**
* 初始化hibernate
*/
static
{
try
{
//此方法已经过时
sessionFactory = new Configuration().configure().buildSessionFactory();
}
catch (Throwable e)
{
throw new ExceptionInInitializerError(e);
}
}
private Hibernate3Util(){}
/**
* 获取开着的session
* @return
*/
public static Session getSession(){
//*openSession必须关闭，currentSession在事务结束后自动关闭
// *openSession没有和当前线程绑定，currentSession和当前线程绑定
// return sessionFactory.openSession();
return sessionFactory.getCurrentSession();
}
/**
* 关闭sessionFactory
*/
public static void closeSession(){
sessionFactory.close();
}
/**
* 获取SessionFactory
* @return
*/
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
}/**
* 日志对象
* @author wbw
*
*/
public class LoggerUtils {
/**
* log对象
*/
private static org.apache.log4j.Logger log = org.apache.log4j.Logger.getRootLogger();
/**
* 日志信息
* @param message 输出信息
*/
final public static void info(Object message) {
log.info(message);
}
/**
* 调试信息
* @param message 输出信息
*/
final public static void debug(Object message) {
log.debug(message);
}
/**
* 错误信息
* @param message 输出信息
*/
final public static void error(Object message) {
log.error(message);
}
/**
* 警告信息
* @param message 输出信息
*/
final public static void warn(Object message) {
log.warn(message);
}
/**
* 严重错误信息
* @param message 输出信息
*/
final public static void fatal(Object message) {
log.fatal(message);
}
}
import java.math.BigDecimal;
/**
*/
public class Arith { // 默认除法运算精度
/**
* DEF_DIV_SCALE
*/
private static final int DEF_DIV_SCALE = 10; // 这个类不能实例化
/**
* scaleStr
*/
private static String scaleStr = "小数位数必须为大于等于0的正整数";
/**
* 提供精确的加法运算。
*
* @param v1
* 被加数
* @param v2
* 加数
* @return 两个参数的和
*/
public static double add(double v1, double v2) {
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.add(b2).doubleValue();
}
/**
* 提供精确的减法运算。
*
* @param v1
* 被减数
* @param v2
* 减数
* @return 两个参数的差
*/
public static double sub(double v1, double v2) {
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.subtract(b2).doubleValue();
}
/**
* 提供精确的乘法运算。
*
* @param v1
* 被乘数
* @param v2
* 乘数
* @return 两个参数的积
*/
public static double mul(double v1, double v2) {
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.multiply(b2).doubleValue();
}
/**
* 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 小数点以后10位，以后的数字四舍五入。
*
* @param v1
* 被除数
* @param v2
* 除数
* @return 两个参数的商
*/
public static double div(double v1, double v2) {
return div(v1, v2, DEF_DIV_SCALE);
}
/**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。
*
* @param v1
* 被除数
* @param v2
* 除数
* @param scale
* 表示表示需要精确到小数点以后几位。
* @return 两个参数的商
*/
public static double div(double v1, double v2, int scale) {
if (scale < 0) {
throw new IllegalArgumentException(scaleStr);
}
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
}
/**
* 提供精确的小数位四舍五入处理。
*
* @param v
* 需要四舍五入的数字
* @param scale
* 小数点后保留几位
* @return 四舍五入后的结果
*/
public static double round(double v, int scale) {
if (scale < 0) {
throw new IllegalArgumentException(scaleStr);
}
BigDecimal b = new BigDecimal(Double.toString(v));
BigDecimal one = new BigDecimal("1");
return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
}
/**
* 对eval对象进行精度和小数位数控制
* @param object object
* @param scale scale
* @return double
*/
public static double roundForEval(Object object, int scale) {
if (scale < 0) {
throw new IllegalArgumentException(scaleStr);
}
return round(Double.valueOf(object.toString()), scale);
}
/**
* double类型转String 类型的小数点后的00
* @param num double参数
* @return String 类型
*/
public static String doubleTransform(double num){
String strNum = num+"";
int a = strNum.indexOf(".");
if(a>0){
//获取小数点后面的数字
String dianAfter = strNum.substring(a+1);
if("0".equals(dianAfter)){
return strNum+"0";
}else{
if(dianAfter.length()==1){
return strNum +"0";
}else{
return strNum;
}
}
}else{
return strNum+".00";
}
}
};11.File工具类，主要是用于存储数据到文件中,删除文件数据等操作
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.StringReader;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.filefilter.AndFileFilter;
import org.apache.commons.io.filefilter.DirectoryFileFilter;
import org.apache.commons.io.filefilter.IOFileFilter;
import org.apache.commons.io.filefilter.NotFileFilter;
import org.apache.commons.io.filefilter.SuffixFileFilter;
import org.apache.log4j.Logger;
public class FileUtil {
private static Logger logger = Logger.getLogger(FileUtil.class);
public static boolean string2File(String res, String filePath) {
boolean flag = true;
BufferedReader bufferedReader = null;
BufferedWriter bufferedWriter = null;
try {
File distFile = new File(filePath);
if (!distFile.getParentFile().exists()) {
distFile.getParentFile().mkdirs();
}
bufferedReader = new BufferedReader(new StringReader(res));
bufferedWriter = new BufferedWriter(new FileWriter(distFile));
char[] buf = new char[1024];
int len;
while ((len = bufferedReader.read(buf)) != -1) {
bufferedWriter.write(buf, 0, len);
}
bufferedWriter.flush();
bufferedReader.close();
bufferedWriter.close();
} catch (IOException e) {
flag = false;
logger.error("将字符串填充到文件失败", e);
}
return flag;
}
public static void copyFile(String resFilePath, String distFolder)
throws IOException {
File resFile = new File(resFilePath);
File distFile = new File(distFolder);
if (resFile.isDirectory()) {
FileUtils.copyDirectoryToDirectory(resFile, distFile);
} else if (resFile.isFile()) {
FileUtils.copyFileToDirectory(resFile, distFile, true);
}
}
public static void deleteFile(String targetPath) throws IOException {
File targetFile = new File(targetPath);
if (targetFile.isDirectory()) {
FileUtils.deleteDirectory(targetFile);
} else if (targetFile.isFile()) {
targetFile.delete();
}
}
public static void moveFile(String resFilePath, String distFolder)
throws IOException {
File resFile = new File(resFilePath);
File distFile = new File(distFolder);
if (resFile.isDirectory()) {
FileUtils.copyDirectory(resFile, distFile, true);
} else if (resFile.isFile()) {
FileUtils.copyDirectory(resFile, distFile, true);
}
}
public static long genFileSize(String distFilePath) {
File distFile = new File(distFilePath);
if (distFile.isFile()) {
return distFile.length();
}
if (distFile.isDirectory()) {
return FileUtils.sizeOfDirectory(distFile);
}
return -1L;
}
public static boolean isExist(String filePath) {
return new File(filePath).exists();
}
public static String[] listFilebySuffix(String folder, String suffix) {
IOFileFilter fileFilter1 = new SuffixFileFilter(suffix);
IOFileFilter fileFilter2 = new NotFileFilter(
DirectoryFileFilter.INSTANCE);
FilenameFilter filenameFilter = new AndFileFilter(fileFilter1,
fileFilter2);
return new File(folder).list(filenameFilter);
}
}
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Properties;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.TreeSet;
public abstract class StringUtils extends org.apache.commons.lang.StringUtils{
private static final String FOLDER_SEPARATOR = "/";
private static final String WINDOWS_FOLDER_SEPARATOR = "\\";
private static final String TOP_PATH = "..";
private static final String CURRENT_PATH = ".";
private static final char EXTENSION_SEPARATOR = '.';
public static String[] addStringToArray(String[] array, String str) {
if ((array == null) || (array.length < 0)) {
return new String[] { str };
}
String[] newArr = new String[array.length + 1];
System.arraycopy(array, 0, newArr, 0, array.length);
newArr[array.length] = str;
return newArr;
}
public static String applyRelativePath(String path, String relativePath) {
int separatorIndex = path.lastIndexOf("/");
if (separatorIndex != -1) {
String newPath = path.substring(0, separatorIndex);
if (!relativePath.startsWith("/")) {
newPath = newPath + "/";
}
return newPath + relativePath;
}
return relativePath;
}
public static String arrayToCommaDelimitedString(Object[] arr) {
return arrayToDelimitedString(arr, ",");
}
public static String arrayToDelimitedString(Object[] arr, String delim) {
if (arr == null) {
return "";
}
StringBuffer sb = new StringBuffer();
for (int i = 0; i < arr.length; i++) {
if (i > 0) {
sb.append(delim);
}
sb.append(arr[i]);
}
return sb.toString();
}
public static String capitalize(String str) {
return changeFirstCharacterCase(str, true);
}
private static String changeFirstCharacterCase(String str,
boolean capitalize) {
if ((str == null) || (str.length() == 0)) {
return str;
}
StringBuffer buf = new StringBuffer(str.length());
if (capitalize) {
buf.append(Character.toUpperCase(str.charAt(0)));
} else {
buf.append(Character.toLowerCase(str.charAt(0)));
}
buf.append(str.substring(1));
return buf.toString();
}
public static String cleanPath(String path) {
String pathToUse = replace(path, "\\", "/");
int prefixIndex = pathToUse.indexOf(":");
String prefix = "";
if (prefixIndex != -1) {
prefix = pathToUse.substring(0, prefixIndex + 1);
pathToUse = pathToUse.substring(prefixIndex + 1);
}
String[] pathArray = delimitedListToStringArray(pathToUse, "/");
List pathElements = new LinkedList();
int tops = 0;
for (int i = pathArray.length - 1; i >= 0; i--) {
if (!".".equals(pathArray[i])) {
if ("..".equals(pathArray[i])) {
tops++;
} else if (tops > 0) {
tops--;
} else {
pathElements.add(0, pathArray[i]);
}
}
}
for (int i = 0; i < tops; i++) {
pathElements.add(0, "..");
}
return prefix + collectionToDelimitedString(pathElements, "/");
}
public static String collectionToCommaDelimitedString(Collection coll) {
return collectionToDelimitedString(coll, ",");
}
public static String collectionToDelimitedString(Collection coll,
String delim) {
return collectionToDelimitedString(coll, delim, "", "");
}
public static String collectionToDelimitedString(Collection coll,
String delim, String prefix, String suffix) {
if (coll == null) {
return "";
}
StringBuffer sb = new StringBuffer();
Iterator it = coll.iterator();
int i = 0;
while (it.hasNext()) {
if (i > 0) {
sb.append(delim);
}
sb.append(prefix).append(it.next()).append(suffix);
i++;
}
return sb.toString();
}
public static Set commaDelimitedListToSet(String str) {
Set set = new TreeSet();
String[] tokens = commaDelimitedListToStringArray(str);
for (String element : tokens) {
set.add(element);
}
return set;
}
public static String[] commaDelimitedListToStringArray(String str) {
return delimitedListToStringArray(str, ",");
}
public static int countOccurrencesOf(String str, String sub) {
if ((str == null) || (sub == null) || (str.length() == 0)
|| (sub.length() == 0)) {
return 0;
}
int count = 0;
int pos = 0;
int idx = 0;
while ((idx = str.indexOf(sub, pos)) != -1) {
count++;
pos = idx + sub.length();
}
return count;
}
public static String delete(String inString, String pattern) {
return replace(inString, pattern, "");
}
public static String deleteAny(String inString, String charsToDelete) {
if ((inString == null) || (charsToDelete == null)) {
return inString;
}
StringBuffer out = new StringBuffer();
for (int i = 0; i < inString.length(); i++) {
char c = inString.charAt(i);
if (charsToDelete.indexOf(c) == -1) {
out.append(c);
}
}
return out.toString();
}
public static String[] delimitedListToStringArray(String str,
String delimiter) {
if (str == null) {
return new String[0];
}
if (delimiter == null) {
return new String[] { str };
}
List result = new ArrayList();
if ("".equals(delimiter)) {
for (int i = 0; i < str.length(); i++) {
result.add(str.substring(i, i + 1));
}
} else {
int pos = 0;
int delPos = 0;
while ((delPos = str.indexOf(delimiter, pos)) != -1) {
result.add(str.substring(pos, delPos));
pos = delPos + delimiter.length();
}
if ((str.length() > 0) && (pos <= str.length())) {
result.add(str.substring(pos));
}
}
return toStringArray(result);
}
public static boolean endsWithIgnoreCase(String str, String suffix) {
if ((str == null) || (suffix == null)) {
return false;
}
if (str.endsWith(suffix)) {
return true;
}
if (str.length() < suffix.length()) {
return false;
}
String lcStr = str.substring(str.length() - suffix.length())
.toLowerCase();
String lcSuffix = suffix.toLowerCase();
return lcStr.equals(lcSuffix);
}
public static String getFilename(String path) {
if (path == null) {
return null;
}
int separatorIndex = path.lastIndexOf("/");
return separatorIndex != -1 ? path.substring(separatorIndex + 1) : path;
}
public static String getFilenameExtension(String path) {
if (path == null) {
return null;
}
int sepIndex = path.lastIndexOf('.');
return sepIndex != -1 ? path.substring(sepIndex + 1) : null;
}
public static boolean hasLength(String str) {
return (str != null) && (str.length() > 0);
}
public static boolean hasText(String str) {
int strLen;
if ((str == null) || ((strLen = str.length()) == 0)) {
return false;
}
for (int i = 0; i < strLen; i++) {
if (!Character.isWhitespace(str.charAt(i))) {
return true;
}
}
return false;
}
public static Locale parseLocaleString(String localeString) {
String[] parts = tokenizeToStringArray(localeString, "_ ", false, false);
String language = parts.length > 0 ? parts[0] : "";
String country = parts.length > 1 ? parts[1] : "";
String variant = parts.length > 2 ? parts[2] : "";
return language.length() > 0 ? new Locale(language, country, variant)
: null;
}
public static boolean pathEquals(String path1, String path2) {
return cleanPath(path1).equals(cleanPath(path2));
}
public static String quote(String str) {
return str != null ? "'" + str + "'" : null;
}
public static Object quoteIfString(Object obj) {
return (obj instanceof String) ? quote((String) obj) : obj;
}
public static String[] removeDuplicateStrings(String[] array) {
if ((array == null) || (array.length < 0)) {
return array;
}
Set set = new TreeSet();
String[] arrayOfString = array;
int j = array.length;
for (int i = 0; i < j; i++) {
String element = arrayOfString[i];
set.add(element);
}
return toStringArray(set);
}
public static String replace(String inString, String oldPattern,
String newPattern) {
if (inString == null) {
return null;
}
if ((oldPattern == null) || (newPattern == null)) {
return inString;
}
StringBuffer sbuf = new StringBuffer();
int pos = 0;
int index = inString.indexOf(oldPattern);
int patLen = oldPattern.length();
while (index >= 0) {
sbuf.append(inString.substring(pos, index));
sbuf.append(newPattern);
pos = index + patLen;
index = inString.indexOf(oldPattern, pos);
}
sbuf.append(inString.substring(pos));
return sbuf.toString();
}
public static String[] sortStringArray(String[] array) {
if ((array == null) || (array.length < 0)) {
return new String[0];
}
Arrays.sort(array);
return array;
}
public static String[] split(String toSplit, String delimiter) {
if ((!hasLength(toSplit)) || (!hasLength(delimiter))) {
return null;
}
int offset = toSplit.indexOf(delimiter);
if (offset < 0) {
return null;
}
String beforeDelimiter = toSplit.substring(0, offset);
String afterDelimiter = toSplit.substring(offset + delimiter.length());
return new String[] { beforeDelimiter, afterDelimiter };
}
public static Properties splitArrayElementsIntoProperties(String[] array,
String delimiter) {
return splitArrayElementsIntoProperties(array, delimiter, null);
}
public static Properties splitArrayElementsIntoProperties(String[] array,
String delimiter, String charsToDelete) {
if ((array == null) || (array.length == 0)) {
return null;
}
Properties result = new Properties();
String[] arrayOfString1 = array;
int j = array.length;
for (int i = 0; i < j; i++) {
String element = arrayOfString1[i];
if (charsToDelete != null) {
element = deleteAny(element, charsToDelete);
}
String[] splittedElement = split(element, delimiter);
if (splittedElement != null) {
result.setProperty(splittedElement[0].trim(),
splittedElement[1].trim());
}
}
return result;
}
public static boolean startsWithIgnoreCase(String str, String prefix) {
if ((str == null) || (prefix == null)) {
return false;
}
if (str.startsWith(prefix)) {
return true;
}
if (str.length() < prefix.length()) {
return false;
}
String lcStr = str.substring(0, prefix.length()).toLowerCase();
String lcPrefix = prefix.toLowerCase();
return lcStr.equals(lcPrefix);
}
public static String stripFilenameExtension(String path) {
if (path == null) {
return null;
}
int sepIndex = path.lastIndexOf('.');
return sepIndex != -1 ? path.substring(0, sepIndex) : path;
}
public static String[] tokenizeToStringArray(String str, String delimiters) {
return tokenizeToStringArray(str, delimiters, true, true);
}
public static String[] tokenizeToStringArray(String str, String delimiters,
boolean trimTokens, boolean ignoreEmptyTokens) {
if (str == null) {
return new String[0];
}
StringTokenizer st = new StringTokenizer(str, delimiters);
List tokens = new ArrayList();
while (st.hasMoreTokens()) {
String token = st.nextToken();
if (trimTokens) {
token = token.trim();
}
if ((!ignoreEmptyTokens) || (token.length() > 0)) {
tokens.add(token);
}
}
return toStringArray(tokens);
}
public static String[] toStringArray(Collection collection) {
if (collection == null) {
return null;
}
return (String[]) collection.toArray(new String[collection.size()]);
}
public static String trimLeadingWhitespace(String str) {
if (!hasLength(str)) {
return str;
}
StringBuffer buf = new StringBuffer(str);
while ((buf.length() > 0) && (Character.isWhitespace(buf.charAt(0)))) {
buf.deleteCharAt(0);
}
return buf.toString();
}
public static String trimTrailingWhitespace(String str) {
if (!hasLength(str)) {
return str;
}
StringBuffer buf = new StringBuffer(str);
while ((buf.length() > 0)
&& (Character.isWhitespace(buf.charAt(buf.length() - 1)))) {
buf.deleteCharAt(buf.length() - 1);
}
return buf.toString();
}
public static String trimWhitespace(String str) {
if (!hasLength(str)) {
return str;
}
StringBuffer buf = new StringBuffer(str);
do {
buf.deleteCharAt(0);
if (buf.length() <= 0) {
break;
}
} while (Character.isWhitespace(buf.charAt(0)));
while ((buf.length() > 0)
&& (Character.isWhitespace(buf.charAt(buf.length() - 1)))) {
buf.deleteCharAt(buf.length() - 1);
}
return buf.toString();
}
public static String uncapitalize(String str) {
return changeFirstCharacterCase(str, false);
}
public static String unqualify(String qualifiedName) {
return unqualify(qualifiedName, '.');
}
public static String unqualify(String qualifiedName, char separator) {
return qualifiedName
.substring(qualifiedName.lastIndexOf(separator) + 1);
}
}import java.io.File;
import java.util.Date;
import java.util.Properties;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeUtility;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.JavaMailSenderImpl;
import org.springframework.mail.javamail.MimeMessageHelper;
/**
* 邮件工具类
*
* @author chenjun
*
*/
public class EmailUtil {
private JavaMailSender javaMailSender;
private String username;
public EmailUtil(String host, int port, String username, String password) {
this.username = username;
JavaMailSenderImpl javaMailSenderImpl = new JavaMailSenderImpl();
javaMailSenderImpl.setHost(host);
javaMailSenderImpl.setPort(port);
javaMailSenderImpl.setUsername(username);
javaMailSenderImpl.setPassword(password);
Properties javaMailProperties = new Properties();
javaMailProperties.put("mail.smtp.auth", true);
javaMailProperties.put("prop", true);
javaMailProperties.put("mail.smtp.timeout", 25000);
javaMailSenderImpl.setJavaMailProperties(javaMailProperties);
javaMailSender = javaMailSenderImpl;
}
/**
* 发送文本内容
*
* @param to
* 目标邮箱
* @param subject
* 主题
* @param body
* 内容
*/
public void sendContent(String to, String subject, String body) {
SimpleMailMessage simpleMessage = new SimpleMailMessage();
simpleMessage.setFrom(username);// 发送人名片
simpleMessage.setTo(to);// 收件人邮箱
simpleMessage.setSubject(subject);// 邮件主题
simpleMessage.setSentDate(new Date());// 邮件发送时间
simpleMessage.setText(body);
javaMailSender.send(simpleMessage);
}
/**
* 发送文本内容，带附件
*
* @param to
* 目标邮箱
* @param subject
* 主题
* @param body
* 内容
* @param file
*/
public void sendContent(String to, String subject, String body, File file) {
sendContent(to, subject, body, new File[] { file });
}
/**
* 发送文本内容,带附件
*
* @param to
* 目标邮箱
* @param subject
* 主题
* @param body
* 内容
*/
public void sendContent(String to, String subject, String body, File[] files) {
if (files == null || files.length == 0) {
sendContent(to, subject, body);
} else {
try {
MimeMessage mimeMessage = javaMailSender.createMimeMessage();
MimeMessageHelper helper = new MimeMessageHelper(mimeMessage,
true, "UTF-8");
helper.setFrom(username);
helper.setTo(to);
helper.setSubject(subject);
helper.setText(body, true);
helper.setSentDate(new Date());
for (int i = 0; i < files.length; i++) {
helper.addAttachment(
MimeUtility.encodeText(files[i].getName()),
files[i]);
}
javaMailSender.send(mimeMessage);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.HanyuPinyinVCharType;
import org.apache.commons.lang.StringUtils;
/**
* @className:PinyingUtil.java
* @classDescription:拼音操作工具类
*/
public class PinYinUtil {
private static final String DEFAULT_SEPARATOR = "";
private static final String SPACE_SEPARATOR = " ";
static HanyuPinyinOutputFormat outputFormat = new HanyuPinyinOutputFormat();
static{
outputFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);
outputFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
outputFormat.setVCharType(HanyuPinyinVCharType.WITH_V);
}
public PinYinUtil() {
}
/**
* 根据汉字返回全拼和简拼的集合，默认用空格分隔
* @param hanyu
* @return
* @throws Exception
*/
public static Set hanyuToPyAndJp(String hanyu)throws Exception{
return hanyuToPyAndJp(hanyu, DEFAULT_SEPARATOR);
}
/**
* 根据汉字返回全拼和简拼的集合，按指定分隔符分隔
* @param hanyu
* @param separator
* @return
* @throws Exception
*/
public static Set hanyuToPyAndJp(String hanyu, String separator)
throws Exception {
Set resultSet = hanyuToPy(hanyu, separator);
separator = " ";
Set resultSet2 = hanyuToPy(hanyu, " ");
for (String pinyin : resultSet2) {
String[] items = pinyin.split(separator);
StringBuffer sb = new StringBuffer();
for (String item : items) {
sb.append(item.substring(0, 1));
}
resultSet.add(sb.toString());
}
return resultSet;
}
/**
* 根据汉字返回简拼的集合
* @param hanyu
* @return
* @throws Exception
*/
public static Set hanyuToJp(String hanyu) throws Exception {
String separator = " ";
Set resultSet = hanyuToPy(hanyu,separator);
Set jpSet = new HashSet();
for (String pinyin : resultSet) {
String[] items = pinyin.split(separator);
StringBuffer sb = new StringBuffer();
for (String item : items) {
sb.append(item.substring(0, 1));
}
jpSet.add(sb.toString());
}
return jpSet;
}
/**
* 根据汉字返回简拼的集合字符串，默认空格关联比如 ab bd
* @param hanyu
* @return
* @throws Exception
*/
public static String hanyuToJpStr(String hanyu) throws Exception {
return hanyuToJpStr(hanyu, " ");
}
/**
* 根据汉字返回简拼的集合字符串，按照指定关联符进行关联比如 ab,bd
* @param hanyu
* @param join
* @return
* @throws Exception
*/
public static String hanyuToJpStr(String hanyu,String join) throws Exception {
String separator = " ";
Set resultSet = hanyuToPy(hanyu,separator);
StringBuffer result = new StringBuffer();
Set jpSet = new HashSet();
for (String pinyin : resultSet) {
String[] items = pinyin.split(separator);
StringBuffer sb = new StringBuffer();
for (String item : items) {
if(StringUtils.isNotEmpty(item))
sb.append(item.substring(0, 1));
}
jpSet.add(sb.toString());
}
for (String jp : jpSet) {
result.append(jp).append(join);
}
return result.toString().trim();
}
/**
* 根据汉字返回拼音的集合
* @param hanyu
* @return
* @throws Exception
*/
public static Set hanyuToPy(String hanyu)
throws Exception {
return hanyuToPy(hanyu, DEFAULT_SEPARATOR);
}
/**
* 根据汉字返回拼音的集合字符串,默认空格关联比如 ab bd
* @param hanyu
* @return
* @throws Exception
*/
public static String hanyuToPyStr(String hanyu) throws Exception{
return hanyuToPyStr(hanyu, DEFAULT_SEPARATOR, SPACE_SEPARATOR);
}
public static String hanyuToPyStr(String hanyu,String separator,String dySeparator) throws Exception{
Set set = hanyuToPy(hanyu, separator);
StringBuffer sb = new StringBuffer();
for (String dy : set) {
sb.append(dy).append(dySeparator);
}
if(set.size()>0){
int index = sb.lastIndexOf(dySeparator);
sb.replace(index, sb.length(), "");
}
return sb.toString();
}
public static Set hanyuToPy(String hanyu, String separator)
throws Exception {
List list = new ArrayList();
Set resultSet = new HashSet();
if(StringUtils.isEmpty(hanyu))return resultSet;
for (int i = 0; i < hanyu.length(); i++) {
String[] pinyinArray = null;
char chineseChar = hanyu.charAt(i);
if (isHanzi(chineseChar)) {
pinyinArray = PinyinHelper.toHanyuPinyinStringArray(
chineseChar, outputFormat);
} else {
pinyinArray = new String[] { chineseChar + DEFAULT_SEPARATOR };
}
if(pinyinArray!=null){
list.add(pinyinArray);
}
}
buildItem(list, 0, DEFAULT_SEPARATOR, separator, resultSet);
return resultSet;
}
protected static boolean isHanzi(char oneChar) {
if ((oneChar >= '\u4e00' && oneChar <= '\u9fa5')
|| (oneChar >= '\uf900' && oneChar <= '\ufa2d')) {
return true;
}
return false;
}
private static void buildItem(List list, int index, String sb,
String separator, Set resultSet) {
if (index == list.size()) {
if (StringUtils.isNotEmpty(sb)) {
if (StringUtils.isNotEmpty(separator)) {
resultSet.add(sb.substring(1));
} else {
resultSet.add(sb);
}
}
return;
}
String[] items = list.get(index);
for (String item : items) {
buildItem(list, index + 1, sb + separator + item, separator,
resultSet);
}
}
} import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;
import org.apache.tools.zip.ZipEntry;
import org.apache.tools.zip.ZipFile;
/**
* @Description 文件压缩解压
* @author wbw
*/
public class ZipFileUtil {
/**
* 解压文件
* @param zipFile
* 解压文件对象
* @param descDir
* 解压到的目录
* @throws Exception
*/
public static void unZipFile(File zipFile,String descDir)throws Exception{
int len = -1;
File pathFile = new File(descDir);
if(!pathFile.exists())pathFile.mkdirs();
ZipFile zip = new ZipFile(zipFile, "GBK");
for(Enumeration entries = zip.getEntries();entries.hasMoreElements();){
ZipEntry entry = (ZipEntry)entries.nextElement();
String zipEntryName = entry.getName();
InputStream in = zip.getInputStream(entry);
String outPath = (descDir +"/"+ zipEntryName).replaceAll("\\*", "/");
//判断路径是否存在,不存在则创建文件路径
File file = new File(outPath.substring(0, outPath.lastIndexOf('/')));
if(!file.exists())file.mkdirs();
//判断文件全路径是否为文件夹,如果是上面已经创建,不需要解压
if(new File(outPath).isDirectory())continue;
OutputStream out = new FileOutputStream(outPath);
byte[] buf = new byte[1024];
while((len=in.read(buf))>0){
out.write(buf, 0, len);
}
in.close();
out.close();
}
}
}
16.字号转中文字符串工具类
/**
* 字号转中文字符串
* @author wbw
* 2014年11月20日
*/
public class ZiAndHaoToChinaStr {
private static final String LING ="零";
private static final String YI ="一";
private static final String ER ="二";
private static final String SAN ="三";
private static final String SI ="四";
private static final String WU ="五";
private static final String LIU ="六";
private static final String QI ="七";
private static final String BA ="八";
private static final String JIU ="九";
public static String toChinaStr(String str) {
StringBuffer strb = new StringBuffer();
for(int i = 0 ; i < str.length();i++){
strb.append(toChinaChar(str.charAt(i)));
}
return strb.toString();
}
private static String toChinaChar(Character ch){
String result= "";
switch(ch){
case '0':
result = LING;
break;
case '1':
result = YI;
break;
case '2':
result = ER;
break;
case '3':
result = SAN;
break;
case '4':
result = SI;
break;
case '5':
result = WU;
break;
case '6':
result = LIU;
break;
case '7':
result = QI;
break;
case '8':
result = BA;
break;
case '9':
result = JIU;
break;
default :
result = "";
}
return result;
}
}
package cn.my.utils;
import java.sql.Connection;
import org.apache.ibatis.session.defaults.DefaultSqlSessionFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* ClassPathXmlApplicationContext 类
*/
public class ApplicationUtil {
private ApplicationUtil() {
}
private static ApplicationContext context = null;
private static final String fileName = "/applicationContext.xml";
/**
* 初始化Spring环境
* @return
* ApplicationContext
*/
public static ApplicationContext getInstance() {
if (context == null) {
context = new ClassPathXmlApplicationContext(fileName);
}
return context;
}
/**
* 获得数据库连接
* @return
* Connection
*/
public static Connection getConnection(){
if(context == null){
context = getInstance();
}
DefaultSqlSessionFactory dssf = (DefaultSqlSessionFactory) context.getBean("sqlSessionFactory");
return dssf.openSession().getConnection();
}
}
其实工具类还有很多很多,需要根据具体的项目情况而定.......未完待续