通用工具类方法

package com.ctb.utils;

import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

import net.sf.json.JSONArray;

import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;

public class MyUtilTool {
    private static Logger logger = Logger.getLogger(MyUtilTool.class);
    /**
     * 日期格式参数
     * @author 11
     */
    public static class DATE_PARAM{
        public static String STANDARD_DATE = "yyyy-MM-dd HH:mm:ss";
        public static String STANDARD_DATE_SIMPLE = "yyyy-MM-dd";
        public static String CHN_DATE = "yyyy年MM月dd日 HH时mm分ss秒";
        public static String CHN_DATE_SIMPLE = "yyyy年MM月dd日";
    }

    /**
     * 日期处理工具
     * @author 11
     */
    public static class DATE{

        /**
         * 获取当前时间
         * @return
         */
        public static Long getCurrentTime() {
            return (new Date()).getTime();
        }

        /**
         * 获取当前日期的格式化字符串
         * @param formateStr
         * @return
         */
        public static String currentDateString(String formateStr) {
            if (StringUtils.isEmpty(formateStr)) {
                formateStr = MyUtilTool.DATE_PARAM.STANDARD_DATE;
            }
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat(formateStr);
            try {
                return simpleDateFormat.format(new Date());
            } catch (Exception e) {
                logger.error("日期格式化异常");
            }
            return null;
        }

        /**
         * 日期格式化
         * @param date
         * @return String
         */
        public static String dateToString(Date date,String formateStr) {
            if (StringUtils.isEmpty(formateStr)) {
                formateStr = MyUtilTool.DATE_PARAM.STANDARD_DATE;
            }
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat(formateStr);
            try {
                return simpleDateFormat.format(date);
            } catch (Exception e) {
                logger.error("日期格式化异常");
            }
            return null;
        }

        /**
         * 字符串转换成日期
         *
         * @param dateStr
         * @return
         */
        public static Date stringToDate(String dateStr,String formateStr) {
            if (StringUtils.isEmpty(formateStr)) {
                formateStr = MyUtilTool.DATE_PARAM.STANDARD_DATE;
            }
            if (dateStr != null && dateStr.length() > 0) {
                dateStr = formatDateStr(dateStr);
                SimpleDateFormat simpleDateFormat = new SimpleDateFormat(formateStr);
                try {
                    return simpleDateFormat.parse(dateStr);
                } catch (ParseException e) {
                    logger.error("日期格式化异常");
                }
            }
            return null;
        }

        /**
         * 格式化日期字符串
         * @param dateStr
         * @return
         */
        private static String formatDateStr(String dateStr){
            String[] strs = dateStr.split("-");
            String str ="";
            for (int i = 0; i < strs.length; i++) {
                String ele = strs[i];
                if (i>0) {
                    if (ele.length()==1) {
                        ele = "0"+ele;
                    }
                    str=str+"-"+ele;
                }else {
                    str=ele;
                }
            }
            return str;
        }

        /**
         * 将SQL DATE类型转换成Date类型
         *
         * @param sqlDate
         * @return
         */
        public static Date sqlDateToDate(java.sql.Date sqlDate) {
            long time = sqlDate.getTime();
            Date date = new Date(time);
            return date;
        }

        /**
         * 将Util Date类型转换成为Sql Date
         *
         * @return
         */
        public static Timestamp currentDateToSQLTimestamp() {
            Date date = new Date();
            Timestamp timestamp = new Timestamp(date.getTime());
            return timestamp;
        }

        /**
         * 将Util Date类型转换成为Sql Date
         * @param date
         * @return
         */
        public static Timestamp dateToSQLTimestamp(Date date){
            if (date!=null) {
                Timestamp timestamp = new Timestamp(date.getTime());
                return timestamp;
            }
            return null;
        }

        /**
         * 将timestamp转换成为Date类型
         * @param timestamp
         * @return Date
         */
        public static Date SQLTimestampToDate(Timestamp timestamp){
            if (timestamp!=null) {
                Date date = new Date(timestamp.getTime());
                return date;
            }
            return null;
        }

        /**
         * 与系统时间比较
         * @param expiredTime
         * @return boolean
         */
        public static boolean checkExpiredTime(Date expiredTime) {
            if (expiredTime != null) {
                Date nowDate = new Date();
                if (expiredTime.before(nowDate)) {
                    return true;
                } else {
                    return false;
                }
            }
            return false;
        }

