精华内容
下载资源
问答
  • 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: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〕的小学生 热爱编程,喜欢挑战新事物! 撩撩博主 😃

    展开全文
  • Java.Utils:图像处理工具类

    万次阅读 2020-02-13 18:36:23
    package ... import javax.imageio.ImageIO; import javax.imageio.stream.ImageOutputStream; import java.awt.*; import java.awt.geom.AffineTransform;...import java.awt.image.AffineTransf...
    package com.bood.common.utils;
    
    import javax.imageio.ImageIO;
    import javax.imageio.stream.ImageOutputStream;
    import java.awt.*;
    import java.awt.geom.AffineTransform;
    import java.awt.image.AffineTransformOp;
    import java.awt.image.BufferedImage;
    import java.io.*;
    import java.text.DecimalFormat;
    
    /**
     * <p>
     * 图像处理工具类(本类完全可以使用,但是更加推荐ImageMagick +Jmagick </br>
     * 采用C++实现的一个类库,提供了Java的Api,非常强大和高效)</br>
     * 而且要为JVM分配较大的堆内存,否则内存溢出 </br>
     * </p>
     *
     * @author:bood
     * @date:2020/10/16
     */
    public class ImageUtils {
    
        public ImageUtils() {
        }
    
        /**
         * 缩放图片
         *
         * @param src   源文件
         * @param dest  目标文件
         * @param ratio 缩放比例,如 0.1,0.8,1.2,2.4
         * @throws IOException
         */
        public static void zoom(String src, String dest, double ratio) throws IOException {
            // 获取文件扩展名
            String suffix = src.substring(src.lastIndexOf(".") + 1);
            // 读入文件
            BufferedImage bi = ImageIO.read(new File(src));
            // 计算目标文件宽度
            int targetWidth = Integer.parseInt(new DecimalFormat("0").format(bi.getWidth() * ratio));
            // 计算目标文件高度
            int targetHeight = Integer.parseInt(new DecimalFormat("0").format(bi.getHeight() * ratio));
            // 获取BufferedImage读入的图片的一个缩放的版本
            Image image = bi.getScaledInstance(targetWidth, targetHeight, Image.SCALE_DEFAULT);
            // 创建一张空白的缓存图片
            BufferedImage target = new BufferedImage(targetWidth, targetHeight, BufferedImage.TYPE_INT_RGB);
            // 返回一张2D图像
            Graphics g = target.createGraphics();
            // 将BufferedImage读入的图片画到上一步创建的对象上
            g.drawImage(image, 0, 0, null);
            // 释放
            g.dispose();
            // 图像写入文件
            ImageIO.write(target, suffix, new File(dest));
        }
    
        /**
         * 切图
         *
         * @param src    源文件
         * @param dest   目标文件
         * @param startX 起点x坐标
         * @param startY 起点y坐标
         * @param endX   结束点x坐标
         * @param endY   结束点y坐标
         * @throws IOException
         */
        public static void cut(String src, String dest, int startX, int startY, int endX, int endY) throws IOException {
            // 获取文件扩展名
            String suffix = src.substring(src.lastIndexOf(".") + 1);
            // 读入文件
            BufferedImage bi = ImageIO.read(new File(src));
            // 计算宽度
            int width = Math.abs(startX - endX);
            // 计算高度
            int height = Math.abs(startY - endY);
            BufferedImage target = bi.getSubimage(startX, startY, width, height);
            ImageIO.write(target, suffix, new File(dest));
        }
    
        /**
         * 旋转图片
         *
         * @param src     源文件
         * @param dest    目标文件
         * @param degree  旋转角度
         * @param bgcolor 背景色,无背景色为null
         * @throws IOException
         */
        public static void rotate(String src, String dest, int degree, Color bgcolor) throws IOException {
            BufferedImage image = ImageIO.read(new File(src));
            // 原始图象的宽度
            int iw = image.getWidth();
            // 原始图象的高度
            int ih = image.getHeight();
            int w = 0;
            int h = 0;
            int x = 0;
            int y = 0;
            degree = degree % 360;
            if (degree < 0) {
                // 将角度转换到0-360度之间
                degree = 360 + degree;
            }
            // 将角度转为弧度
            double ang = Math.toRadians(degree);
    
            /**
             * 确定旋转后的图象的高度和宽度
             */
            if (degree == 180 || degree == 0 || degree == 360) {
                w = iw;
                h = ih;
            } else if (degree == 90 || degree == 270) {
                w = ih;
                h = iw;
            } else {
                double cosVal = Math.abs(Math.cos(ang));
                double sinVal = Math.abs(Math.sin(ang));
                w = (int) (sinVal * ih) + (int) (cosVal * iw);
                h = (int) (sinVal * iw) + (int) (cosVal * ih);
            }
            // 确定原点坐标
            x = (w / 2) - (iw / 2);
            y = (h / 2) - (ih / 2);
            BufferedImage rotatedImage = new BufferedImage(w, h, image.getType());
            Graphics2D gs = (Graphics2D) rotatedImage.getGraphics();
            if (bgcolor == null) {
                rotatedImage = gs.getDeviceConfiguration().createCompatibleImage(w, h, Transparency.TRANSLUCENT);
            } else {
                gs.setColor(bgcolor);
                // 以给定颜色绘制旋转后图片的背景
                gs.fillRect(0, 0, w, h);
            }
    
            AffineTransform at = new AffineTransform();
            // 旋转图象
            at.rotate(ang, w / 2, h / 2);
            at.translate(x, y);
            AffineTransformOp op = new AffineTransformOp(at,
                    AffineTransformOp.TYPE_BICUBIC);
            op.filter(image, rotatedImage);
            image = rotatedImage;
    
            ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
            ImageOutputStream iamgeOut = ImageIO.createImageOutputStream(byteOut);
    
            ImageIO.write(image, "png", iamgeOut);
            InputStream is = new ByteArrayInputStream(byteOut.toByteArray());
    
            OutputStream os = new FileOutputStream(new File(dest));
    
            byte[] buffer = new byte[1024];
            int length = 0;
            while ((length = is.read(buffer)) > 0) {
                os.write(buffer, 0, length);
            }
            os.close();
            is.close();
            byteOut.close();
        }
    
    }
    

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

    展开全文
  • HttpClient工具类

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

    万次阅读 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...
  • 自动生成代码工具 文件工具类

    万次阅读 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个基本每个项目中都会使用的工具类,用于...
  • CollectionUtils工具类

    万次阅读 2020-09-01 15:40:49
    这篇讲的CollectionUtils工具类是在apache下的 相关的maven <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-collections4</artifactId> <version&...
  • Java8中的LocalDateTime工具类

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

    万次阅读 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 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....
  • 很多时候,我们采用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 ...
  • 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使用正则表达式进行...
  • 史上最全Java8日期时间工具类

    万次阅读 多人点赞 2020-12-13 14:52:18
    这是我总结的Java8日期工具类,应该是比较全面的,满足日常开发绝大部分需求,分享给大家,有错误之处,还望大神指教。 /** * Java8日期时间工具类 * * @author JourWon * @date 2020/12/13 */ public class ...
  • 常用的工具类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....
  • Arrays 工具类

    千次阅读 2017-12-17 11:23:30
    JDK 提供了一个工具类专门用来操作数组的工具类,即 Arrays,该 Arrays 工具类提供了大量的静态方法排序Arrays 工具类中的静态方法 sort() 可以对数组进行排序。Example.java 示例代码:import java.util.*;public ...
  • DBUtils工具类

    千次阅读 2016-12-27 13:39:23
    DBUtils工具类

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 227,834
精华内容 91,133
关键字:

工具类