精华内容
下载资源
问答
  • Json寻址工具类

    万次阅读 2020-04-15 17:05:52
    抽空写了个根据地址寻址json内容中的某个值的工具类。 说明: 1.工具类使用google Gson,有兴趣的可以使用其他json序列号工具改造。大概流程都一样 private static final String JSON_ARRAY_FORMAT...

    在项目使用中,经常使用json的反序列化获取某个值,如果某个值的路径比较深,除了编写工作量变大和风险扩大外,还有就是代码不够整洁。抽空写了个根据地址寻址json内容中的某个值的工具类。

    说明:

    1.工具类使用google Gson,有兴趣的可以使用其他json序列号工具改造。大概流程都一样

         private static final String JSON_ARRAY_FORMAT = "(.)*(\\[(\\d)+])$";
    
     /**
         * 根据路径获取json对象的值
         * 约定:
         * 路径格式:下层用点代表 数组用[index]代表
         * 举例:
         * a.b[1].c
         * [0].a.c
         * a[1].b
         * a.
         * [0]
         *
         * @param json
         * @param path
         * @return Object 如果获取不到 返回null
         */
        public static <T> T getObjectGson4Path(String json, String path, Class<T> tClass) {
            Gson gson = new Gson();
            JsonElement value4Path = getValue4Path(json, path);
            if (null == value4Path) {
                LOGGER.error("can't find value by path {} ", path);
                return null;
            }
            try {
                return gson.fromJson(value4Path, tClass);
            } catch (JsonSyntaxException e) {
                LOGGER.error("can't find format Type is {} value", tClass.getName());
                return null;
            }
        }
    
        /**
         * 根据路径获取json对象的值
         * 约定:
         * 路径格式:下层用点代表 数组用[index]代表
         * 举例:
         * a.b[1].c
         * [0].a.c
         * a[1].b
         * a.
         * [0]
         *
         * @param json
         * @param path
         * @return List 如果获取不到 返回null
         */
        public static <T> List<T> getListGson4Path(String json, String path, Class<T> tClass) {
            Gson gson = new Gson();
            JsonElement value4Path = getValue4Path(json, path);
            if (null == value4Path) {
                LOGGER.error("can't find value by path {} ", path);
                return null;
            }
            if (!value4Path.isJsonArray()) {
                throw new IllegalArgumentException("parse format not match");
            }
            JsonArray asJsonArray = value4Path.getAsJsonArray();
            ArrayList<T> objects = new ArrayList<>(asJsonArray.size());
            try {
                for (JsonElement jsonElement : asJsonArray) {
                    objects.add(gson.fromJson(value4Path, tClass));
                }
            } catch (JsonSyntaxException e) {
                LOGGER.error("can't find format Type is {} value", tClass.getName());
                return null;
            }
            return objects;
        }
    
    
        private static JsonElement getValue4Path(String content, String path) {
            LOGGER.info("content={},path={}", content, path);
            if (StringUtils.isBlank(path)) {
                LOGGER.warn("path is blank");
                return null;
            }
            if (!isJSONStr(content)) {
                LOGGER.warn("content format not json");
                return null;
            }
            JsonParser parser = new JsonParser();
            JsonElement parse = parser.parse(content);
            String[] split = path.split("\\.");
            StringBuilder stringBuilder = new StringBuilder();
            for (String s : split) {
                try {
                    parse = parseJson(parse, s, stringBuilder);
                } catch (Exception e) {
                    LOGGER.warn("can't find value ,this path is {}", path);
                    return null;
                }
            }
            return parse;
        }
    
        private static JsonElement parseJson(JsonElement jsonElement, String childPath, StringBuilder sb) {
            if (jsonElement.isJsonNull()) {
                return null;
            }
            if (StringUtils.isBlank(childPath)) {
                return jsonElement;
            }
            sb.append(".").append(childPath);
            Matcher matcher = Pattern.compile(JSON_ARRAY_FORMAT).matcher(childPath);
            if (matcher.find()) {
                String group = matcher.group(1);
                if (null == group) {
                    group = matcher.group(0);
                }
                String s = group.replaceAll("\\[", "\\\\[");
                String[] split1 = childPath.split(s);
                String key = null;
                if (null == split1 || split1.length == 0) {
                    key = "";
                } else {
                    key = split1[0];
                }
                String index = group.substring(1, group.length() - 1);
                if (StringUtils.isBlank(key)) {
                    if (!jsonElement.isJsonArray()) {
                        LOGGER.warn("can't find value by this childPath,path={}", sb.substring(1));
                        return null;
                    }
                    JsonArray asJsonArray = jsonElement.getAsJsonArray();
                    JsonElement res = asJsonArray.get(Integer.valueOf(index));
                    return res;
                } else {
                    JsonObject asJsonObject = jsonElement.getAsJsonObject();
                    JsonElement res = asJsonObject.get(key);
                    return res;
                }
            } else {
                JsonObject asJsonObject = jsonElement.getAsJsonObject();
                JsonElement res = asJsonObject.get(childPath);
                return res;
            }
    
        }
    
        public static void main(String[] args) {
            String str12 = "{\"additionJson\":{\"needPush\":true},\"id\":123456,\"date\":\"2013-4-13 12: 36: 54\"}";
            Boolean objectGson4Path12 = getObjectGson4Path(str12, "additionJson.needPush", Boolean.class);
            System.out.println(objectGson4Path12);
        }
    

     

    展开全文
  • /** * @description:驼峰与下划线之间互转工具类 * @author:boob * @since:2020/2/9 */ public class CamelCaseUtil { private static final char SEPARATOR = '_'; public CamelC...
    package com.bood.common.utils;
    
    /**
     * <p>
     * 驼峰与下划线之间互转工具类
     * </p>
     * 
     * @author:bood
     * @date:2020/10/16
     */
    public class CamelCaseUtil {
    
        private static final char SEPARATOR = '_';
    
        private CamelCaseUtil() {
        }
    
        /**
         * <p>
         * 转下划线
         * </p>
         *
         * @param s: 
         * @return:java.lang.String
         * @author:bood
         * @date:2020/10/16
         */
        public static String toUnderlineName(String s) {
            if (s == null) {
                return null;
            }
    
            StringBuilder sb = new StringBuilder();
            boolean upperCase = false;
            for (int i = 0; i < s.length(); i++) {
                char c = s.charAt(i);
                boolean nextUpperCase = true;
    
                if (i < (s.length() - 1)) {
                    nextUpperCase = Character.isUpperCase(s.charAt(i + 1));
                }
    
                if ((i >= 0) && Character.isUpperCase(c)) {
                    if (!upperCase || !nextUpperCase) {
                        if (i > 0) sb.append(SEPARATOR);
                    }
                    upperCase = true;
                } else {
                    upperCase = false;
                }
    
                sb.append(Character.toLowerCase(c));
            }
            return sb.toString();
        }
    
        /**
         * <p>
         * 转驼峰
         * </p>
         *
         * @param s: 
         * @return:java.lang.String
         * @author:bood
         * @date:2020/10/16
         */
        public static String toCamelCase(String s) {
            if (s == null) {
                return null;
            }
            s = s.toLowerCase();
            StringBuilder sb = new StringBuilder(s.length());
            boolean upperCase = false;
            for (int i = 0; i < s.length(); i++) {
                char c = s.charAt(i);
                if (c == SEPARATOR) {
                    upperCase = true;
                } else if (upperCase) {
                    sb.append(Character.toUpperCase(c));
                    upperCase = false;
                } else {
                    sb.append(c);
                }
            }
            return sb.toString();
        }
    
        /**
         * <p>
         * 转大写驼峰
         * </p>
         *
         * @param s: 
         * @return:java.lang.String
         * @author:bood
         * @date:2020/10/16
         */
        public static String toCapitalizeCamelCase(String s) {
            if (s == null) {
                return null;
            }
            s = toCamelCase(s);
            return s.substring(0, 1).toUpperCase() + s.substring(1);
        }
    
    }
    

    在这里插入图片描述
    混〔IT〕的小学生 热爱编程,喜欢挑战新事物!

    展开全文
  • Java.Utils:客户端工具类

    万次阅读 2019-12-12 15:21:16
    基于Spring Boot框架 package ... import org.springframework.web.context.request.RequestContextHolder;...import org.springframework.web.context.request.ServletRequestAttributes;...impo...

    基于 Spring Boot 框架

    Maven

    <!-- hutool -->
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>5.5.1</version>
    </dependency>
    
    package com.bood.common.utils;
    
    import cn.hutool.core.convert.Convert;
    import com.bood.shimmer.common.utils.StringUtils;
    import org.springframework.web.context.request.RequestAttributes;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;
    import java.io.IOException;
    
    /**
     * <p>
     * 客户端工具类
     * </p>
     *
     * @author:bood
     * @date:2020/9/23
     */
    public class ServletUtils {
    
        public ServletUtils() {
        }
    
        /**
         * <p>
         * 获取当前线程 request 对象
         * </p>
         *
         * @return:javax.servlet.http.HttpServletRequest
         * @author:bood
         * @date:2020/9/23
         */
        public static HttpServletRequest getRequest() {
            return new ServletUtils().getCurrentThreadRequest();
        }
    
        /**
         * <p>
         * 获取当前线程 response 对象
         * </p>
         *
         * @return:javax.servlet.http.HttpServletResponse
         * @author:bood
         * @date:2020/9/23
         */
        public static HttpServletResponse getResponse() {
            return new ServletUtils().getCurrentThreadResponse();
        }
    
        /**
         * <p>
         * 获取当前线程 session 对象
         * </p>
         *
         * @return:javax.servlet.http.HttpSession
         * @author:bood
         * @date:2020/9/23
         */
        public static HttpSession getSession() {
            return new ServletUtils().getCurrentThreadSession();
        }
    
        /**
         * 获取String参数
         */
        public static String getParameter(String name) {
            return getRequest().getParameter(name);
        }
    
        /**
         * 获取String参数
         */
        public static String getParameter(String name, String defaultValue) {
            return Convert.toStr(getRequest().getParameter(name), defaultValue);
        }
    
        /**
         * 获取Integer参数
         */
        public static Integer getParameterToInt(String name) {
            return Convert.toInt(getRequest().getParameter(name));
        }
    
        /**
         * 获取Integer参数
         */
        public static Integer getParameterToInt(String name, Integer defaultValue) {
            return Convert.toInt(getRequest().getParameter(name), defaultValue);
        }
    
        /**
         * <p>
         * 将字符串渲染到客户端
         * </p>
         *
         * @param response: 渲染对象
         * @param string: 待渲染的字符串
         * @return:java.lang.String
         * @author:bood
         * @date:2020/12/2
         */
        public static String renderString(HttpServletResponse response, String string) {
            try {
                response.setStatus(200);
                response.setContentType("application/json");
                response.setCharacterEncoding("utf-8");
                response.getWriter().print(string);
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * <p>
         * 是否是 Ajax 异步请求
         * </p>
         *
         * @param request:
         * @return:boolean
         * @author:bood
         * @date:2020/12/2
         */
        public static boolean isAjaxRequest(HttpServletRequest request) {
            String accept = request.getHeader("accept");
            if (accept != null && accept.indexOf("application/json") != -1) {
                return true;
            }
    
            String xRequestedWith = request.getHeader("X-Requested-With");
            if (xRequestedWith != null && xRequestedWith.indexOf("XMLHttpRequest") != -1) {
                return true;
            }
    
            String uri = request.getRequestURI();
            if (StringUtils.inStringIgnoreCase(uri, ".json", ".xml")) {
                return true;
            }
    
            String ajax = request.getParameter("__ajax");
            if (StringUtils.inStringIgnoreCase(ajax, "json", "xml")) {
                return true;
            }
            return false;
        }
    
        private HttpServletRequest getCurrentThreadRequest() {
            return getRequestAttributes().getRequest();
        }
    
        private HttpServletResponse getCurrentThreadResponse() {
            return getRequestAttributes().getResponse();
        }
    
        private HttpSession getCurrentThreadSession() {
            return getRequestAttributes().getRequest().getSession();
        }
    
        private static ServletRequestAttributes getRequestAttributes() {
            RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
            return (ServletRequestAttributes) attributes;
        }
    
    }
    

    混〔IT〕的小学生 热爱编程,喜欢挑战新事物! 撩撩博主 😃

    展开全文
  • Java.Utils:Date 时间工具类

    万次阅读 2020-02-13 18:30:06
    package com.boob.common.utils; import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Calendar;...import java.util.Date;... * @description:...
    package com.bood.common.utils;
    
    import java.text.DateFormat;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Calendar;
    import java.util.Date;
    
    /**
     * <p>
     * Date 时间工具类
     * </p>
     *
     * @author:bood
     * @date:2020/10/16
     */
    public class DateUtils {
    
        private final static SimpleDateFormat sdfYear = new SimpleDateFormat("yyyy");
    
        private final static SimpleDateFormat sdfDay = new SimpleDateFormat("yyyy-MM-dd");
    
        private final static SimpleDateFormat sdfDays = new SimpleDateFormat("yyyyMMdd");
    
        private final static SimpleDateFormat sdfTime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    
        private final static SimpleDateFormat sdfTimeString = new SimpleDateFormat("yyyyMMddHHmmss");
    
        public DateUtils() {
        }
        
        /**
         * 获取 YYYY 格式
         *
         * @return yyyy
         */
        public static String getYear() {
            return sdfYear.format(new Date());
        }
    
        /**
         * 获取 YYYY-MM-DD 格式
         *
         * @return YYYY-MM-DD
         */
        public static String getDay() {
            return sdfDay.format(new Date());
        }
    
        /**
         * 获取 YYYYMMDD 格式
         *
         * @return YYYYMMDD
         */
        public static String getDays() {
            return sdfDays.format(new Date());
        }
    
        /**
         * 获取 YYYY-MM-DD HH:mm:ss 格式
         *
         * @return YYYY-MM-DD HH:mm:ss
         */
        public static String getTime() {
            return sdfTime.format(new Date());
        }
    
        /**
         * 获取 YYYYMMDDHHmmss 格式
         *
         * @return YYYYMMDDHHmmss
         */
        public static String getTimeString() {
            return sdfTimeString.format(new Date());
        }
    
        /**
         * <p>
         * 日期比较,如果s > = e 返回 true 否则返回 false
         * </p>
         *
         * @param s:
         * @param e:
         * @return:boolean
         * @author:bood
         * @date:2020/10/16
         */
        public static boolean compareDate(String s, String e) {
            if (fomatDate(s) == null || fomatDate(e) == null) {
                return false;
            }
            return fomatDate(s).getTime() >= fomatDate(e).getTime();
        }
    
        /**
         * <p>
         * 格式化日期
         * </p>
         *
         * @param date:
         * @return:java.util.Date
         * @author:bood
         * @date:2020/10/16
         */
        public static Date fomatDate(String date) {
            DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd");
            try {
                return fmt.parse(date);
            } catch (ParseException e) {
                e.printStackTrace();
                return null;
            }
        }
    
        /**
         * <p>
         * 校验日期是否合法
         * </p>
         *
         * @param s:
         * @return:boolean
         * @author:bood
         * @date:2020/10/16
         */
        public static boolean isValidDate(String s) {
            DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd");
            try {
                fmt.parse(s);
                return true;
            } catch (Exception e) {
                // 如果 throw java.text.ParseException 或者 NullPointerException,就说明格式不对
                return false;
            }
        }
    
        /**
         * <p>
         * 时间相减得到年数
         * </p>
         *
         * @param startTime:
         * @param endTime:
         * @return:int
         * @author:bood
         * @date:2020/10/16
         */
        public static int getDiffYear(String startTime, String endTime) {
            DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd");
            try {
                int years = (int) (((fmt.parse(endTime).getTime() - fmt.parse(startTime).getTime()) / (1000 * 60 * 60 * 24)) / 365);
                return years;
            } catch (Exception e) {
                // 如果 throw java.text.ParseException 或者 NullPointerException,就说明格式不对
                return 0;
            }
        }
    
        /**
         * <p>
         * 时间相减得到天数
         * </p>
         *
         * @param beginDateStr:
         * @param endDateStr:
         * @return:long
         * @author:bood
         * @date:2020/10/16
         */
        public static long getDaySub(String beginDateStr, String endDateStr) {
            long day = 0;
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            Date beginDate = null;
            Date endDate = null;
    
            try {
                beginDate = format.parse(beginDateStr);
                endDate = format.parse(endDateStr);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            day = (endDate.getTime() - beginDate.getTime()) / (24 * 60 * 60 * 1000);
            // System.out.println("相隔的天数="+day);
            return day;
        }
    
        /**
         * <p>
         * 得到 n 天之后的日期
         * </p>
         *
         * @param days:
         * @return:java.lang.String
         * @author:bood
         * @date:2020/10/16
         */
        public static String getAfterDayDate(String days) {
            int daysInt = Integer.parseInt(days);
            // java.util包
            Calendar canlendar = Calendar.getInstance();
            // 日期减 如果不够减会将月变动
            canlendar.add(Calendar.DATE, daysInt);
            Date date = canlendar.getTime();
    
            SimpleDateFormat sdfd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dateStr = sdfd.format(date);
    
            return dateStr;
        }
    
        /**
         * 得到n天之后是周几
         *
         * @param days
         * @return
         */
        public static String getAfterDayWeek(String days) {
            int daysInt = Integer.parseInt(days);
            // java.util包
            Calendar canlendar = Calendar.getInstance();
            // 日期相减,如果不够减会将月变动
            canlendar.add(Calendar.DATE, daysInt);
            Date date = canlendar.getTime();
    
            SimpleDateFormat sdf = new SimpleDateFormat("E");
            String dateStr = sdf.format(date);
    
            return dateStr;
        }
    
        /**
         * <p>
         * 获得当前时间之前或之后几个月的日期
         * </p>
         *
         * @param amount: 值可正可负,负<==>before 正<==>after
         * @return:java.lang.String yyyy-MM-dd HH:mm:ss
         * @author:bood
         * @date:2020/10/16
         */
        public static String getAfterMonthDate(Integer amount) {
            //获取当前时间
            Date nowDate = new Date();
            //获取日历类实例
            Calendar cl = Calendar.getInstance();
            //设置当前时间
            cl.setTime(nowDate);
            cl.add(Calendar.MONTH, amount);
            return sdfTime.format(cl.getTime());
        }
    
        /**
         * <p>
         * 获得当前时间之前或之后几年的日期
         * </p>
         *
         * @param amount: 值可正可负,负<==>before 正<==>after
         * @return:java.lang.String yyyy-MM-dd HH:mm:ss
         * @author:bood
         * @date:2020/10/16
         */
        public static String getAfterYearDate(Integer amount) {
            //获取当前时间
            Date nowDate = new Date();
            //获取日历类实例
            Calendar cl = Calendar.getInstance();
            //设置当前时间
            cl.setTime(nowDate);
            cl.add(Calendar.YEAR, amount);
            return sdfTime.format(cl.getTime());
        }
    
    }
    

    混〔IT〕的小学生 热爱编程,喜欢挑战新事物! 撩撩博主 😃

    展开全文
  • HttpClient工具类

    万次阅读 多人点赞 2019-09-25 22:23:57
    最近在工作中需要在后台调用短信接口,经过研究决定使用HttpClient,自己封装了一个HttpClient工具类,简单轻松的实现get,post,put和delete请求,希望分享给大家。 1. 什么是HttpClient HTTP 协议可能是现在 ...
  • CollectionUtils工具类

    万次阅读 2020-09-01 15:40:49
    这篇讲的CollectionUtils工具类是在apache下的 相关的maven <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-collections4</artifactId> <version&...
  • 自动生成代码工具 模板工具类

    万次阅读 2019-09-20 15:59:31
    自动生成代码工具 模板工具类 import java.io.BufferedWriter; import java.io.FileOutputStream; import java.io.OutputStreamWriter; import java.util.ArrayList; i...
  • 自动生成代码工具 数据库工具类

    万次阅读 2019-09-20 15:59:31
    自动生成代码工具 数据库工具类 import java.sql.Connection; import java.sql.DatabaseMetaData; import java.sql.DriverManager; import java.sql.PreparedStatement; i...
  • Java.Utils:Alibaba - JSON 工具类

    万次阅读 2019-12-12 15:10:10
    1.首先引入maven依赖 <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.60</version> ...2.工...
  • 自动生成代码工具 文件工具类

    万次阅读 2019-09-20 15:59:31
    自动生成代码工具 文件工具类 import java.io.File; import java.util.List; import java.util.Map; import org.apache.commons.lang.StringUtils; import org.slf4j.Lo...
  • Android快速开发系列 10个常用工具类

    万次阅读 多人点赞 2014-09-05 09:27:33
    转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/38965311,本文出自【张鸿洋的博客】打开大家手上的项目,基本都会有一大批的辅助类,今天特此整理出10个基本每个项目中都会使用的工具类,用于...
  • Java8中的LocalDateTime工具类

    万次阅读 多人点赞 2017-07-22 22:57:14
    网上搜索了半天都没有找到Java8的LocalDateTime的工具类,只好自己写了一个,常用功能基本都有。还在用Date的Java同道该换换了。 个人项目地址:https://github.com/KingBoyWorld/common.git,Common模块中有很多...
  • Java 8 时间操作工具类有需要的拿走

    万次阅读 2020-08-07 20:10:18
    时间转换工具类 项目中是经常需要使用,废话不多说,直接上代码 package com.study; import lombok.extern.slf4j.Slf4j; import java.time.*; import java.time.format.DateTimeFormatter; import java.time....
  • 自动生成代码工具 字符串工具类

    万次阅读 2019-09-20 15:59:31
    自动生成代码工具 字符串工具类 import org.apache.commons.lang.StringUtils; import com.ijwt.exception.JavaTypeException; import com.ijwt.exception.MybatisTypeException; /** * @...
  • 自动生成代码工具 配置文件工具类

    万次阅读 2019-09-20 15:59:31
    自动生成代码工具 配置文件工具类 import java.io.IOException; import java.io.InputStream; import java.util.ArrayList; import java.util.List; import org.dom4j.Do...
  • 很多时候,我们采用java来开发相关应用软件的时候,需要自己开发一些工具类并把它封装在utils工具类中,然后在需要使用的地方直接“类.方法”直接调用!本文将介绍两个比较常用的工具类,分别是日期工具类DateUtils...
  • RestTemplateUtils工具类

    千次阅读 2019-06-10 09:54:55
    RestTemplateUtils 工具类 最强RestTemplateUtils 可绕过https请求,带异常处理,容错机制,以及设置链接时间.设置读写时间。 工具类 import com.alibaba.fastjson.JSONObject; import org.springframework....
  • 流量转换工具类需要的工具类

    千次阅读 2020-03-26 11:07:07
    用于double类型数据进行运算: ... import java.math.BigDecimal;... * 由于Java的简单类型不能够精确的对浮点数进行运算,这个工具类提供精 * 确的浮点数运算,包括加减乘除和四舍五入。 */ public ...
  • 史上最全Java8日期时间工具类

    万次阅读 多人点赞 2020-12-13 14:52:18
    这是我总结的Java8日期工具类,应该是比较全面的,满足日常开发绝大部分需求,分享给大家,有错误之处,还望大神指教。 /** * Java8日期时间工具类 * * @author JourWon * @date 2020/12/13 */ public class ...
  • java工具类(六)根据经纬度计算距离

    万次阅读 2015-08-14 10:21:42
    在项目开发过程中,需要根据两地经纬度坐标计算两地间距离,所用的工具类如下: Demo1: public static double getDistatce(double lat1, double lat2, double lon1, double lon2) { double R = 6371; double ...
  • java正则表达式表单验证类工具类(验证邮箱、手机号码、qq号码等) 这篇文章主要介绍了java使用正则表达式进行表单验证工具类,可以验证邮箱、手机号码、qq号码等方法,需要的朋友可以参考下。 java使用正则表达式进行...
  • 常用的工具类ApplicationContextHolder

    千次阅读 2018-08-23 15:50:07
    工具类
  • 整理收集的一些常用java工具类

    万次阅读 多人点赞 2017-08-20 19:42:14
    整理收集的一些常用java工具类
  • ResourceUtils工具类

    万次阅读 2018-07-12 11:50:35
    File jsonfile = ResourceUtils.getFile("classpath:city.json"); // 通过Java自带的读取工具对文件目录下的文件进行读取 File jsonfile = ResourceUtils.get...Spring 提供了一个 ResourceUtils 工具类,它支持...
  • MultipartFileToFile工具类

    千次阅读 2020-03-31 12:40:15
    MultipartFileToFile工具类: bufferReader读取文件都会把文件下载到项目目录中,要注意删除。以下实现MultipartFile 转 File功能以及项目中文件删除。 package com.reachauto.vsp.portal.util; import org....
  • 很多时候都需要使用到缓存工具-(不过目前有很多专业的缓存工具,写这个东西仅仅是为了梳理缓存的逻辑) 首先定义一个存储工具使用的ConcurrentHashMap(支持并发) private volatile Map<String, CacheObject&...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 229,292
精华内容 91,716
关键字:

工具类