`
拓子轩
  • 浏览: 210705 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

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

    博客分类:
  • java
阅读更多
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();
        }
    }

}

 

分享到:
评论

相关推荐

    JAVA 工具类 项目开发常用方法

    java 工具类 项目开发常用方法,如:字符转换函数,字符处理,数组相关的处理函数

    JAVA开发常用工具安装包

    在这个安装包中,除了上述工具和组件外,还包含了其他有用的开发工具和资源,例如Java开发文档、开发示例代码、开发工具插件等。这些资源可以帮助开发者更好地掌握Java开发技术,提高开发技能和效率。 这个安装包是...

    java项目开发常用工具类

    以下是一些常见的Java项目开发工具类的详细说明: 1. **RestTemplate**: RestTemplate是Spring框架提供的一种用于执行HTTP请求的工具,特别适合于RESTful服务的调用。它支持GET、POST、PUT、DELETE等多种HTTP方法...

    Java项目开发常用工具包util

    Java项目开发常用工具包,其中主要包括:Assert.java BufferedImageLuminanceSource.java CipherUtil.java ClientConst.java CodeUtil.java ComputeUtil.java DataUtils.java DateUtils.java Digests.java Encodes....

    Java常用开发工具.zip

    在给定的“Java常用开发工具.zip”压缩包中,我们可以找到几个关键的组件,这些工具对于Java开发者来说至关重要。 1. **Tomcat 8.5**: Tomcat是一个开源的、基于Apache Software Foundation的Jakarta项目下的...

    JAVA项目开发案例全程实录(超级高清).PDF

    综上所述,“JAVA项目开发案例全程实录(超级高清).PDF”不仅涵盖了一般Java项目的开发流程和技术栈介绍,还提供了实际案例分析和问题解决方法等内容,对于想要深入了解Java项目开发的读者来说,是一份非常有价值的...

    java开发常用工具类大全,程序员必备工具

    本文将详细解析“java开发常用工具类大全”中涉及的关键知识点,包括但不限于输入字符校验、数据转换、网络操作、加密解密、JSON处理、图像操作以及数据库操作。 1. **输入字符校验类**: 这类工具通常包含对字符...

    Java项目开发PPT

    在学习这些知识点的过程中,PPT可能会提供详细的代码示例、案例分析以及问题解决策略,帮助学习者逐步提高Java项目开发的能力。此外,PPT中的每一页都可能包含小结和习题,以巩固学习效果。通过这样的学习计划,学习...

    一些java常用的工具类

    在Java编程中,工具类(Utility Classes)是非常重要的组成部分,它们提供了许多通用的功能,以简化开发人员的工作。以下是对"一些java常用的工具类"的详细说明。 首先,工具类通常包含静态方法,这些方法不依赖于...

    java常用开发工具类大全

    "java常用开发工具类大全"很可能包含以上提到的一些工具类的实现或扩展,便于开发者在项目中快速集成和使用。通过阅读`readme.htm`和解压后的`1845027886334976.zip`文件,你可以获取更多具体的信息和示例,以便更好...

    JAVA项目开发文档模板

    在软件开发过程中,Java项目开发文档模板是至关重要的,它为整个项目的生命周期提供了一套标准和规范,确保团队成员能够高效、有序地进行工作。以下将详细解释标题和描述中涉及的知识点,并根据标签和文件名拓展相关...

    java常用开发词汇

    "Java常用开发词汇" ...10. Java开发词汇的实际应用:Java开发词汇广泛应用于实际的软件开发项目中,例如开发一个android应用程序等。 本文档旨在帮助开发者更好地理解和掌握Java开发词汇,提高开发效率和质量。

    JAVA项目开发全程实录配套光盘

    【标题】"JAVA项目开发全程实录配套光盘"揭示了这个压缩包是与一本关于JAVA项目开发的书籍配套的资源。通常这类资源会包含实际项目开发中的源代码、示例、教程或练习材料,旨在帮助读者更好地理解和实践书中讲解的...

    java开发,30个常用工具类总结,全部来自项目实践中用到的工具类

    在Java开发中,工具类是程序员经常会用到的代码模块,它们封装了各种常见的操作,提高了代码的可重用性和可维护性。以下是对标题和描述中提到的几个常用工具类的详细说明: 1. **DateUtils**: `java.util.Date` 和 ...

    java项目打包工具

    Java项目打包工具是开发人员在完成Java应用程序或Web应用程序开发后,用来整合资源、编译代码、处理依赖、生成可部署文件的重要工具。这些工具帮助开发者将源代码、配置文件、库和其他资源组织成便于分发和运行的...

    Java项目开发实例自学手册

    在Java项目开发中,首先需要了解的是Java的基础知识,包括语法、类与对象、封装、继承、多态等核心概念。这些是构建任何Java程序的基础,也是理解和编写项目代码的前提。书中会详细解释这些概念,并通过实例来演示...

    Java常用工具类包包含各种常用开发工具

    在Java编程语言中,工具类库(通常称为util包)是开发者日常工作中不可或缺的一部分。这些工具类提供了许多实用的功能,可以极大地...在实际开发中,根据项目需求选择合适的工具类,可以有效提升代码质量和开发效率。

    java常见14种开发工具

    2. Java Workshop:这是一个早期的Java开发工具,具体信息在描述中未详尽给出,但通常这样的工具会提供项目管理、代码编辑、编译和调试等功能,便于开发者进行Java应用程序的构建。 3. NetBeans:NetBeans是一款...

    java项目开发实战密码

    《Java项目开发实战密码》是一本深度探讨Java项目开发实践的书籍,主要针对那些希望提升自己在实际开发中解决问题能力的程序员。GBK编码的使用表明该资源可能关注的是早期Java项目,那时GBK是中国地区广泛使用的字符...

    JAVA项目展示PPT

    下面,我们将深入探讨Java项目开发的关键知识点: 1. **Java简介**:Java是一种多平台、面向对象的编程语言,由Sun Microsystems(现已被Oracle收购)于1995年推出。它的设计目标是“一次编写,到处运行”,这得益...

Global site tag (gtag.js) - Google Analytics