精华内容
下载资源
问答
  • /** * @description:驼峰与下划线之间互转工具类 * @author:boob * @since:2020/2/9 */ public class CamelCaseUtil { private static final char SEPARATOR = '_'; public CamelC...
    package org.bood.common.utils;
    
    /**
     * <p>
     * 驼峰与下划线之间互转工具类
     * </p>
     * 
     * @author:bood
     * @date:2020/10/16
     */
    public class CamelCaseUtil {
    
        private static final char SEPARATOR = '_';
    
        public 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);
        }
    
    }
    

    在这里插入图片描述

    展开全文
  • 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);
        }
    

     

    展开全文
  • 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....

    时间转换工具类

    项目中是经常需要使用,废话不多说,直接上代码

    package com.study;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.time.*;
    import java.time.format.DateTimeFormatter;
    import java.time.temporal.TemporalAdjusters;
    import java.time.temporal.TemporalUnit;
    import java.util.Date;
    import java.util.List;
    import java.util.Locale;
    import java.util.Objects;
    import java.util.stream.Collector;
    import java.util.stream.Collectors;
    import java.util.stream.Stream;
    
    import static java.time.temporal.ChronoUnit.MILLIS;
    import static org.springframework.util.StringUtils.hasText;
    
    /**
     * @Package: com.study
     * @Description: <时间操作工具>
     * @Author: MILLA
     * @CreateDate: 2018/5/4 16:02
     * @UpdateUser: MILLA
     * @UpdateDate: 2018/5/4 16:02
     * @UpdateRemark: <>
     * @Version: 1.0
     */
    @Slf4j
    public final class DateUtils extends org.apache.commons.lang3.time.DateUtils {
        public static final String YEAR_MONTH_DAY_I = "yyyy/MM/dd";
        public static final String YEAR_MONTH_DAY_M = "yyyy-MM-dd";
        public static final String YEAR_MONTH_DAY_ZH = "yyyy年MM月dd日";
        public static final String MONTH_ZH = "M月";
        public static final String YEAR_MONTH_DAY_HH_MM_SS_I = "yyyy/MM/dd HH:mm:ss";
        public static final String YEAR_MONTH_DAY_HH_MM_SS_M = "yyyy-MM-dd HH:mm:ss";
        public static final String YEAR_MONTH_DAY_HH_MM_SS_NONE = "yyyyMMddHHmmss";
        public static final String YEAR_MONTH_DAY_HH_MM_SS_SSS_NONE = "yyyyMMddHHmmssSSS";
        public static final String YEAR_MONTH_DAY_HH_MM_I = "yyyy/MM/dd HH:mm";
        public static final String YEAR_MONTH_DAY_HH_MM_M = "yyyy-MM-dd HH:mm";
        public static final String YEAR_MONTH_DAY_HH_MM_SS_SSS_I = "yyyy/MM/dd HH:mm:ss.SSS";
        public static final String YEAR_MONTH_DAY_HH_MM_SS_SSS_M = "yyyy-MM-dd HH:mm:ss.SSS";
        private static final String WEB_TIME_FORMAT = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'";
    
    
        //测试可删除
        public static void main(String[] args) {
            System.out.println(previousMonthFirstDay(System.currentTimeMillis()));
            System.out.println(previousMonthLastDay(System.currentTimeMillis()));
    
            Date date = previousMonthFirstDay(1592972481000L);
            String format = format(YEAR_MONTH_DAY_HH_MM_SS_M, date);
            System.out.println(format);
            Date date1 = previousMonthLastDay(1592972481000L);
            String format1 = format(YEAR_MONTH_DAY_HH_MM_SS_M, date1);
            System.out.println(format1);
    
            String s = formatPreviousMonth(1606796481000L, null);
            System.out.println(s);
            System.out.println(formatMonth(1606796481000L, null));
    
        }
    
        public static String formatCurrentDateTime() {
            return formatCurrentDateTime(null);
        }
    
    
        /**
         * 对给定时间进行时间的加减操作
         *
         * @param now         指定时间
         * @param amountToAdd 增加的数量
         * @param unit        增加的单位
         * @return
         */
        public static Date plus(Date now, Long amountToAdd, TemporalUnit unit) {
            LocalDateTime nowDateTime = now.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
            LocalDateTime plus = nowDateTime.plus(amountToAdd, unit);
            Instant instant = plus.atZone(ZoneId.systemDefault()).toInstant();
            return Date.from(instant);
        }
    
        /**
         * 对给定时间进行时间的加减操作
         *
         * @param now         指定时间
         * @param amountToAdd 增加的数量
         * @param unit        增加的单位
         * @return
         */
        public static Date plus(Long now, Long amountToAdd, TemporalUnit unit) {
            return plus(new Date(now), amountToAdd, unit);
        }
    
        /**
         * 格式化当前时间
         *
         * @param pattern 指定格式
         * @return 时间字符串输出
         */
        public static String formatCurrentDateTime(String pattern) {
            LocalDate now = LocalDate.now();
            return format(pattern, now);
        }
    
        /**
         * 获取当前月份第一天
         *
         * @return 日期的字符串格式输出
         */
        public static String formatCurrentMonthFirstDay() {
            return formatCurrentMonthFirstDay(null);
        }
    
        /**
         * 获取当前月份最后一天
         *
         * @return 日期的字符串格式输出
         */
        public static String formatCurrentMonthLastDay() {
            return formatCurrentMonthLastDay(null);
        }
    
        /**
         * 获取前一月第一天
         *
         * @return 日期的字符串格式输出
         */
        public static String formatPreviousMonthFirstDay() {
            return formatPreviousMonthFirstDay(null);
        }
    
        /**
         * 获取前一个月最后一天
         *
         * @return 日期的字符串格式输出
         */
        public static String formatPreviousMonthLastDay() {
            return formatPreviousMonthLastDay(null);
        }
    
        /**
         * 获取前一个月第一天[从凌晨开始]
         *
         * @return 日期的字符串格式输出
         */
        public static Date previousMonthFirstDay() {
            LocalDate today = LocalDate.now();
            //本月的第一天
            LocalDate localDate = LocalDate.of(today.getYear(), today.getMonth().plus(-1), 1);
            ZonedDateTime dateTime = localDate.atStartOfDay(ZoneId.systemDefault());
            return Date.from(dateTime.toInstant());
        }
    
        /**
         * 获取前一个月第一天[从凌晨开始]
         *
         * @param timestamps 指定时间戳
         * @return 日期的字符串格式输出
         */
        public static Date previousMonthFirstDay(long timestamps) {
            Date date = new Date(timestamps);
            LocalDateTime localDateTime = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
            LocalDate now = localDateTime.toLocalDate();
            //本月的第一天
            LocalDate localDate = LocalDate.of(now.getYear(), now.getMonth().plus(-1), 1);
            ZonedDateTime dateTime = localDate.atStartOfDay(ZoneId.systemDefault());
            return Date.from(dateTime.toInstant());
        }
    
        /**
         * 获取前一个月最后一天[下一个凌晨前一秒结束]
         *
         * @return 日期的字符串格式输出
         */
        public static Date previousMonthLastDay() {
            LocalDate today = LocalDate.now();
            //本月的第一天
            LocalDate firstDay = LocalDate.of(today.getYear(), today.getMonth(), 1);
            ZonedDateTime dateTime = firstDay.atStartOfDay(ZoneId.systemDefault());
            Instant plus = dateTime.toInstant().plus(-1, MILLIS);
            return Date.from(plus);
        }
    
        /**
         * 获取前一个月最后一天[下一个凌晨前一秒结束]
         *
         * @param timestamps 指定时间戳
         * @return 日期的字符串格式输出
         */
        public static Date previousMonthLastDay(long timestamps) {
            Date date = new Date(timestamps);
            LocalDateTime localDateTime = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
            LocalDate now = localDateTime.toLocalDate();
            //本月的第一天
            LocalDate firstDay = LocalDate.of(now.getYear(), now.getMonth(), 1);
            ZonedDateTime dateTime = firstDay.atStartOfDay(ZoneId.systemDefault());
            Instant plus = dateTime.toInstant().plus(-1, MILLIS);
            return Date.from(plus);
        }
    
        /**
         * 获取当前时间前一个月月份
         *
         * @param timestamps 指定时间戳
         * @return 日期的字符串格式输出
         */
        public static String formatPreviousMonth(long timestamps, String pattern) {
            Date previousMonth = previousMonthFirstDay(timestamps);
            return format(hasText(pattern) ? pattern : MONTH_ZH, previousMonth);
        }
    
        /**
         * 格式化给定时间的月份
         *
         * @param timestamps 指定时间戳
         * @return 日期的字符串格式输出
         */
        public static String formatMonth(Long timestamps, String pattern) {
            return format(hasText(pattern) ? pattern : MONTH_ZH, new Date(timestamps));
        }
    
        /**
         * 获取当前月份第一天
         *
         * @param pattern 指定格式
         * @return 日期的字符串格式输出
         */
        public static String formatCurrentMonthFirstDay(String pattern) {
            LocalDate today = LocalDate.now();
            //本月的第一天
            LocalDate firstDay = LocalDate.of(today.getYear(), today.getMonth(), 1);
            return format(pattern, firstDay);
        }
    
        /**
         * 获取前一个月最后一天
         *
         * @param pattern 指定格式
         * @return 日期的字符串格式输出
         */
        public static String formatPreviousMonthFirstDay(String pattern) {
            LocalDate today = LocalDate.now();
            //本月的第一天
            LocalDate firstDay = LocalDate.of(today.getYear(), today.getMonth().plus(-1), 1);
            return format(pattern, firstDay);
        }
    
        /**
         * 获取前一个月第一天
         *
         * @param pattern 指定格式
         * @return 日期的字符串格式输出
         */
        public static String formatPreviousMonthLastDay(String pattern) {
            LocalDate today = LocalDate.now();
            //本月的第一天
            LocalDate firstDay = LocalDate.of(today.getYear(), today.getMonth().plus(-1), 1);
            LocalDate last = firstDay.with(TemporalAdjusters.lastDayOfMonth());
            return format(pattern, last);
        }
    
        /**
         * 格式化
         *
         * @param pattern 指定样式
         * @param date    时间
         * @return
         */
        public static String format(String pattern, LocalDate date) {
            if (Objects.isNull(pattern) || pattern.length() == 0) {
                return date.format(DateTimeFormatter.ofPattern(YEAR_MONTH_DAY_ZH, Locale.CHINA));
            }
            return date.format(DateTimeFormatter.ofPattern(pattern));
        }
    
        /**
         * 格式化
         *
         * @param pattern 指定样式
         * @param date    时间
         * @return
         */
        public static String format(String pattern, LocalDateTime date) {
            if (Objects.isNull(pattern) || pattern.length() == 0) {
                return date.format(DateTimeFormatter.ofPattern(YEAR_MONTH_DAY_HH_MM_M, Locale.CHINA));
            }
            return date.format(DateTimeFormatter.ofPattern(pattern));
        }
    
        /**
         * 格式化
         *
         * @param pattern 指定样式
         * @param date    时间
         * @return
         */
        public static String format(String pattern, Date date) {
            LocalDateTime localDateTime = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
    
            return format(pattern, localDateTime);
        }
    
        /**
         * 格式化
         *
         * @param pattern   指定样式
         * @param timestamp 时间戳
         * @return
         */
        public static String format(String pattern, Long timestamp) {
            return format(pattern, new Date(timestamp));
        }
    
        /**
         * 计算两个时间的差值
         *
         * @param start 开始时间
         * @param end   结束时间
         * @param unit  单位
         * @return
         */
        public static long until(Date start, Date end, TemporalUnit unit) {
            LocalDateTime startDateTime = start.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
            LocalDateTime endDateTime = end.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
            return startDateTime.until(endDateTime, unit);
        }
    
        /**
         * 计算两个时间的差值
         *
         * @param startTime 开始时间
         * @param endTime   结束时间
         * @param unit      单位
         * @return
         */
        public static long until(Long startTime, Long endTime, TemporalUnit unit) {
            return until(new Date(startTime), new Date(endTime), unit);
        }
    
    
        /**
         * 获取当前月份最后一天
         *
         * @param pattern 指定格式
         * @return 日期的字符串格式输出
         */
        public static String formatCurrentMonthLastDay(String pattern) {
            LocalDate today = LocalDate.now();
            //本月的最后一天
            LocalDate lastDay = today.with(TemporalAdjusters.lastDayOfMonth());
            return format(pattern, lastDay);
        }
    }
    

     

    展开全文
  • Java.Utils:Alibaba - JSON 工具类

    万次阅读 2019-12-12 15:10:10
    /** * * Alibaba - JSON 对象工具类 * * * @author:bood * @date:2020/9/23 */ public final class JsonUtils { public JsonUtils() { } /** * 值过滤器 */ private static ValueFilter filter = new ValueFilter...

    Maven

    <!-- fastjson -->
    <dependency>
         <groupId>com.alibaba</groupId>
         <artifactId>fastjson</artifactId>
         <version>1.2.60</version>
     </dependency>
    
    package org.bood.common.utils;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    import com.alibaba.fastjson.serializer.SerializeConfig;
    import com.alibaba.fastjson.serializer.SerializerFeature;
    import com.alibaba.fastjson.serializer.SimpleDateFormatSerializer;
    import com.alibaba.fastjson.serializer.ValueFilter;
    
    import java.sql.Timestamp;
    import java.util.Date;
    import java.util.List;
    
    /**
     * <p>
     * Alibaba - JSON 对象工具类
     * </p>
     *
     * @author:bood
     * @date:2020/9/23
     */
    public final class JsonUtils {
    
        public JsonUtils() {
        }
    
        /**
         * 值过滤器
         */
        private static ValueFilter filter = new ValueFilter() {
            @Override
            public Object process(Object obj, String s, Object v) {
                if (v == null) {
                    return "";
                }
                return v;
            }
        };
    
        private static SerializerFeature[] feature = {
                // 解决 FastJson 循环引用的问题
                SerializerFeature.DisableCircularReferenceDetect,
                // 输出值为 null 的字段
                SerializerFeature.WriteMapNullValue
        };
    
        private static SerializeConfig mapping = new SerializeConfig();
    
        static {
            mapping.put(Date.class, new SimpleDateFormatSerializer("yyyy-MM-dd HH:mm:ss"));
            mapping.put(Timestamp.class, new SimpleDateFormatSerializer("yyyy-MM-dd HH:mm:ss"));
        }
    
        /**
         * 将对象转换成 JSON 字符串 --固定时间格式"yyyy-MM-dd HH:mm:ss"
         *
         * @param BO/VO,map,数组,list 对象
         * @return JSON 字符串
         * @说明:对 bean 中有 Date 类型的数据可以成功转换成 yyyy-MM-dd HH:mm:ss 格式的时间类型,例如:"barDate":yyyy-MM-dd HH:mm:ss
         */
        public static String getJsonByObj(Object bean) {
    
            return getJsonByObj(bean, mapping);
        }
    
        /**
         * 将对象转换成 JSON 字符串 --特定时间格式--所有 Key 为小写
         *
         * @param BO/VO,map,数组,list 对象
         * @return JSON 字符串
         * @dateType 时间格式转换后的字符串格式,例如 yyyy-MM-dd HH:mm:ss
         * @说明:对 bean 中有 Date 类型的数据可以成功转换成 yyyy-MM-dd HH:mm:ss 格式的时间类型,例如:"barDate":yyyy-MM-dd HH:mm:ss
         */
        public static String getJsonByObj(Object bean, String dateType) {
            SerializeConfig zdymapping = new SerializeConfig();
            zdymapping.put(Date.class, new SimpleDateFormatSerializer(dateType));
            return getJsonByObj(bean, zdymapping);
        }
    
        /**
         * 将对象转换成 JSON 字符串 ---效率高一些--不处理 key 也不处理循环引用的问题--也不处理时间格式
         *
         * @param BO/VO,map,数组,list 对象
         * @return JSON 字符串
         * @说明:对 bean 中有 Date 类型的数据可以成功转换成 long 格式的时间类型,例如:"barDate":1458268099098
         */
        public static String getJsonDefaultByObj(Object bean) {
            return JSON.toJSONString(bean);
        }
    
        /**
         * 将 JSON 数据转换为 ListBean 集合
         *
         * @param <T>
         * @param json  JSON 数组数据
         * @param calzz 待转换的 Bean 类型 --LinkedCaseInsensitiveMap
         * @return
         */
        public static <T> List<T> getListBean(String json, Class<T> calzz) {
            return JSON.parseArray(json, calzz);
        }
    
        /**
         * 将JSON数据转换为List集合
         *
         * @param <T>
         * @param json  JSON数组数据
         * @param calzz 待转换的Bean类型 --LinkedCaseInsensitiveMap
         * @return
         */
        @SuppressWarnings({"rawtypes", "unchecked"})
        public static List getList(String json, Class calzz) {
            return getListBean(json, calzz);
        }
    
        /**
         * 将JSON数据转换为 Java Bea n对象
         *
         * @param json  JSON字符串
         * @param calzz 待转换的 Bean 类型--LinkedCaseInsensitiveMap
         * @return
         */
        public static <T> T getObjet(String json, Class<T> calzz) {
            return JSON.parseObject(json, calzz);
        }
    
        /**
         * <p>
         * 通用封装 --获取 json 字符串
         * </p>
         *
         * @param bean: 对象
         * @param mappingx: 时间类型计划等
         * @return:java.lang.String
         * @author:bood
         * @date:2020/9/23
         */
        private static String getJsonByObj(Object bean, SerializeConfig mappingx) {
            String json = JSON.toJSONString(bean, mappingx, filter, feature);
            json = stringToJson(json);
            // 所有 Key 为小写
            return json;
        }
    
        /**
         * <p>
         * 将 JSON 数据转换为 JSONObject 对象
         * </p>
         *
         * @param json: JSON 字符串
         * @return:com.alibaba.fastjson.JSONObject
         * @author:bood
         * @date:2020/9/23
         */
        public static JSONObject getJson(String json) {
            return JSON.parseObject(json);
        }
    
        /**
         * <p>
         * 当文本中含有如下特殊字符时,此方法可以成功处理,让其在前台被正确解析,注意:此法不能处理单引号
         * </p>
         *
         * @param s: 字符串
         * @return:java.lang.String
         * @author:bood
         * @date:2020/9/23
         */
        public static String stringToJson(String s) {
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < s.length(); i++) {
                char c = s.charAt(i);
                switch (c) {
                    /*case '\"':
                        sb.append("\\\"");
    					break;*/
                    // 如果不处理单引号,可以释放此段代码,若结合下面的方法处理单引号就必须注释掉该段代码
                    case '\\':
                        sb.append("\\\\");
                        break;
                    case '/':
                        sb.append("\\/");
                        break;
                    //退格
                    case '\b':
                        sb.append("\\b");
                        break;
                    //走纸换页
                    case '\f':
                        sb.append("\\f");
                        break;
                    //换行
                    case '\n':
                        sb.append("\\n");
                        break;
                    //回车
                    case '\r':
                        sb.append("\\r");
                        break;
                    //横向跳格
                    case '\t':
                        sb.append("\\t");
                        break;
                    default:
                        sb.append(c);
                }
            }
            return sb.toString();
        }
    
    }
    

    在这里插入图片描述

    展开全文
  • CollectionUtils工具类

    万次阅读 2020-09-01 15:40:49
    这篇讲的CollectionUtils工具类是在apache下的 相关的maven <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-collections4</artifactId> <version&...
  • Android快速开发系列 10个常用工具类

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

    万次阅读 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...
  • JWT工具类

    万次阅读 2018-03-30 14:12:41
    1.JWT 加密/解密工具类实现 import com.google.gson.Gson; import io.jsonwebtoken.Claims; import io.jsonwebtoken.JwtBuilder; import io.jsonwebtoken.Jwts; import io.jsonwebtoken.Signature...
  • 自动生成代码工具 文件工具类

    万次阅读 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...
  • 很多时候,我们采用java来开发相关应用软件的时候,需要自己开发一些工具类并把它封装在utils工具类中,然后在需要使用的地方直接“类.方法”直接调用!本文将介绍两个比较常用的工具类,分别是日期工具类DateUtils...
  • POJO转换类工具类

    千次阅读 2017-12-27 17:54:58
    javaweb项目中,少不了需要领域类之间的...本文也提供了一个pojo的转换工具类,经测算,该工具类的运行效率比BeanUtils快20倍。 下文是工具类代码: /** * 实体类转化工具类 * @author 漆可 * @date 2017年12月
  • Java常用工具类汇总

    万次阅读 2021-03-04 16:03:15
    Java常用工具类汇总 时间工具类,根据本月时间获取上月一号零点零时零分零秒 java实现阿拉伯数字转换成中文数字显示 SpringBoot使用注解(@value)动态读取properties(yml)文件中配置信息 时间工具类,根据本月时间...
  • 自动生成代码工具 字符串工具类

    万次阅读 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...
  • Java8中的LocalDateTime工具类

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

    万次阅读 2020-07-27 16:49:27
    """ 超级鹰打码平台工具类 http://www.chaojiying.com/ """ from hashlib import md5 import requests class Chaojiying(object): def __init__(self, username, password, soft_id): self.username = username ...
  • 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 ...
  • 常用的工具类ApplicationContextHolder

    千次阅读 2018-08-23 15:50:07
    工具类
  • 史上最全Java8日期时间工具类

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

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

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

    千次阅读 2017-11-13 16:58:36
    一个Java基础工具类,类似于jodd...一个Java基础工具类,对文件、流、加密解密、转码、正则、线程、XML等JDK方法进行封装,组成各种Util工具类,同时提供以下组件: 布隆过滤 缓存 克隆接口 类型转换
  • UUID工具类

    千次阅读 2018-04-10 13:42:28
    UUID工具类 import utils.print.Print; import java.util.UUID; /** * @author Created by 谭健 on 2018/3/27 0027. 星期二. 14:39. * © All Rights Reserved. */ public class UUIDUtils { public ...
  • 整理收集的一些常用java工具类

    万次阅读 多人点赞 2017-08-20 19:42:14
    整理收集的一些常用java工具类
  • java正则表达式表单验证类工具类(验证邮箱、手机号码、qq号码等) 这篇文章主要介绍了java使用正则表达式进行表单验证工具类,可以验证邮箱、手机号码、qq号码等方法,需要的朋友可以参考下。 java使用正则表达式进行...
  • java类的转换工具类,泛型的使用

    万次阅读 2021-02-08 15:35:10
    做项目的时候,要取出map中的值进行运算,map对象如下,不知道什么类型,还要进行准确的转换,确实是不容易,然后写一个可扩展的工具类,方便项目使用,也方便大家使用 Map<String,Object> map = new ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 277,030
精华内容 110,812
关键字:

工具类