工具类_工具类产品 - CSDN
精华内容
参与话题
  • JAVA 实用的工具类 汇总

    千次阅读 2018-05-30 11:47:18
    字符分隔工具类 java.util.StringTokenizer

    字符分隔工具类

    java.util.StringTokenizer

    展开全文
  • 常用的Java工具类——十六种

    千次阅读 2019-01-16 21:39:43
    在Java中,工具类定义了一组公共方法,这篇文章将介绍Java中使用最频繁及最通用的Java工具类。以下工具类、方法按使用流行度排名,参考数据来源于Github上随机选取的5万个开源项目源码。 一. org.apache.commons.io...

    干货:排名前16的Java工具类

     

    在Java中,工具类定义了一组公共方法,这篇文章将介绍Java中使用最频繁及最通用的Java工具类。以下工具类、方法按使用流行度排名,参考数据来源于Github上随机选取的5万个开源项目源码。

    一. org.apache.commons.io.IOUtils

    closeQuietly:关闭一个IO流、socket、或者selector且不抛出异常,通常放在finally块
    toString:转换IO流、 Uri、 byte[]为String
    copy:IO流数据复制,从输入流写到输出流中,最大支持2GB
    toByteArray:从输入流、URI获取byte[]
    write:把字节. 字符等写入输出流
    toInputStream:把字符转换为输入流
    readLines:从输入流中读取多行数据,返回List<String>
    copyLarge:同copy,支持2GB以上数据的复制
    lineIterator:从输入流返回一个迭代器,根据参数要求读取的数据量,全部读取,如果数据不够,则失败
    

    二. org.apache.commons.io.FileUtils

    deleteDirectory:删除文件夹
    readFileToString:以字符形式读取文件内容
    deleteQueitly:删除文件或文件夹且不会抛出异常
    copyFile:复制文件
    writeStringToFile:把字符写到目标文件,如果文件不存在,则创建
    forceMkdir:强制创建文件夹,如果该文件夹父级目录不存在,则创建父级
    write:把字符写到指定文件中
    listFiles:列举某个目录下的文件(根据过滤器)
    copyDirectory:复制文件夹
    forceDelete:强制删除文件
    

    三. org.apache.commons.lang.StringUtils

    isBlank:字符串是否为空 (trim后判断)
    isEmpty:字符串是否为空 (不trim并判断)
    equals:字符串是否相等
    join:合并数组为单一字符串,可传分隔符
    split:分割字符串
    EMPTY:返回空字符串
    trimToNull:trim后为空字符串则转换为null
    replace:替换字符串
    

    四. org.apache.http.util.EntityUtils

    toString:把Entity转换为字符串
    consume:确保Entity中的内容全部被消费。可以看到源码里又一次消费了Entity的内容,假如用户没有消费,那调用Entity时候将会把它消费掉
    toByteArray:把Entity转换为字节流
    consumeQuietly:和consume一样,但不抛异常
    getContentCharset:获取内容的编码
    

    五. org.apache.commons.lang3.StringUtils

    isBlank:字符串是否为空 (trim后判断)
    isEmpty:字符串是否为空 (不trim并判断)
    equals:字符串是否相等
    join:合并数组为单一字符串,可传分隔符
    split:分割字符串
    EMPTY:返回空字符串
    replace:替换字符串
    capitalize:首字符大写
    

    六. org.apache.commons.io.FilenameUtils

    getExtension:返回文件后缀名
    getBaseName:返回文件名,不包含后缀名
    getName:返回文件全名
    concat:按命令行风格组合文件路径(详见方法注释)
    removeExtension:删除后缀名
    normalize:使路径正常化
    wildcardMatch:匹配通配符
    seperatorToUnix:路径分隔符改成unix系统格式的,即/
    getFullPath:获取文件路径,不包括文件名
    isExtension:检查文件后缀名是不是传入参数(List<String>)中的一个
    

    七. org.springframework.util.StringUtils

    hasText:检查字符串中是否包含文本
    hasLength:检测字符串是否长度大于0
    isEmpty:检测字符串是否为空(若传入为对象,则判断对象是否为null)
    commaDelimitedStringToArray:逗号分隔的String转换为数组
    collectionToDelimitedString:把集合转为CSV格式字符串
    replace 替换字符串
    7. delimitedListToStringArray:相当于split
    uncapitalize:首字母小写
    collectionToDelimitedCommaString:把集合转为CSV格式字符串
    tokenizeToStringArray:和split基本一样,但能自动去掉空白的单词
    

    八. org.apache.commons.lang.ArrayUtils

    contains:是否包含某字符串
    addAll:添加整个数组
    clone:克隆一个数组
    isEmpty:是否空数组
    add:向数组添加元素
    subarray:截取数组
    indexOf:查找某个元素的下标
    isEquals:比较数组是否相等
    toObject:基础类型数据数组转换为对应的Object数组
    

    九. org.apache.commons.lang.StringEscapeUtils

    参考十五:org.apache.commons.lang3.StringEscapeUtils
    

    十. org.apache.http.client.utils.URLEncodedUtils

    format:格式化参数,返回一个HTTP POST或者HTTP PUT可用application/x-www-form-urlencoded字符串
    parse:把String或者URI等转换为List<NameValuePair>
    

    十一. org.apache.commons.codec.digest.DigestUtils

    md5Hex:MD5加密,返回32位字符串
    sha1Hex:SHA-1加密
    sha256Hex:SHA-256加密
    sha512Hex:SHA-512加密
    md5:MD5加密,返回16位字符串
    

    十二. org.apache.commons.collections.CollectionUtils

    isEmpty:是否为空
    select:根据条件筛选集合元素
    transform:根据指定方法处理集合元素,类似List的map()
    filter:过滤元素,雷瑟List的filter()
    find:基本和select一样
    collect:和transform 差不多一样,但是返回新数组
    forAllDo:调用每个元素的指定方法
    isEqualCollection:判断两个集合是否一致
    

    十三. org.apache.commons.lang3.ArrayUtils

    contains:是否包含某个字符串
    addAll:添加整个数组
    clone:克隆一个数组
    isEmpty:是否空数组
    add:向数组添加元素
    subarray:截取数组
    indexOf:查找某个元素的下标
    isEquals:比较数组是否相等
    toObject:基础类型数据数组转换为对应的Object数组
    

    十四. org.apache.commons.beanutils.PropertyUtils

    getProperty:获取对象属性值
    setProperty:设置对象属性值
    getPropertyDiscriptor:获取属性描述器
    isReadable:检查属性是否可访问
    copyProperties:复制属性值,从一个对象到另一个对象
    getPropertyDiscriptors:获取所有属性描述器
    isWriteable:检查属性是否可写
    getPropertyType:获取对象属性类型
    

    十五. org.apache.commons.lang3.StringEscapeUtils

    unescapeHtml4:转义html
    escapeHtml4:反转义html
    escapeXml:转义xml
    unescapeXml:反转义xml
    escapeJava:转义unicode编码
    escapeEcmaScript:转义EcmaScript字符
    unescapeJava:反转义unicode编码
    escapeJson:转义json字符
    escapeXml10:转义Xml10
    

    这个现在已经废弃了,建议使用commons-text包里面的方法。

    十六. org.apache.commons.beanutils.BeanUtils

    copyPeoperties:复制属性值,从一个对象到另一个对象
    getProperty:获取对象属性值
    setProperty:设置对象属性值
    populate:根据Map给属性复制
    copyPeoperty:复制单个值,从一个对象到另一个对象
    cloneBean:克隆bean实例
    

    现在你只要了解了以上16种最流行的工具类方法,你就不必要再自己写工具类了,不必重复造轮子。大部分工具类方法通过其名字就能明白其用途,如果不清楚的,可以看下别人是怎么用的,或者去网上查询其用法。

    根据阿里开发手册,包名如果要使用util不能带s,工具类命名为XxxUtils。

    展开全文
  • jedisUtil工具类java

    2020-07-30 23:32:08
    jedis的工具类,java代码写的,非常全面,jedis的工具类,java代码写的,非常全面jedis的工具类,java代码写的,非常全面jedis的工具类,java代码写的,非常全面jedis的工具类,java代码写的,非常全面jedis的工具类...
  • Util工具类

    万次阅读 2017-10-30 14:52:23
    Util工具类
    
    public class Util {
        /**
         * log4j
         */
        private final static Logger logger = LoggerFactory.getLogger(Util.class);
    
        /**
         * 随即获取32位ID
         * <p>
         * 2017年8月3日 13:26:45
         * xj
         *
         * @return String
         */
        public static String getUUID() {
            return UUID.randomUUID().toString().replaceAll("-", "");
        }
    
        /**
         * 将指定数据转换为int型
         *
         * 2017年8月3日 13:28:34
         * xj
         *
         * @param o 指定数据
         * @return int
         */
        public static int getInt(Object o) {
            if (o instanceof BigDecimal) {
                return ((BigDecimal) o).intValue();
            } else if (o instanceof Integer) {
                return ((Integer) o).intValue();
            } else if (o instanceof Float) {
                return ((Float) o).intValue();
            } else if (o instanceof Double) {
                return ((Double) o).intValue();
            }
    
            throw new RuntimeException("can't parse object to int");
        }
    
        /**
         * 获取股票得分表(SV_SCORE)当前月份表名
         *
         * @return
         */
        public static String getCurrentScoreTableName() {
            String name = null;
            Calendar calendar = Calendar.getInstance();
            int year = calendar.get(Calendar.YEAR);
    //        int month = calendar.get(Calendar.MONTH) + 1;
    //        if (month < 10) {
    //            name = "SV_SCORE_" + year + "0" + month;
    //        } else {
    //            name = "SV_SCORE_" + year + "" + month;
    //        }
            name = "SV_SCORE_" + year;
    
            return name;
        }
    
    
        /**
         * 获取股票得分表(SV_SCORE)指定格式的日期的月份表名
         * <p>
         * 2017年8月8日 16:25:18
         * xj
         *
         * @param date 指定日期
         * @return String
         */
        public static String getScoreTableNameByTime(String date) {
            String name = null;
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(Util.transformStringToDate(date, "yyyy-MM-dd"));
            int year = calendar.get(Calendar.YEAR);
    //        int month = calendar.get(Calendar.MONTH) + 1;
    //        if (month < 10) {
    //            name = "SV_SCORE_" + year + "0" + month;
    //        } else {
    //            name = "SV_SCORE_" + year + "" + month;
    //        }
            name = "SV_SCORE_" + year;
            return name;
        }
    
        /**
         * 获取指定时间的最近半年时间月份第一天
         * <p>
         * 2017年8月8日 17:19:10
         * xj
         *
         * @param date 指定日期
         * @return String[]
         */
        public static String[] getHalfYear(Date date) {
            String[] last6Months = new String[6];
            Calendar cal = Calendar.getInstance();
            cal.setTime(date);
            //要先+1,才能把本月的算进去
            cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) + 1);
            for (int i = 0; i < 6; i++) {
                //逐次往前推1个月
                cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) - 1);
                last6Months[5 - i] = cal.get(Calendar.YEAR) + "-" + (cal.get(Calendar.MONTH) + 1) + "-01";
            }
    
            return last6Months;
        }
    
        /**
         * 获取Date类型yyyy-MM-dd格式的当前时间
         *
         * 2017年8月3日 10:56:09
         * xj
         *
         * @return Date
         */
        public static Date getCurrentDate() {
            Date date = new Date();
            DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            String dateStr = format.format(date);
            Date curDay = null;
            try {
                curDay = format.parse(dateStr);
            } catch (ParseException e) {
                logger.error(e.getMessage(), e);
            }
    
            return curDay;
        }
    
        /**
         * 日期加减
         *
         * @param date       指定日期
         * @param dateFormat 指定日期格式
         * @param year       加减年数
         * @return -1 为日期格式错误
         */
        public static String minusYear(String date, String dateFormat, int year) {
            SimpleDateFormat format = new SimpleDateFormat(dateFormat);
            try {
                Calendar calendar = Calendar.getInstance();
                Date now = format.parse(date);
                calendar.setTime(now);
                calendar.add(Calendar.YEAR, year);
                return format.format(calendar.getTime());
            } catch (ParseException e) {
                logger.error(e.getMessage(), e);
                return "-1";
            }
        }
    
        /**
         * 日期加减
         *
         * @param date       指定日期
         * @param dateFormat 指定日期格式
         * @param day        加减天数
         * @return    -1 为日期格式错误
         */
        public static String minusDay(String date, String dateFormat, int day) {
            SimpleDateFormat format = new SimpleDateFormat(dateFormat);
            try {
                Calendar calendar = Calendar.getInstance();
                Date now = format.parse(date);
                calendar.setTime(now);
                calendar.add(Calendar.DAY_OF_MONTH, day);
                return format.format(calendar.getTime());
            } catch (ParseException e) {
                logger.error(e.getMessage(), e);
                return "-1";
            }
        }
    
        /**
         * 日期加减
         *
         * @param date       指定日期
         * @param dateFormat 指定日期格式
         * @param day        加减天数
         * @return null 为日期格式错误
         */
        public static Date minusDate(String date, String dateFormat, int day) {
            SimpleDateFormat format = new SimpleDateFormat(dateFormat);
            try {
                Calendar calendar = Calendar.getInstance();
                Date now = format.parse(date);
                calendar.setTime(now);
                calendar.add(Calendar.DAY_OF_MONTH, day);
                return calendar.getTime();
            } catch (ParseException e) {
                logger.error(e.getMessage(), e);
                return null;
            }
        }
    
        /**
         * 将日期字符串转换为Date类型
         * String类型的日期格式和要转化的format格式必须一样
         *
         * @param dateStr    日期字符串
         * @param dateFormat 日期格式  yyyy-MM-dd
         * @return date
         */
        public static Date transformStringToDate(String dateStr, String dateFormat) {
            Date date = null;
            DateFormat format = new SimpleDateFormat(dateFormat);
            try {
                date = format.parse(dateStr);
            } catch (ParseException e) {
                logger.error(e.getMessage(), e);
            }
    
            return date;
        }
    
        /**
         * 将Date类型转换为日期字符串
         *
         * @param date       日期字符串
         * @param dateFormat 日期格式
         * @return dateStr
         */
        public static String transformDateToString(Date date, String dateFormat) {
            if (date == null || StringUtils.isEmpty(dateFormat)) {
                return "";
            }
            DateFormat format = new SimpleDateFormat(dateFormat);
            return format.format(date);
        }
    
        /**
         * 获取某日期区间的所有日期  日期倒序
         *
         * @param startDate  开始日期
         * @param endDate    结束日期
         * @param dateFormat 日期格式
         * @return 区间内所有日期
         */
        public static List<String> getPerDaysByStartAndEndDate(String startDate, String endDate, String dateFormat) {
            DateFormat format = new SimpleDateFormat(dateFormat);
            try {
                Date sDate = format.parse(startDate);
                Date eDate = format.parse(endDate);
                long start = sDate.getTime();
                long end = eDate.getTime();
                if (start > end) {
                    return null;
                }
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(eDate);
                List<String> res = new ArrayList<String>();
                while (end >= start) {
                    res.add(format.format(calendar.getTime()));
                    calendar.add(Calendar.DAY_OF_MONTH, -1);
                    end = calendar.getTimeInMillis();
                }
                return res;
            } catch (ParseException e) {
                logger.error(e.getMessage(), e);
            }
            return null;
        }
    
        /**
         * 获取某日期区间的所有12月31日的日期  日期倒序
         *
         * @param startDate 开始日期   yyyy-MM-dd
         * @param endDate   结束日期   yyyy-MM-dd
         * @return 区间内所有日期
         */
        public static List<String> getPerYearByStartAndEndDate(String startDate, String endDate) {
            String start = startDate.substring(0, startDate.indexOf("-"));
            String end = endDate.substring(0, endDate.indexOf("-"));
            int s = Integer.parseInt(start);
            int e = Integer.parseInt(end);
            if (!(end + "-12-31").equals(endDate)) {
                e--;
            }
            List<String> res = new ArrayList<String>();
            while (e >= s) {
                res.add(e + "-12-31");
                e--;
            }
            return res;
        }
    
        /**
         * 获取某日期区间的年份
         *
         * @param startDate 开始日期   yyyy
         * @param endDate   结束日期   yyyy
         * @return 区间内所有日期
         */
        public static List<String> getYearsByStartAndEndDate(String startDate, String endDate) {
            Integer s = Integer.parseInt(startDate);
            Integer e = Integer.parseInt(endDate);
            List<String> res = new ArrayList<String>();
            while (e >= s) {
                res.add(e.toString());
                e--;
            }
            return res;
        }
    
        /**
         * 对含有map的list排序
         *
         * @param areaList 原始值
         * @param isDesc   TRUE:从大到小  FALSE:从小到大
         */
        public static void sortListMap(List<Map.Entry<String, Double>> areaList, final boolean isDesc) {
            Collections.sort(areaList, new Comparator<Map.Entry<String, Double>>() {
                public int compare(Map.Entry<String, Double> o1,
                                   Map.Entry<String, Double> o2) {
                    int flag = 1;
                    if (isDesc) {
                        if (o2.getValue() - o1.getValue() < 0) {
                            flag = -1;
                        }
                    } else {
                        if (o2.getValue() - o1.getValue() > 0) {
                            flag = -1;
                        }
                    }
    
                    return flag;
                }
            });
        }
    
        /**
         * 对map中含有String类型的日期key值的list进行排序
         * <p>
         * 2017年9月29日 17:19:09
         * xj
         *
         * @param list   List<Map<String,Object>>,String为日期
         * @param format 日期格式
         * @param isDesc TRUE:从大到小  FALSE:从小到大
         */
        public static void sortListStringDateMap(List list, final String format, final boolean isDesc) {
            Collections.sort(list, new Comparator() {
                @Override
                public int compare(Object o1, Object o2) {
                    Map<String, Object> o1Map = (Map<String, Object>) o1;
                    Map<String, Object> o2Map = (Map<String, Object>) o2;
                    String o1Key = "";
                    for (String key : o1Map.keySet()) {
                        o1Key = key;
                    }
                    String o2Key = "";
                    for (String key : o2Map.keySet()) {
                        o2Key = key;
                    }
                    Integer o1K = Integer.valueOf(Util.transformDateToString(Util.transformStringToDate(o1Key, format), "yyyyMMdd"));
                    Integer o2K = Integer.valueOf(Util.transformDateToString(Util.transformStringToDate(o2Key, format), "yyyyMMdd"));
                    int flag = 1;
                    if (isDesc) {
                        if (o2K - o1K < 0) {
                            flag = -1;
                        }
                    } else {
                        if (o2K - o1K > 0) {
                            flag = -1;
                        }
                    }
    
                    return flag;
                }
            });
    
        }
    
        /**
         * null转为空字符串
         *
         * @param obj
         * @return
         */
        public static Object nvl(Object obj) {
            if (null == obj) {
                return "";
            }
            return obj;
        }
    
        /**
         * @methodName nullTrans
         * @describe 将空值转化成空字符串
         * @author xj
         * @date 2017/10/18 15:49
         * @param obj
         * @return java.lang.Object
         */
        public static String nullTrans(Object obj){
            String nullValue = "null";
            String nuValue = "nu";
            if (null == obj || nullValue.equals(obj) || nuValue.equals(obj)){
                return "";
            }
            return obj.toString();
        }
    
        /**
         * 数字类型数组转换为以逗号分隔的字符串
         *
         * @param arr
         * @return
         */
        public static String transformArrayToString(Object[] arr) {
            if (null == arr || arr.length == 0) {
                return null;
            }
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < arr.length; i++) {
                sb.append(arr[i]).append(",");
            }
            return sb.substring(0, sb.length() - 1);
        }
    
        /**
         * 字符串类型数组转换为以逗号分隔的字符串, 字符串加引号
         *
         * @param arr
         * @return
         */
        public static String transformArrayToStringQ(Object[] arr) {
            if (null == arr || arr.length == 0) {
                return null;
            }
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < arr.length; i++) {
                sb.append("'").append(arr[i]).append("'").append(",");
            }
            return sb.substring(0, sb.length() - 1);
        }
    
        /**
         * double类型加法,防止失去精度
         *
         * @param d1
         * @param d2
         * @return
         */
        public static double addDouble(Double d1, Double d2) {
            BigDecimal bd1 = new BigDecimal(d1.toString());
            BigDecimal bd2 = new BigDecimal(d2.toString());
            return bd1.add(bd2).doubleValue();
        }
    
        /**
         * 比较两个double是否相等
         *
         * @param d1
         * @param d2
         * @return  当此 BigDecimal 在数字上小于、等于或大于 val 时,返回 -1、0 或 1。
         */
        public static int compareToDouble(String d1, String d2) {
            BigDecimal bd1 = new BigDecimal(d1);
            BigDecimal bd2 = new BigDecimal(d2);
            return bd1.compareTo(bd2);
        }
    
        /**
         * double类型减法,防止失去精度
         *
         * @param d1
         * @param d2
         * @return
         */
        public static Double subtractDouble(Double d1, Double d2) {
            BigDecimal bd1 = new BigDecimal(d1.toString());
            BigDecimal bd2 = new BigDecimal(d2.toString());
            return bd1.subtract(bd2).doubleValue();
        }
    
        /**
         * double 乘法
         *
         * @param d1
         * @param d2
         * @return
         */
        public static Double multiplyDouble(Double d1, Double d2) {
            BigDecimal bd1 = new BigDecimal(d1.toString());
            BigDecimal bd2 = new BigDecimal(d2.toString());
            return bd1.multiply(bd2).doubleValue();
        }
    
        /**
         * double 除法
         *
         * @param d1
         * @param d2
         * @param scale 四舍五入 小数点位数
         * @return
         */
        public static Double divideDouble(Double d1, Double d2, int scale) {
            //  当然在此之前,你要判断分母是否为0,
            //  为0你可以根据实际需求做相应的处理
            BigDecimal bd1 = new BigDecimal(d1.toString());
            BigDecimal bd2 = new BigDecimal(d2.toString());
            return bd1.divide(bd2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
        }
    
        /**
         * 精度,四舍五入
         *
         * @param d1
         * @param scale
         * @return
         */
        public static Double round(Double d1, int scale) {
            if (d1 == null) {
                return null;
            }
            BigDecimal bd1 = new BigDecimal(d1.toString());
            return bd1.setScale(scale, RoundingMode.HALF_UP).doubleValue();
        }
    
        /**
         * 转码以提供中文名文件下载支持
         *
         * @param fileName
         * @return
         */
        public static String getAttachFileNameForCn(String fileName) {
            StringBuffer sb = new StringBuffer();
            try {
                sb.append("filename=").append(URLEncoder.encode(fileName, "UTF-8"))
                        .append(";filename*=UTF-8''").append(URLEncoder.encode(fileName, "UTF-8"));
            } catch (UnsupportedEncodingException e) {
                logger.error(e.getMessage(), e);
            }
    
            return sb.toString();
        }
    
        /**
         * 判断项目的架包目录中是否存在upload文件夹、svUpload文件夹
         * 如果存在直接返回svUpload文件夹完整url,如果不存在则创建upload文件夹、svUpload文件夹,
         * 在返回svUpload文件夹url
         * <p>
         * 2017年7月10日 15:16:19
         * xj
         *
         * @return String
         */
        public static String getUploadUrl() {
            String url = JarUrlUtil.getJarUrl();
            url += File.separator + "upload";
            File file2 = new File(url);
            if (!file2.isDirectory()) {
                file2.mkdir();
                url += File.separator + "svUpload";
                File file1 = new File(url);
                if (!file1.isDirectory()) {
                    file1.mkdir();
                }
            } else {
                url += File.separator + "svUpload";
                File file1 = new File(url);
                if (!file1.isDirectory()) {
                    file1.mkdir();
                }
            }
            return url;
        }
    
        /**
         * 判断项目的架包目录中是否存在download文件夹,
         * 如果存在则返回download文件夹完成路径,如果不存在,创建download文件夹,在返回其完整路径。
         * <p>
         * 2017年7月21日 10:32:54
         * xj
         *
         * @return String
         */
        public static String getDownloadUrl() {
            String url = JarUrlUtil.getJarUrl();
            url += File.separator + "download";
            File downloadFile = new File(url);
            if (!downloadFile.isDirectory()) {
                downloadFile.mkdir();
            }
            return url;
        }
    
        /**
         * 判断项目的架包目录中是否存在template文件夹,
         * 如果存在则返回template文件夹完成路径,如果不存在,创建template文件夹,在返回其完整路径。
         * <p>
         * 2017年7月27日 14:58:16
         * xj
         *
         * @return String
         */
        public static String getTemplateUrl() {
            String url = JarUrlUtil.getJarUrl();
            url += File.separator + "template";
            File templateFile = new File(url);
            if (!templateFile.isDirectory()) {
                templateFile.mkdir();
            }
            return url;
        }
    
        /**
         * 判断当前fileUrl是否存在fileName文件夹,
         * 如果存在则返回fileName文件夹完成路径,如果不存在,创建fileName文件夹,在返回其完整路径。
         * <p>
         * 2017年7月28日 14:59:48
         * xj
         *
         * @param fileUrl 文件所在路径
         * @return String
         */
        public static String getFileUrl(String fileUrl) {
            File file = new File(fileUrl);
            if (!file.isDirectory()) {
                file.mkdir();
            }
            return fileUrl;
        }
    
        /**
         * 格式化数字
         *
         * @param format
         * @param obj
         * @return
         */
        public static String formatByDecimalFormat(String format, Object obj) {
            if (null != obj && !"".equals(obj)) {
                DecimalFormat decimalFormat = new DecimalFormat(format);
                return decimalFormat.format(obj);
            }
            return "";
        }
    
        /**
         * 返回一个空表格格式Grid
         * <p>
         * 2017年7月12日 16:12:01
         * xj
         *
         * @param idsList
         * @param hdsList
         * @return
         */
        public static Grid getNullGrid(List<String> idsList, List<String> hdsList) {
            Grid grid = new Grid(null, 0);
            grid.setIds(idsList);
            grid.setHds(hdsList);
            grid.setRows(null);
            return grid;
        }
    
        /**
         * 将时间戳转换为时间
         * <p>
         * 2017年7月12日 17:40:43
         * xj
         *
         * @param s 时间戳
         * @return "yyyy-MM-dd HH:mm:ss"
         */
        public static String stampToDate(String s) {
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            long lt = new Long(s);
            Date date = new Date(lt);
            String res = simpleDateFormat.format(date);
            return res;
        }
    
        /**
         * 将字Clob转成String类型
         * <p>
         * 2017年8月31日 15:24:48
         * xj
         *
         * @param sc clob对象
         * @return String
         * @throws SQLException
         * @throws IOException
         */
        public static String ClobToString(Clob sc) throws SQLException, IOException {
            String reString = "";
            // 得到流
            Reader is = sc.getCharacterStream();
            BufferedReader br = new BufferedReader(is);
            String s = br.readLine();
            StringBuffer sb = new StringBuffer();
            // 执行循环将字符串全部取出付值给StringBuffer由StringBuffer转成STRING
            while (s != null) {
                sb.append(s);
                s = br.readLine();
            }
            reString = sb.toString();
            return reString;
        }
    
        /**
         * 获取传入时间某几年之前的日期
         * <p>
         * 2017年9月1日 10:12:40
         * xj
         *
         * @param date     指定日期
         * @param someYear 某几年
         * @return String
         */
        public static String getLastSomeYear(String date, Integer someYear) {
            Integer lastSomeYear = Integer.parseInt(date.substring(0, 4)) - someYear;
            date = lastSomeYear + date.substring(4);
            return date;
        }
    
        /**
         * 获取指定dateFormat格式的date,某几个月之前的日期
         * <p>
         * 2017年9月1日 11:15:31
         * xj
         *
         * @param date       传入日期
         * @param dateFormat 日期格式
         * @param someMonth  某几个月
         * @return Date
         */
        public static Date getLastSomeMonth(String date, String dateFormat, Integer someMonth) {
            SimpleDateFormat format = new SimpleDateFormat(dateFormat);
            Calendar c = Calendar.getInstance();
            c.setTime(Util.transformStringToDate(date, dateFormat));
            //得到前几个月
            c.add(Calendar.MONTH, -(someMonth));
            Date time = Util.transformStringToDate(format.format(c.getTime()), dateFormat);
            return time;
        }
    
        /**
         * 检查上传文件是否为空
         * <p>
         * 2017年9月4日 13:14:36
         * xj
         *
         * @param request 请求request对象
         * @return MultipartFile
         */
        public static MultipartFile checkFile(HttpServletRequest request) {
            if (!(request instanceof MultipartHttpServletRequest)) {
                throw new ServiceException(ResultEnum.NO_FILE);
            }
            MultipartFile file = ((MultipartHttpServletRequest) request).getFile("file");
            if (file.isEmpty()) {
                throw new ServiceException(ResultEnum.NO_FILE);
            }
            return file;
        }
    
        /**
         * <li>功能描述:时间相减得到天数
         * <p>
         * 2017年9月5日 15:13:36
         * xj
         *
         * @param beginDateStr 开始日期
         * @param endDateStr   结束日期
         * @return long
         */
        public static long getDaySub(String beginDateStr, String endDateStr) {
            long day = 0;
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            Date beginDate;
            Date endDate;
            try {
                beginDate = format.parse(beginDateStr);
                endDate = format.parse(endDateStr);
                day = (endDate.getTime() - beginDate.getTime()) / (24 * 60 * 60 * 1000);
            } catch (ParseException e) {
                logger.error(e.getMessage(), e);
            }
    
            return day;
        }
    
        /**
         * 获取指定月份的天数
         * <p>
         * 2017年9月6日 13:11:05
         * xj
         *
         * @param date 指定日期
         * @return Integer
         */
        public static Integer getMonthDays(String date) {
            Calendar a = Calendar.getInstance();
            a.setTime(Util.transformStringToDate(date, "yyyy-MM-dd"));
            //把日期设置为当月第一天
            a.set(Calendar.DATE, 1);
            //日期回滚一天,也就是最后一天
            a.roll(Calendar.DATE, -1);
            int maxDate = a.get(Calendar.DATE);
            return maxDate;
        }
    
        /**
         * 获得指定月份的,月末日期
         *
         * @param date 指定日期
         * @return String
         */
        public static String getMonthEndStringDateByMonth(String date, String dateFormat) {
            Calendar c = Calendar.getInstance();
            c.setTime(Util.transformStringToDate(date, dateFormat));
            c.set(Calendar.DAY_OF_MONTH, c.getActualMaximum(Calendar.DAY_OF_MONTH));
            return transformDateToString(c.getTime(), dateFormat);
        }
    
        /**
         * 比较日期大小
         * <p>
         * 2017年9月7日 16:15:53
         * xj
         *
         * @param DATE1      第一个时间
         * @param DATE2      第二个时间
         * @param dateFormat 日期格式
         * @return Integer null日期格式有误,1:第一个日期大,0:两个日期一样,-1:第二个日期大
         */
        public static Integer compareDate(String DATE1, String DATE2, String dateFormat) {
            DateFormat df = new SimpleDateFormat(dateFormat);
            try {
                Date dt1 = df.parse(DATE1);
                Date dt2 = df.parse(DATE2);
                if (dt1.getTime() > dt2.getTime()) {
                    return 1;
                } else if (dt1.getTime() < dt2.getTime()) {
                    return -1;
                } else {
                    return 0;
                }
            } catch (Exception e) {
                logger.error(e.toString(), e);
            }
            return null;
        }
    
    } // class 结束
    
    展开全文
  • 这样才是写工具类

    千次阅读 2019-10-31 15:29:36
    什么是工具类? 这种 低级的问题还问的出来。 最近我发现 好多东西都是一看就懂。然而,自己不知道什么时候就能写出 shi 一样的代码。 这是因为编码时的构思,没有明确下来,构思不清晰,就相当于地基不稳。 ...

    在这里插入图片描述

    文章讲的很浅,道理大家都懂。写出来,是为了更好的贯彻它!
    
    与君共勉
    
    什么是工具类?

    在这里插入图片描述
    这种 低级的问题还问的出来。

    最近我发现 好多东西都是一看就懂。然而,自己不知道什么时候就能写出 shi 一样的代码。
    这是因为编码时的构思,没有明确下来,构思不清晰,就相当于地基不稳。

    接下来,我们以 TimeUtil为例讲解我的思考。


    TimeUtils编码时的考量

    偶然的一次CodeReview,发现TimeUtils竟然不知道什么时候,变乱了。

    我知道 我该重构了。可是在重构之前,我仔细反思了自己对这个类的维护。说到底还是思考不充分导致。

    没有经过思考的代码,是没有灵气的代码。

    大道至简

    我需要一个核心思想。于是,我开始琢磨。。

    思考描述

    及时的记录自己当时的想法,请写进CodeDesc中。

     * 在实际项目中,总可能会出现各种各样的时间格式,花样百出
     * 后端给N种格式,前端再转换再显示。
     * 讲道理,是要统一后端给的格式:时间戳。
     * 这个后端给的时间,是要结合时区的。唯有时间戳不可破。
     * 为了应对这种情况,前端必须适配。
     * 这是一个工具类,要具备通用性。
     * 这个类,应该提供各种类型转换成long的方法
     * 提供,long转换成各种格式的方法。(当然,时间格式,除了通用的都是模块自己提供)
     * 做法:
     * 1. 子模块,可以自己定义TimeConst。
     * 2. 子模块先将后端的返回字段,转换成long的时间戳
     * 2. 根据 子模块自定义的格式,转换成需要的格式。
     * <p>
     * 这个类包括:
     * 1、getTime从String、Date、Time获取时间戳
     * 2、从long时间戳,转化为各种格式
     * 3、String转Date
     * 4、String转Calendar
     * 5、或者你会需要扩展些功能。我建议将公共的部分塞到public里头去,必须做差。
    

    这份描述表达了我编写这个代码时的思考。
    这段文字写出来,这个类就算是实现了一半了;具体的编码实现就是具体的思考。

    思考永远是最重要的

    你的考量会给后面的同事带来很多便捷,节约大量的时间。


    工具类的初始化
        protected TimeUtils() {
            throw new UnsupportedOperationException("u can't instantiate me...");
        }
    
    getTime从String、Date、Time获取时间戳
        /**
         * Formatted time string to the milliseconds.
         *
         * @param time       The formatted time string.
         * @param timeFormat The format.
         * @return the milliseconds
         */
        public static long getTime(final String time, @NonNull final String timeFormat) {
            return getTime(time, new SimpleDateFormat(timeFormat));
        }
    
        /**
         * Formatted time string to the milliseconds.
         *
         * @param time   The formatted time string.
         * @param format The format.
         * @return the milliseconds
         */
        public static long getTime(final String time, @NonNull final DateFormat format) {
            try {
                return format.parse(time).getTime();
            } catch (ParseException e) {
                e.printStackTrace();
            }
            return -1;
        }
    
        /**
         * 从Date转成时间戳
         *
         * @param date
         * @return
         */
        public static long getTime(@NonNull final Date date) {
            return date.getTime();
        }
    
        /**
         * 从Date转成时间戳
         *
         * @param date
         * @return
         */
        public static long getTime(@NonNull final Calendar date) {
            return getTime(date.getTime());
        }
        
        /**
         * 从Date转成时间戳
         *
         * @param date
         * @return
         */
        public static long getTime(@NonNull final Calendar date) {
            return getTime(date.getTime());
        }
    
    从long时间戳,转化为各种格式
    /**
         * Milliseconds to the formatted time string.
         *
         * @param millis     The milliseconds.
         * @param timeFormat The format.
         * @return the formatted time string
         */
        public static String millis2String(final long millis, @NonNull final String timeFormat) {
            return millis2String(millis, new SimpleDateFormat(timeFormat));
        }
    
        /**
         * UTC time to format
         *
         * @param utcTime
         * @param format  yyyy-MM-dd HH:mm:ss
         * @return
         */
        public static String formatTo(String utcTime, String format) {
            if (utcTime == null) {
                return "";
            }
            DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss.SSSZ");
            Date result;
            try {
                result = df.parse(utcTime);
                SimpleDateFormat sdf = new SimpleDateFormat(format);
                sdf.setTimeZone(TimeZone.getTimeZone("GMT"));
                return sdf.format(result);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            return utcTime;
        }
    
        /**
         * Milliseconds to the formatted time string.
         *
         * @param millis The milliseconds.
         * @param format The format.
         * @return the formatted time string
         */
        public static String millis2String(final long millis, @NonNull final DateFormat format) {
            return format.format(new Date(millis));
        }
    
    String转Date
    
        /**
         * Formatted time string to the milliseconds.
         *
         * @param time   The formatted time string.
         * @param timeFormat The format.
         * @return the milliseconds
         */
        public static long string2Millis(final String time, @NonNull final String timeFormat) {
            return string2Millis(time, new SimpleDateFormat(timeFormat));
        }
    
        /**
         * Formatted time string to the milliseconds.
         *
         * @param time   The formatted time string.
         * @param format The format.
         * @return the milliseconds
         */
        public static long string2Millis(final String time, @NonNull final DateFormat format) {
            try {
                return format.parse(time).getTime();
            } catch (ParseException e) {
                e.printStackTrace();
            }
            return -1;
        }
    
    String转Calendar
    
        /**
         * Formatted time string to the date.
         *
         * @param time       The formatted time string.
         * @param timeFormat The format.
         * @return the date
         */
        public static Date string2Date(final String time, @NonNull final String timeFormat) {
            return string2Date(time, new SimpleDateFormat(timeFormat));
        }
    
        /**
         * Formatted time string to the date.
         *
         * @param time   The formatted time string.
         * @param format The format.
         * @return the date
         */
        public static Date string2Date(final String time, @NonNull final DateFormat format) {
            try {
                return format.parse(time);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            return null;
        }
    
    
        /**
         * Formatted time string to the date.
         *
         * @param time       The formatted time string.
         * @param timeFormat The format.
         * @return the date
         */
        public static Calendar string2Calendar(final String time, @NonNull final String timeFormat) {
            return string2Calendar(time, new SimpleDateFormat(timeFormat));
        }
    
        /**
         * Formatted time string to the date.
         *
         * @param time   The formatted time string.
         * @param format The format.
         * @return the date
         */
        public static Calendar string2Calendar(final String time, @NonNull final DateFormat format) {
            try {
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(format.parse(time));
                return calendar;
            } catch (ParseException e) {
                e.printStackTrace();
            }
            return null;
        }
    
    时间做差
    
    
        /**
         * 获取合适型两个时间差
         *
         * @param millis0   毫秒时间戳1
         * @param millis1   毫秒时间戳2
         * @param precision 精度
         *                  <p>precision = 0,返回null</p>
         *                  <p>precision = 1,返回天</p>
         *                  <p>precision = 2,返回天和小时</p>
         *                  <p>precision = 3,返回天、小时和分钟</p>
         *                  <p>precision = 4,返回天、小时、分钟和秒</p>
         *                  <p>precision &gt;= 5,返回天、小时、分钟、秒和毫秒</p>
         * @return 合适型两个时间差
         */
        public static int getFitTimeSpanV2(long millis0, long millis1, int precision) {
            return millis2FitTimeSpanV2(Math.abs(millis0 - millis1), precision);
        }
    
        @SuppressLint("DefaultLocale")
        public static int millis2FitTimeSpanV2(long millis, int precision) {
            if (millis <= 0) {
                return 0;
            }
            int[] unitLen = {86400000, 3600000, 60000, 1000, 1};
            long mode = 0;
            precision = Math.min(precision, 5);
            mode = millis / unitLen[precision];
            return (int) mode;
        }
    

    小结

    比起迅速开始编码工作,思考构思更重要。
    思考不充分,迟早会给你带来返工。

    程序员这份工作,总算很大的瓶颈。我时长想,这家伙跟我差不多,却为什么工资比我高辣么多。

    是思维决定了你的层次。凡事多思考。方有沉淀。

    这就是好多人常说的。10年经验,是10个1年经验,还是1个10年经验。
    有成长方有沉淀。

    没有经过思考的代码,是没有灵气的代码。

    大道至简,Linux的开创者,当初也只是因为一个想法。

    展开全文
  • Java Utils工具类大全

    千次阅读 2019-01-21 23:06:10
    #Java Utils 封装了一些常用Java操作方法,便于重复开发利用. 另外希望身为Java牛牛的你们一起测试和完善,欢迎入群263641914 一起封装和完成常用的Java代码。 节约撸码时间以方便有更多的时间去把妹子~ ...
  • 工具类

    2019-09-08 15:18:27
    工具类 String类 String类可以存储字符序列,它不是基本数据类型,而是引用类型。 创建字符串对象的两种方式: package day16; public class Day1604 { public static void main(String[] args) { //String是引用...
  • 常用工具类(一)

    千次阅读 2018-04-26 21:04:21
    包装: 在Java中,每个基本类型在java.lang包中,都有相应的包装,把基本数据转换为对象,其中包装Integer是Number的直接子类。 基本数据类型: byte short int long float double char boolean 包装: ...
  • 几个常用的工具类,照片,文件,时间,网络工具
  • 常用工具类

    2020-04-27 11:37:58
    /** * 从url获取ip、port和地址信息 * 例如 入参:rtmp://10.0.0.1:6666/live/a174658f3ba9483e9c597fb7c4d2bd2d_sub * 出参:[10.0.0.1, 6666, /live/a174658f3ba9483e9c597fb7c4d2bd2d_sub] ...
  • 一、问题描述及试用场景: 在项目开发中,常常需要校验入参参数的合法性,是否...这里建议使用hibernate的工具包,稍加封装即可实现 三、样例源码: package org.egg.utils; import org.egg.enums.CommonErr
  • 按照触电防护方式,电气设备分为以下4: 0。这种设备仅仅依靠基本绝缘来防止触电。0设备外壳上和内部的不带电导体上都没有接地端子。 Ⅰ。这种设备除依靠基本绝缘外,还有一个附加的安全措施。Ⅰ设备外壳...
  • JAVA中MD5加密(MD5工具类

    万次阅读 2018-04-13 10:06:02
    工具类如下:import java.security.MessageDigest; /** * @Author:Starry * @Description: * @Date:Created in 9:46 2018/4/13 * Modified By: */ public class MD5Utils { private static final String ...
  • 人工智能,零基础入门!... 我们知道,在spring项目中,只有都是容器中的bean才可以互取【依赖注入】,比如说userController和userService都是容器中的实例bean,所以在userController中可以注入userService。...
  • 工具类不应该有公有的构造函数

    千次阅读 2016-05-11 22:26:43
    工具类不应该有公有的构造函数工具类是一系列静态成员或方法的集合,意味着它不可以被实例化,即使是抽象的工具类,它可以被继承,但也不可以有公有的构造函数。Java类如果没有声明构造函数,则会默认有一个公有的...
  • java 实体对象与Map之间的转换工具类

    万次阅读 2018-09-25 10:40:53
    import java.lang.reflect.Field; import java.util.HashMap; import java.util.Map;... * 实体转Map * @param object * @return */ public static Map&lt;String, Object&gt...
  • Spring获取ApplicationContext的工具类

    万次阅读 2017-02-24 20:43:32
    在项目中,经常遇到这样的问题:有些需要使用new来创建对象,但是中需要使用spring容器中定义的bean,此时无法通过spring的自动注入来注入我们需要使用的bean。所以需要手动的从spring容器中获取bean。要获取...
  • 工具类需要依赖谷歌的java开发工具包guava,这个工具包里面具备了很多功能具体的可以参考并发编程网关于guava的系列教程[ 快捷入口 ]:CaseFomat提供的枚举常量的说明 SN 枚举常量 说明 1 LOWER_HYPHEN 连...
  • BeanUtils工具类常用方法

    万次阅读 2018-06-21 09:57:13
    BeanUtils 是 Apache commons组件的成员之一,主要用于简化JavaBean封装数据的操作...使用第三方工具,需要导入jar包:BeanUtils工具常用工具类有两个:BeanUtils、ConvertUtils。BeanUtils用于封装数据,ConvertUti...
  • Java8中的LocalDateTime工具类

    万次阅读 多人点赞 2020-09-01 13:11:54
    网上搜索了半天都没有找到Java8的LocalDateTime的工具类,只好自己写了一个,常用功能基本都有。还在用Date的Java同道该换换了。 个人项目地址:https://github.com/KingBoyWorld/common.git,Common模块中有很多...
1 2 3 4 5 ... 20
收藏数 2,029,561
精华内容 811,824
关键字:

工具类