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的反序列化获取某个值，如果某个值的路径比较深，除了编写工作量变大和风险扩大外，还有就是代码不够整洁。抽空写了个根据地址寻址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);
    }


 

时间转换工具类

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


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);
    }
}


 

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();
    }

}