        /**
         * 日期计算
         * @param field
         * @param calCount
         * @return
         */
        public static Date calculateDate(Date orgDate,int field,int calCount){
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(orgDate);
            calendar.add(field, calCount);
            orgDate = calendar.getTime();
            return orgDate;
        }

        /**
         * 设置修改日期内容
         * @param orgDate
         * @param field
         * @param setValue
         * @return
         */
        public static Date calculateSetDate(Date orgDate,int field,int setValue){
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(orgDate);
            calendar.set(field, setValue);
            orgDate = calendar.getTime();
            return orgDate;
        }
    }

    /**
     * 字符串处理工具
     * @author 11
     */
    public static class STRING{
        /**
         * 验证字符串是否为空
         *
         * @param str
         * @return
         */
        public static boolean checkStrNull(String str) {
            if (str != null && str.trim().length() > 0) {
                return false;
            } else {
                return true;
            }
        }

        private static final int MAX_GENERATE_COUNT = 99999;
        private static int generateCount = 0;
        public static synchronized String getUniqueString() {
            if (generateCount > MAX_GENERATE_COUNT)
                generateCount = 0;
            String uniqueNumber = Long.toString(System.currentTimeMillis()) + Integer.toString(generateCount);
            generateCount++;
            return uniqueNumber;
        }

        /**
         * 将字符串中的中文转成nicode码
         * @param str
         * @return
         */
        public static String chineseToUnicode(String str){
            String result="";
            for (int i = 0; i < str.length(); i++){
                int chr1 = (char) str.charAt(i);
                if(chr1>=19968&&chr1<=171941){//汉字范围 \u4e00-\u9fa5 (中文)
                    result+="\\u" + Integer.toHexString(chr1);
                }else{
                    result+=str.charAt(i);
                }
            }
            try {
                result = new String(result.getBytes(),"utf-8");
            } catch (Exception e) {
                System.out.println("不支持的编码格式");
            }
            return result;
        }

        /**
         * 对字符串进行正则验证
         * @param str
         * @param reg
         * @return Boolean
         */
        public static Boolean checkStrignReg(String str, String reg) {
            boolean regCheck = str.matches(reg);
            return regCheck;
        }

        /**
         * 替换字符
         * @param str
         * @param oldChar
         * @param newChar
         * @return
         */
        public static String replace(String str,String oldChar,String newChar){
            if (StringUtils.isNotEmpty(str)) {
                str = str.replace(oldChar, newChar);
            }
            return str;
        }

        /**
         * MD5加密字符串
         * @param password
         * @return
         */
        public static String cipherPassword(String password){
            String cipherPassword = DigestUtils.md5Hex(password);
            return cipherPassword;
        }

        /**
         * 取出字符串中含有的空格
         * @param str
         * @return
         */
        public static String removeBlanksInString(String str) {
            if (str != null && str.trim().length() > 0) {
                str = str.replace(" ", "");
            }
            return str;
        }

        /**
         * 将字符串分割成为
         * @param str
         * @param sign
         * @return String[]
         */
        public static String[] seperateStringToStrings(String str, String sign) {
            if (str != null && str.trim().length() > 0) {
                if (str.contains(sign)) {
                    return str.split(sign);
                }
            }
            return null;
        }

        /**
         * 将字符串以字符分割
         * @param orgStr
         * @param splitRange
         * @param sign
         * @return
         */
        public static String splitWithSign(String orgStr,Integer splitRange,String sign){
            if (StringUtils.isNotEmpty(orgStr)) {
                Integer length = orgStr.length();
                if (length > splitRange) {
                    Integer splitNums = length/splitRange;
                    Integer lastMod = length % splitRange;
                    if (lastMod>0) {
                        splitNums = splitNums+1;
                    }

                    String[] results = new String[splitNums];

                    for (int i = 0; i < splitNums; i++) {
                        Integer startIndex = i*splitRange;
                        Integer endIndex = (i+1)*splitRange;
                        if (endIndex>length) {
                            endIndex = length;
                        }
                        results[i] = orgStr.substring(startIndex,endIndex);
                    }

                    String newStr = "";

                    int length2 = results.length;
                    if (ArrayUtils.isNotEmpty(results)) {
                        for (int i = 0; i < length2; i++) {
                            if(i==0){
                                newStr = results[i];
                            }else {
                                newStr = newStr +sign+ results[i];
                            }
                        }
                    }

                    return newStr;
                }
            }
            return orgStr;
        }
    }

