欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

JAVA项目开发中常用的工具方法

程序员文章站 2022-05-11 23:22:07
...
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.math.BigDecimal;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 项目中常用的工具类
 * 
 * @author tuozixuan
 * 
 */
public class CommonUtil
{
    /**
     * 是否为空,包括null和空格字符串
     * 
     * @param text 文本
     * @return boolean 是否为空
     */
    public static boolean isEmpty(String text)
    {
        boolean result = false;
        if (text == null || "".equals(text.trim()))
        {
            result = true;
        }
        return result;
    }

    /**
     * 是否不为空,包括null和空格字符串
     * 
     * @param text 文本
     * @return boolean 是否为空
     */
    public static boolean isNotEmpty(String text)
    {
        return !isEmpty(text);
    }

    /**
     * 如果文本为空或空字符串,则返回0,否则返回本身
     * 
     * @param text 文本
     * @return String 处理后的文本
     */
    public static String emptyToZero(String text)
    {
        String localText = text;
        if (isEmpty(text))
        {
            localText = "0";
        }
        else
        {
            localText = text.trim();
        }
        return localText;
    }

    /**
     * 对象是否为空
     * 
     * @param object 对象
     * @return boolean 是否为空
     */
    public static boolean isEmpty(Object object)
    {
        boolean result = false;
        if (object != null && !"".equals(object.toString()) && !"null".equals(object.toString()))
        {
            result = true;
        }
        return result;
    }

    /**
     * 如果对象为空,则返回默认值,否则强制转换为int类型
     * 
     * @param obj 对象
     * @param defaultInt 默认值
     * @return int int类型的数字
     */
    public static int objectToInt(Object obj, int defaultInt)
    {
        return obj == null ? defaultInt : ((Integer) obj).intValue();
    }

    /**
     * 如果对象为空,则返回默认值,否则强制转换为String类型
     * 
     * @param obj 对象
     * @param defaultStr 默认值
     * @return String String对象
     */
    public static String objectToString(Object obj, String defaultStr)
    {
        return obj == null ? defaultStr : String.valueOf(obj);
    }

    /**
     * 如果对象为空,则返回默认值,否则强制转换为Date类型
     * 
     * @param obj 对象
     * @param defaultDate 默认值
     * @return Date Date对象
     */
    public static Date objectToDate(Object obj, Date defaultDate)
    {
        return obj == null ? defaultDate : (Date) obj;
    }

    /**
     * 如果对象为空,则返回默认值,否则强制转换为double类型的数值
     * 
     * @param obj 对象
     * @param defaultDouble 默认值
     * @return double double数值
     */
    public static double objectToDouble(Object obj, double defaultDouble)
    {
        return obj == null ? defaultDouble : ((Double) obj).doubleValue();
    }

    /**
     * 如果对象为空,则返回默认值,否则强制转换为long类型的数值
     * 
     * @param obj 对象
     * @param defaultLong 默认值
     * @return long long数值
     */
    public static long objectToLong(Object obj, long defaultLong)
    {
        return obj == null ? defaultLong : ((Long) obj).longValue();
    }

    /**
     * 如果对象为空,则返回默认值,否则强制转换为boolean类型的数值
     * 
     * @param obj 对象
     * @param defaultBoolean 默认值
     * @return boolean boolean数值
     */
    public static boolean objectToBoolean(Object obj, boolean defaultBoolean)
    {
        return obj == null ? defaultBoolean : ((Boolean) obj).booleanValue();
    }

    /**
     * 把字符串转换为日期对象,如果字符串为空或格式不符转换失败,则返回null<br/>
     * 1.如果字符串长度为8,则按照yyyyMMdd格式进行转换<br/>
     * 2.如果字符串长度为10,则按照yyyy-MM-dd格式进行转换<br/>
     * 3.如果字符串长度为14,则按照yyyyMMddHHmmss格式进行转换<br/>
     * 4.如果字符串长度为19,则按照yyyy-MM-dd HH:mm:ss格式进行转换<br/>
     * 
     * @param dateStr 日期时间字符串
     * @return Date 日期对象
     */
    public static Date stringToDate(String dateStr)
    {
        if (dateStr == null || "".equals(dateStr.trim()))
        {
            return null;
        }

        String formatStr = "";
        if (dateStr.length() == 8)
        {
            formatStr = "yyyyMMdd";
        }
        else if (dateStr.length() == 10)
        {
            formatStr = "yyyy-MM-dd";
        }
        else if (dateStr.length() == 14)
        {
            formatStr = "yyyyMMddHHmmss";
        }
        else if (dateStr.length() == 19)
        {
            formatStr = "yyyy-MM-dd HH:mm:ss";
        }

        Date date = null;

        try
        {
            date = new SimpleDateFormat(formatStr).parse(dateStr);
        }
        catch (ParseException e)
        {
            e.printStackTrace();
        }
        return date;

    }