    /**
     * 集合类处理工具
     *
     * @author 11
     */
    public static class COLLECTION {
        public static Long[] longsListToLongs(List<Long> longList) {
            if (CollectionUtils.isNotEmpty(longList)) {
                Long[] longArray = new Long[longList.size()];
                for (int i = 0; i < longList.size(); i++) {
                    longArray[i] = longList.get(i);
                }
                return longArray;
            }
            return null;
        }

        public static Object[] objectsListToObjects(List<Object> objList) {
            if (CollectionUtils.isNotEmpty(objList)) {
                Object[] array = new Object[objList.size()];
                array = objList.toArray(array);
                return array;
            }
            return null;
        }
    }

    public static class ARRAY{
        public static boolean checkIntInInts(int[] results, int i) {
            if (ArrayUtils.isNotEmpty(results)) {
                for (Integer integer : results) {
                    if (integer > i) {
                        return true;
                    }
                }
            }
            return false;
        }

        /**
         * 验证数组中是否包含不为空的内容
         * @param strings
         * @return
         */
        public static boolean checkStringsAllNull(String...strings){
            if (ArrayUtils.isNotEmpty(strings)) {
                for (String string : strings) {
                    if (StringUtils.isNotEmpty(string)) {
                        return true;
                    }
                }
            }
            return false;
        }

        /**
         * 将Integer类型数组转换成为Long类型数组
         * @param orgArrays
         * @return
         */
        public static Long[] integersToLongs(Integer[] orgArrays){
            if (ArrayUtils.isNotEmpty(orgArrays)) {
                Long[] results = new Long[orgArrays.length];
                for (int i = 0; i < orgArrays.length; i++) {
                    results[i] = new Long(orgArrays[i]);
                }
                return results;
            }
            return null;
        }

        /**
         * 将String类型数组，转换成为Long类型数组
         * @param orgArrays
         * @return
         */
        public static Long[] stringsToLongs(String[] orgArrays){
            if (ArrayUtils.isNotEmpty(orgArrays)) {
                Long[] results = new Long[orgArrays.length];
                for (int i = 0; i < orgArrays.length; i++) {
                    results[i] = new Long(orgArrays[i]);
                }
                return results;
            }
            return null;
        }

        /**
         * 将对象数组转成字符串
         * @param array
         * @return
         */
        public static String objectsToStrings(Object[] array,String sepSign) {
            if (array != null && array.length > 0) {
                String result = "";
                for (int i = 0; i < array.length; i++) {
                    if (i==0) {
                        result = array[0].toString();
                    }else {
                        result = result+sepSign+array[i];
                    }
                }
                return result;
            }
            return null;
        }

        /**
         * 验证字符串数组中是否存在字符串
         * @param strs
         * @param str
         * @return Boolean
         */
        public static Boolean checkStringInStrings(String[] strs, String str) {
            if (strs != null && strs.length > 0) {
                for (String string : strs) {
                    if (string.equals(str)) {
                        return true;
                    }
                }
            }
            return false;
        }

        /**
         * 对象数组转成字符数组
         * @param objArray
         * @return
         */
        public static String[] objectsToStrings(Object[] objArray) {
            if (ArrayUtils.isNotEmpty(objArray)) {
                String[] strArray = new String[objArray.length];
                for (int i = 0; i < objArray.length; i++) {
                    strArray[i] = (String) objArray[i];
                }
                return strArray;
            }
            return null;
        }

        /**
         * 将字符串数组中的元素合并成为一个字符串
         */
        public static String comb2Str(String[] strs, String sign) {
            String combStr = "";
            if (strs != null && strs.length > 0) {
                for (int i = 0; i < strs.length; i++) {
                    combStr = strs[i] + sign + combStr;
                }
            }
            return combStr;
        }
    }

    public static class JSON{
        /**
         * 将JSONArray字符串转成Sting数组
         * @param jsonArrayStr
         * @return
         */
        public static Integer[] jsonArrayToIntegerArray(String jsonArrayStr){
            if (StringUtils.isNotEmpty(jsonArrayStr)) {
                JSONArray jsonArray = JSONArray.fromObject(jsonArrayStr);
                Integer[] array = new Integer[jsonArray.size()];
                array = (Integer[]) jsonArray.toArray(array);
                return array;
            }
            return null;
        }
    }

    public static void main(String[] args) {
        String value = MyUtilTool.DATE.currentDateString(null);
        System.out.println(value);
    }
}

　　

时间： 2024-10-06 19:11:29

通用工具类方法的相关文章

微信小程序开发入门教程

做任何程序开发要首先找到其官方文档,微信小程序目前还在邀请内测阶段,目前官方放出了部分开发文档,经过笔者一天的查看和尝试,感觉文档并不全面,但是通过这些文档已经能够看出其大概面貌了.闲话不多说,我们先来看看其有哪些官方文档. 微信公众平台开发者文档统一入口为:https://mp.weixin.qq.com/wiki,这里面大部分内容都是以前就有的,微信开发都是基于此份文档. 现在的变化是在这份文档的顶部加了一个“微信公众平台.小程序”的入口,这个入口才就是专门针对微信小程序开发的文档,如下图:

微信开发(2)---微信小程序开发实战part1

微信开发现在来说,简单可以概括为两部分,微信公众号和微信小程序. 微信公众号的技术已经非常成熟.分为服务号和订阅号.简单的.可以弄一个个人订阅号,在编辑模式下就可以实现推送图文.自动回复.自定义菜单的常用功能.切换至开发模式,可以搭服务器,使用php语言及各种成熟接口完成自己想要实现的功能,相对而言非常方便.大家对公众号感兴趣的可以自己去注册个个人订阅号探索一下,微信公众平台跳转: https://mp.weixin.qq.com/ 再来说微信小程序,16年初上线示例,到现在技术已经基本趋于成熟

微信小程序之注册和入门

一.注册 首先,在微信公众平台mp.weixin.qq.com上注册一个帐号. 小程序开放个人开发者申请注册,个人用户可访问微信公众平台,扫码验证个人身份后即可完成小程序帐号申请并进行代码开发. 这里不写太详细,请查看 https://jingyan.baidu.com/article/4e5b3e192a33da91911e2455.html 注册完了跳转到以下页面, 补充信息,然后下载工具安装: 可以不用添加开发者,自己就是了: 二.开发入门 1.创建一个项目 登录成功后,如果是第一次使用该

焦作市共享链商家软件开发

小程序共享链商家开发,小程序共享链商家软件(陈琦:138-2848-7919可微)小程序共享链商家平台,小程序共享链商家模式商家与微信共享链合作之后,消费者在该店通过微信支付的金额会按照消费顺序依次被奖励到消费者的微信共享链内,绑卡提现即可实时到账. 互联网购物的大潮下,中国的实体店铺面临了前所未有的巨大的考验和挑战,开店做生意的道路坎坷而艰难,许多店铺产品品质优良,服务到位,但仍门庭冷落,艰难经营,面临关门.共享链给这类产品好,营销弱的店铺一次超越同行的机会,帮助店铺留住客户,通过让客户分享消

【day25】类方法classmethod、静态方法staticmethod、普通方法

  普通方法:通过实例传参数进行调用的方法.s = 类(参数) 静态方法staticmethod:如果我们想写仅仅与类交互而不是与实例交互的方法,用类方法就可以达成,好处是不让类代码的关系到类定义的外面,也避免了今后代码维护的困难. class Foo: def __init__(self): pass @staticmethod def say_hi(self): print('hi,im staticmethod') Foo.say_hi() #不用实例化,就可以调用该方法 #输出hi,im

python 静态方法、实例方法、类方法

实例方法: class A: data = 0 def printd(self): print(self.data) type(A) #out:type A.__dict__ #out: a = A() #out:{} 类方法:@classmethod class A: data = 0 def printd(self): print(self.data) def getdata(): A.data = 1 print(A.data) class A: data = 0 def printd(s

Python-面向对象高级语法之静态方法、类方法

静态方法 一.什么是静态方法 普通的方法可以在实例化后直接调用,并且在方法里可以通过self.xxx调用实例变量或类变量,而静态方法是不可以访问实例变量或类变量,一个不能访问实例变量和类变量的方法,实际上已经和类本身没什么关系了.唯一与类有关联的就是有需要通过类名来调用这个方法. 二.如何使用静态方法 通过@staticmethod装饰器把需其装饰的方法即可变成一个静态方法. # _*_ coding:utf-8 _*_ class Dog(object): def __init__(self,

django之创建第4-2个项目-访问class类属性和类方法

1.修改index <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>django之创建第4-2个项目</title> </head> <body> <h1>hello,{{test.name}}</h1> <!--模板 变量用变量定义--> &l

tablib.Dataset()操作exl类型数据之“类方法”研究

#tablib.Dataset()操作exl类型数据之“类方法”研究 import tablib #初始化 data=tablib.Dataset() #设置列标题 data.headers=('name','where') some_collector=[('xiaodeng','enshi'),('xiaoming','hubei'),('xiaodong','enshi')] #写入数据 for key,value in some_collector: data.append((key,v