    /**
     * 获取指定格式的日期时间字符串
     * 
     * @param date 日期
     * @param dateFormat 日期时间格式
     * @return String 日期时间字符串
     */
    public static String getDateStr(Date date, String dateFormat)
    {
        SimpleDateFormat format = new SimpleDateFormat(dateFormat);
        String dateStr = format.format(date);
        return dateStr;
    }

    /**
     * 获取日期字符串,格式为yyyy-MM-dd
     * 
     * @param date 日期对象
     * @return String 日期字符串
     */
    public static String getDateStr(Date date)
    {
        return getDateStr(date, "yyyy-MM-dd");
    }

    /**
     * 获取日期数字字符串,格式为yyyyMMdd
     * 
     * @param date 日期对象
     * @return String 日期数字字符串
     */
    public static String getDateNumStr(Date date)
    {
        return getDateStr(date, "yyyyMMdd");
    }

    /**
     * 获取日期时间字符串,格式为yyyy-MM-dd HH:mm:ss
     * 
     * @param date 日期对象
     * @return String 日期字符串
     */
    public static String getDateTimeStr(Date date)
    {
        return getDateStr(date, "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * 获取日期时间数字字符串,格式为yyyyMMddHHmmss
     * 
     * @param date 日期对象
     * @return String 日期字符串
     */
    public static String getDateTimeNumStr(Date date)
    {
        return getDateStr(date, "yyyyMMddHHmmss");
    }

    /**
     * 根据指定日期格式把日期字符串转换为日期对象
     * 
     * @param dateStr 日期字符串
     * @param dateFormat 日期格式
     * @return Date 日期对象
     */
    public static Date getDate(String dateStr, String dateFormat)
    {
        Date date = null;
        try
        {
            if (!isEmpty(dateStr))
            {
                SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
                date = sdf.parse(dateStr);
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * 获取当前时间
     * 
     * @return Date 当前时间
     */
    public static Date getCurrentDate()
    {
        Calendar cal = Calendar.getInstance();
        Date currentDate = cal.getTime();
        return currentDate;
    }

    /**
     * 获取当前日期的字符串yyyy-MM-dd
     * 
     * @return String 当前日期的数字字符串
     */
    public static String getCurrentDateStr()
    {
        Date date = getCurrentDate();
        return getDateStr(date, "yyyy-MM-dd");
    }

    /**
     * 获取当前日期的数字字符串
     * 
     * @return String 当前日期的数字字符串
     */
    public static String getCurrentDateNumStr()
    {
        Date date = getCurrentDate();
        return getDateStr(date, "yyyyMMdd");
    }

    /**
     * 获取当前日期时间字符串,格式为yyyy-MM-dd HH:mm:ss
     * 
     * @return String 日期时间字符串
     */
    public static String getCurrentDateTimeStr()
    {
        Date date = getCurrentDate();
        return getDateStr(date, "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * 获取当前日期时间数字字符串,格式为yyyyMMddHHmmss
     * 
     * @return String 日期时间字符串
     */
    public static String getCurrentDateTimeNumStr()
    {
        Date date = getCurrentDate();
        return getDateStr(date, "yyyyMMddHHmmss");
    }

    /**
     * 比较格式为yyyy-MM-dd HH:mm:ss的日期字符串的大小
     * 
     * @param dateTime1 日期时间字符串1
     * @param dateTime2 日期时间字符串2
     * @return int 0:相等 1:前者大约后者 -1:前者小于后者 -2:发生错误
     */
    public static int compareStringDate(String dateTime1, String dateTime2)
    {
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Calendar c1 = Calendar.getInstance();
        Calendar c2 = Calendar.getInstance();
        try
        {
            c1.setTime(df.parse(dateTime1));
            c2.setTime(df.parse(dateTime2));
        }
        catch (ParseException e)
        {
            return -2;
        }
        int result = c1.compareTo(c2);
        if (result == 0)
        {
            return 0;
        }
        return result >= 0 ? 1 : -1;
    }

    /**
     * 是否为数字
     * 
     * @param text 要验证的文本
     * @return boolean true-是 false-否
     */
    public static boolean isNumber(String text)
    {
        if (isEmpty(text))
        {
            return false;
        }

        String numberStr = "0123456789";
        for (int i = 0; i < text.length(); i++)
        {
            char c = text.charAt(i);
            if (numberStr.indexOf(String.valueOf(c)) == -1)
            {
                return false;
            }
        }
        return true;
    }

    /**
     * 是否符合电子邮件地址格式
     * 
     * @param email 电子邮件地址
     * @return boolean true-是 false-否
     */
    public static boolean isEmail(String email)
    {
        boolean isEmail = false;
        Pattern p = Pattern.compile("([\\w[.-]]+)(@)([\\w[.-]]+\\.[\\w[.-]]+)");
        Matcher m = p.matcher(email);
        if (m.matches())
        {
            isEmail = true;
        }
        return isEmail;
    }

    /**
     * 是否符合手机号码格式
     * 
     * @param mobile 手机号码
     * @return boolean true-是 false-否
     */
    public static boolean isMobile(String mobile)
    {
        boolean isMobile = false;
        Pattern p = Pattern.compile("((\\()?(\\+)?(86)?1[3|5|8][0-9]{9}(\\))?$)|((\\()?(\\+)?(86)?01[3|5|8][0-9]{9}(\\))?$)");
        Matcher m = p.matcher(mobile);
        if (m.matches())
        {
            isMobile = true;
        }
        return isMobile;
    }

    /**
     * 电话号码格式简单校验,格式为:数字-数字
     * 
     * @param phone 电话号码
     * @return boolean true-是 false-否
     */
    public static boolean isPhone(String phone)
    {

        boolean isPhone = false;

        int index = phone.indexOf("-");
        if (index > 0 && index != phone.length() - 1)
        {
            String phoneNum = phone.substring(0, index) + phone.substring(index + 1);
            if (isNumber(phoneNum))
            {
                isPhone = true;
            }
        }
        return isPhone;
    }

    /**
     * 是否为密码,允许大小写字母、数字以及下划线,长度为4-16位
     * 
     * @param pwd 密码
     * @return boolean true-是 false-否
     */
    public static boolean isPassword(String pwd)
    {
        boolean ifPwd = false;
        Pattern p = Pattern.compile("([A-Za-z0-9_]{4,16})");
        Matcher m = p.matcher(pwd);
        if (m.matches())
        {
            ifPwd = true;
        }
        return ifPwd;
    }

    /**
     * 文本是否都有字母组成
     * 
     * @param text 待验证的文本
     * @return boolean true-是 false-否
     */
    public static boolean isLetter(String text)
    {
        if (text != null)
        {
            Pattern pattern = Pattern.compile("^[a-zA-Z]+$");
            Matcher matcher = pattern.matcher(text);
            if (matcher.matches())
            {
                return true;
            }
        }
        return false;
    }

    /**
     * 是否为文字,包括中文字符、英文字母和数字
     * 
     * @param text 待验证的文本
     * @return boolean true-是 false-否
     */
    public static boolean isWord(String text)
    {
        boolean isWord = false;
        if (text != null)
        {
            Pattern p = Pattern.compile("([A-Za-z0-9\u4E00-\u9FA5])+");
            Matcher m = p.matcher(text);
            if (m.matches())
            {
                isWord = true;
            }
        }
        return isWord;
    }

    /**
     * 字符串是否处于指定长度之间
     * 
     * @param text 文本
     * @param minLen 最小长度
     * @param maxLen 最大长度
     * @return boolean true-是 false-否
     */
    public static boolean isLength(String text, int minLen, int maxLen)
    {
        int length = 0;
        if (text != null)
        {
            length = trueLength(text);
        }

        boolean result = false;
        if (length >= minLen && length <= maxLen)
        {
            result = true;
        }
        return result;
    }

    /**
     * 获取文本的真实长度,中文-2 英文-1
     * 
     * @param text 文本
     * @return int 文本的真实长度
     */
    public static int trueLength(String text)
    {
        int length = 0;
        Pattern p = Pattern.compile("([\u4E00-\u9FA5])");
        for (int i = 0; i < text.length(); i++)
        {
            Matcher m = p.matcher(text.charAt(i) + "");
            if (m.matches())
            {
                length += 2;
            }
            else
            {
                length++;
            }
        }

        return length;
    }

    /**
     * 检查是否符合昵称规则,4-24个字符, 支持中英文、数字、下划线;<br/>
     * 
     * @param nickName 昵称
     * @return boolean true-符合 false-不符合
     */
    public static boolean isNickName(String nickName)
    {

        int length = trueLength(nickName);
        if (length < 4 || length > 24)
        {
            return false;
        }

        Pattern p = Pattern.compile("([_A-Za-z0-9\u4E00-\u9FA5]){1,24}");
        Matcher m = p.matcher(nickName);
        if (!m.matches())
        {
            return false;
        }

        return true;
    }

    /**
     * 是否URL地址
     * 
     * @param url URL
     * @return boolean true-是 false-否
     */
    public static boolean isUrl(String url)
    {
        return validByRegex("(http://|https://)?([\\w-]+\\.)+[\\w-]+(/[\\w- ./?%&=]*)?", url);
    }

    /**
     * 是否为数字字符串
     * 
     * @param s 字符串
     * @return boolean true-是 false-否
     */
    public static boolean isNumberic(String s)
    {
        if (isEmpty(s))
        {
            return false;
        }
        boolean rtn = validByRegex("^[-+]{0,1}\\d*\\.{0,1}\\d+$", s);
        if (rtn)
        {
            return true;
        }

        return validByRegex("^0[x|X][\\da-eA-E]+$", s);
    }

    /**
     * 是否为整数字符串
     * 
     * @param s 字符串
     * @return boolean true-是 false-否
     */
    public static boolean isInteger(String s)
    {
        boolean result = validByRegex("^[-+]{0,1}\\d*$", s);
        return result;
    }

    /**
     * 是否为邮政编码
     * 
     * @param s 字符串
     * @return boolean true-是 false-否
     */
    public static boolean isZipCode(String s)
    {
        boolean result = validByRegex("^[0-9]{6}$", s);
        return result;
    }

    /**
     * 是否为QQ号码
     * 
     * @param s 字符串
     * @return boolean true-是 false-否
     */
    public static boolean isQq(String s)
    {
        boolean result = validByRegex("^[1-9]\\d{4,9}$", s);
        return result;
    }

    /**
     * 是否为指定格式的日期字符串
     * 
     * @param strDate 日期字符串
     * @param format 日期格式
     * @return boolean true-是 false-否
     */
    public static boolean isDate(String strDate, String format)
    {
        boolean result = false;
        try
        {
            DateFormat df = new SimpleDateFormat(format);
            Date d = df.parse(strDate);
            String strNewDate = df.format(d);
            if (strDate.equals(strNewDate))
            {
                result = true;
            }
        }
        catch (Exception localException)
        {
        }
        return result;
    }

    /**
     * 检验字符串是否匹配指定的正则表达式
     * 
     * @param regex 正则表达式
     * @param input 字符串
     * @return boolean true-匹配 false-不匹配
     */
    public static boolean validByRegex(String regex, String input)
    {
        Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        Matcher regexMatcher = p.matcher(input);
        return regexMatcher.find();
    }

    /**
     * 数组拼装成 xx,yy,zz
     * 
     * @param array 数组
     * @param separator 分隔符
     * @return String 字符串
     */
    public static <T> String join(T[] array, String separator)
    {
        StringBuffer str = new StringBuffer();
        String newStr = "";
        if (array != null && array.length > 0)
        {
            for (T arr : array)
            {
                str.append(arr).append(separator);
            }
            newStr = str.substring(0, str.length() - 1);
        }
        return newStr;
    }

    /**
     * 列表拼装成 xx,yy,zz类型的字符串
     * 
     * @param list 列表
     * @param separator 分隔符
     * @return String 字符串
     */
    public static <T> String join(List<T> list, String separator)
    {
        StringBuffer str = new StringBuffer();
        String newStr = "";
        if (list != null && list.size() > 0)
        {
            for (T arr : list)
            {
                str.append(arr).append(separator);
            }
            newStr = str.substring(0, str.length() - 1);
        }
        return newStr;
    }

    /**
     * 转换为大写
     * 
     * @param str 字符串
     * @return String 大写字符串
     */
    public static String upperCase(String str)
    {
        if (str == null)
        {
            return null;
        }
        return str.toUpperCase();
    }

    /**
     * 转换为小写
     * 
     * @param str 字符串
     * @return String 小写字符串
     */
    public static String lowerCase(String str)
    {
        if (str == null)
        {
            return null;
        }
        return str.toLowerCase();
    }

    /**
     * 字符串是否为null或者由空白字符组成
     * 
     * @param str 字符串
     * @return boolean true-是 false-否
     */
    public static boolean isBlank(String str)
    {
        if ((str == null) || str.length() == 0)
        {
            return true;
        }
        int strLen = str.length();
        for (int i = 0; i < strLen; i++)
        {
            if (!Character.isWhitespace(str.charAt(i)))
            {
                return false;
            }
        }
        return true;
    }

    /**
     * 字符串是否不为null并且不都由空白字符组成
     * 
     * @param str 字符串
     * @return boolean true-是 false-否
     */
    public static boolean isNotBlank(String str)
    {
        return !isBlank(str);
    }

    /**
     * 提供精确的小数位四舍五入处理
     * 
     * @param v 需要四舍五入的数字
     * @param scale 小数点后保留几位
     * @return double 四舍五入后的结果
     */
    public static double round(double v, int scale)
    {
        if (scale < 0)
        {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");

        }
        BigDecimal b = new BigDecimal(Double.toString(v));
        BigDecimal one = new BigDecimal("1");
        return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 提供精确的加法运算
     * 
     * @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();
    }

    /**
     * 提供(相对)精确的除法运算。当发生除不尽的情况时,由scale参数指定的精度,以后的数字四舍五入
     * 
     * @param v1 被除数
     * @param v2 除数
     * @param scale 表示需要精确到小数点以后几位。
     * @return 两个参数的商
     */
    public static double div(double v1, double v2, int scale)
    {
        if (scale < 0)
        {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 获取有★组成的字符串,如:★★★,如果starCount小于等于0,返回空字符串
     * 
     * @param starCount 星星的数量
     * @return String starCount个星星组成的字符串
     */
    public static String getStarString(int starCount)
    {
        String starString = "";
        if (starCount > 0)
        {
            for (int i = 0; i < starCount; i++)
            {
                starString += "★";
            }
        }
        return starString;
    }

    /**
     * 根据类名获取Class类
     * 
     * @param className 全类名
     * @return Class<?> Class类
     * @throws ClassNotFoundException
     */
    public static Class<?> getClass(String className) throws ClassNotFoundException
    {
        return Class.forName(className);
    }

    /**
     * 是否存在类名指定的类
     * 
     * @param className 类名
     * @return boolean true-存在 false-不存在
     */
    public static boolean hasClass(String className)
    {
        boolean has = true;
        try
        {
            Class.forName(className);
        }
        catch (ClassNotFoundException e)
        {
            has = false;
        }
        return has;
    }

    /**
     * 获取类的构造器
     * 
     * @param c 类
     * @param parameterTypes 参数类型
     * @return Constructor<?> 构造器
     * @throws SecurityException
     * @throws NoSuchMethodException
     */
    public static Constructor<?> getConstructor(Class<?> c, Class<?>[] parameterTypes) throws SecurityException, NoSuchMethodException
    {

        return c.getConstructor(parameterTypes);
    }

    /**
     * 根据Class类获取类名
     * 
     * @param c Class类
     * @return String 类名
     */
    public static String getClassName(Class<?> c)
    {
        String className = c.getSimpleName();
        Class<?>[] interfaces = c.getInterfaces();
        if ((!className.startsWith("$")) || (interfaces.length == 0))
        {
            return className;
        }
        String[] names = new String[interfaces.length];
        for (int i = 0; i < interfaces.length; i++)
        {
            names[i] = interfaces[i].getSimpleName();
        }

        return className + "(" + join(names, ",") + ")";
    }

    /**
     * SQL特殊字符转义
     * 
     * @param sql 结构化查询语句
     * @return String 转义后的SQL
     */
    public static String encodeSQL(String sql)
    {
        if (sql == null)
        {
            return "";
        }

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < sql.length(); i++)
        {
            char c = sql.charAt(i);
            switch (c)
            {
            case '\\':
                sb.append("\\\\");
                break;
            case '\r':
                sb.append("\\r");
                break;
            case '\n':
                sb.append("\\n");
                break;
            case '\t':
                sb.append("\\t");
                break;
            case '\b':
                sb.append("\\b");
                break;
            case '\'':
                sb.append("''");
                break;
            case '"':
                sb.append("\\\"");
                break;
            case '%':
                sb.append("\\%");
                break;
            default:
                sb.append(c);
            }
        }
        return sb.toString();
    }

    /**
     * MD5散列不可逆加密算法
     * 
     * @param userName 用户名
     * @param password 密码
     * @return String 加密后的密码
     */
    public static String encryptPassword(String userName, String password)
    {
        String publicKey1 = "jjejduuhjdjdHDUEHWHd3ehgfidhwh23hHJCRIOI4HDHDHFKHFD3dhdhrg2djsHSDFHFEDJGW";
        String publicKey2 = "347djejDETahe3j%3jd*%%2DDE223fdhahfh%^@21hdhfhzhdDFQ3hH7eh32hdE#@sdqhqhde";
        String publicKey3 = "wkjd@wjsdj2324shjsQWeh2dsGed/#21ssdEdhawehrcyzhzeje2#@SDajw2D2sjzahd3#dSa";
        String str = publicKey1 + userName + publicKey2 + password + publicKey3;
        return md5(str).toUpperCase();
    }

    /**
     * 使用UTF-8解码字符串
     * 
     * @param paramValue 参数字符串
     * @return String 解码后的字符串
     * @throws Exception
     */
    public static String decodeUTF8(String str)
    {
        return decode(str, "utf-8");
    }

    /**
     * 用指定的编码类型对字符串进行解码
     * 
     * @param string 字符串
     * @param encodeScheme 编码类型
     * @return String 解码后的字符串
     */
    public static String decode(String string, String encodeScheme)
    {
        try
        {
            return java.net.URLDecoder.decode(string, encodeScheme);
        }
        catch (UnsupportedEncodingException uee)
        {
            uee.printStackTrace();
        }
        return string;
    }

    /**
     * 使用UTF-8编码字符串
     * 
     * @param paramValue 参数字符串
     * @return String 编码后的字符串
     * @throws Exception
     */
    public static String encodeUTF8(String str)
    {
        return encode(str, "utf-8");
    }

    /**
     * 用指定的编码类型对字符串进行编码
     * 
     * @param string 字符串
     * @param encodeScheme 编码类型
     * @return String 编码后的字符串
     */
    public static String encode(String string, String encodeScheme)
    {
        try
        {
            return java.net.URLEncoder.encode(string, encodeScheme);
        }
        catch (UnsupportedEncodingException uee)
        {
            uee.printStackTrace();
        }
        return string;
    }

    /**
     * 数组转换为列表
     * 
     * @param array 数组
     * @return List<T> 列表
     */
    public static <T> List<T> arrayToList(T[] array)
    {
        List<T> list = null;
        if (array != null)
        {
            list = new ArrayList<T>();
            for (int i = 0; i < array.length; i++)
            {
                list.add(array[i]);
            }
        }

        return list;
    }

    /**
     * 列表转换为数组
     * 
     * @param list 列表
     * @param type Class类型
     * @return T[] 数组
     */
    @SuppressWarnings("unchecked")
    public static <T> T[] listToArray(List<T> list, Class<T> type)
    {

        T[] array = null;
        if (list != null)
        {

            array = (T[]) Array.newInstance(type, list.size());
            for (int i = 0; i < list.size(); i++)
            {
                array[i] = list.get(i);
            }
        }

        return array;
    }

    /**
     * 把字符串由一种编码转换为另一种编码(如果转换失败,则返回原字符串)
     * 
     * @param str 字符串
     * @param from 源编码
     * @param to 目标编码
     * @return String 编码后的字符串
     */
    public static String encodingString(String str, String from, String to)
    {
        String result = str;
        try
        {
            result = new String(str.getBytes(from), to);
        }
        catch (Exception e)
        {
            result = str;
        }
        return result;
    }

    /**
     * MD5加密字符串
     * 
     * @param str 加密前的字符串
     * @return String 加密后的字符串
     */
    public static String md5(String str)
    {
        try
        {
            MessageDigest alg = MessageDigest.getInstance("MD5");
            byte[] b = str.getBytes();
            alg.reset();
            alg.update(b);
            byte[] hash = alg.digest();
            String d = "";
            for (int i = 0; i < hash.length; i++)
            {
                int v = hash[i] & 0xFF;
                if (v < 16)
                {
                    d += "0";
                }
                d += Integer.toString(v, 16);
            }
            return d;
        }
        catch (NoSuchAlgorithmException e)
        {
            return null;
        }
    }

    /**
     * 关闭数据库连接
     * 
     * @param conn 数据库连接
     */
    public static void closeConnection(Connection conn)
    {
        try
        {
            if ((conn != null) && (!conn.isClosed()))
            {
                conn.close();
            }
        }
        catch (SQLException e)
        {
            e.printStackTrace();
        }
    }

    /**
     * 关闭Statement对象
     * 
     * @param stmt Statement对象
     */
    public static void closeStatement(Statement stmt)
    {
        try
        {
            if (stmt != null)
            {
                stmt.close();
            }
        }
        catch (SQLException e)
        {
            e.printStackTrace();
        }
    }

    /**
     * 关闭结果集
     * 
     * @param rs ResultSet对象
     */
    public static void closeResultSet(ResultSet rs)
    {
        try
        {
            if (rs != null)
            {
                rs.close();
            }
        }
        catch (SQLException e)
        {
            e.printStackTrace();
        }
    }

    /**
     * 安全关闭数据库连接、Statement及结果集对象
     * 
     * @param conn 数据库连接对象
     * @param stmt Statement对象
     * @param rs 结果集对象
     */
    public static void close(Connection conn, Statement stmt, ResultSet rs)
    {
        closeResultSet(rs);
        closeStatement(stmt);
        closeConnection(conn);
    }

    /**
     * 回滚数据库事务
     * 
     * @param conn 数据库连接
     */
    public static void rollback(Connection conn)
    {
        try
        {
            if ((conn != null) && (!conn.isClosed()))
            {
                conn.rollback();
            }
        }
        catch (SQLException e)
        {
            e.printStackTrace();
        }
    }

    /**
     * 是否为自动提交
     * 
     * @param conn 数据库连接
     * @return boolean true-是 false-否
     */
    public static boolean isAutoCommit(Connection conn)
    {
        try
        {
            if ((conn != null) && (!conn.isClosed()))
            {
                return conn.getAutoCommit();
            }
        }
        catch (SQLException e)
        {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * Connection对象不为null且未关闭的情况下,设置是否自动提交
     * 
     * @param conn 数据库连接
     * @param autoCommit 是否自动提交
     */
    public static final void setAutoCommit(Connection conn, boolean autoCommit)
    {
        try
        {
            if ((conn != null) && (!conn.isClosed()))
            {
                conn.setAutoCommit(autoCommit);
            }
        }
        catch (SQLException e)
        {
            e.printStackTrace();
        }
    }

    /**
     * 提交数据库事务
     * 
     * @param conn Connection对象
     */
    public static void commit(Connection conn)
    {
        try
        {
            if ((conn != null) && (!conn.isClosed()))
            {
                conn.commit();
            }
        }
        catch (SQLException e)
        {
            e.printStackTrace();
        }
    }

}