Java中 String工具类

public class StringUtil {

/**
 * 判断字符串是否   不为NotEmpty(!null或空值)
 *
 * @param param 待检查对象
 * @return boolean 返回的布尔值
 */
public static boolean isNotNullEmpty(String param) {
    return !isNullOrEmpty(param);
}

/**
 * 判断字符串是否为   NotEmpty(!null或空值)
 *
 * @param param
 * @return
 */
public static boolean isNullOrEmpty(String param) {
    if (StringUtils.isEmpty(param)) {
        return true;
    }
    return StringUtils.isBlank(param);
}

/**
 * 字符串长度
 * 中文2个字符，英文1个字符
 *
 * @param value
 * @return
 */
public static int length(String value) {
    int valueLength = 0;
    String chinese = "[\u4e00-\u9fa5]";
    for (int i = 0, j = value.length(); i < j; i++) {
        String temp = value.substring(i, i + 1);
        if (temp.matches(chinese)) {
            valueLength += 2;
        } else {
            valueLength += 1;
        }
    }
    return valueLength;
}

/**
 * 字符串截取
 *
 * @param str
 * @param start  开始
 * @param length 长度
 * @return
 */
public static final String substr(String str, Integer start, Integer length) {
    if (length > 0) {
        return str.substring(start, length);
    }
    return str.substring(start);
}

private static Pattern replaceBlank = Pattern.compile("\\s*|\t|\r|\n");

/**
 * 去除所有空格，制表，换行
 *
 * @param str
 * @return
 */
public static String replaceBlank(String str) {
    String dest = "";
    if (str != null) {
        Matcher m = replaceBlank.matcher(str);
        dest = m.replaceAll("");
    }
    return dest;
}

/**
 * 特殊字符
 */
private static String patternEx = "[`~!@#$%^&*()+=|{}':;',\\[\\].<>/?~！@#￥%……&*（）——+|{}【】‘；：”“’。，、？_]";

/**
 * 判断特殊字符
 * https://blog.csdn.net/you23hai45/article/details/20163459
 *
 * @param str
 * @return
 * @throws PatternSyntaxException
 * @Title : FilterStr
 * @Type : FilterString
 * @Description : 判断特殊字符
 */
public static String filterStr(String str) throws PatternSyntaxException {
    Pattern pat = Pattern.compile(patternEx);
    Matcher mat = pat.matcher(str);

    /**
     * 返回替换结果
     */
    return mat.replaceAll("").trim();
}

/**
 * 判断 String[] 是否为null
 *
 * @param str
 * @return
 */
public static boolean isArrNotNull(String[] str) {
    return str != null && str.length > 0;
}

public static String toString(Object obj) {
    return toString(obj, "");
}

public static String toString(Object obj, String defaults) {
    String s = String.valueOf(obj);
    if ("null".equals(s)) {
        return defaults;
    }
    return s;
}

public static String toString(char obj[]) {
    return String.valueOf(obj);
}

public static String toString(boolean obj) {
    return String.valueOf(obj);
}

public static String toString(char obj) {
    return String.valueOf(obj);
}

public static String toString(int obj) {
    return String.valueOf(obj);
}

public static String toString(long obj) {
    return String.valueOf(obj);
}

public static String toString(float obj) {
    return String.valueOf(obj);
}

public static String toString(double obj) {
    return String.valueOf(obj);
}

public static String toString(Long obj) {
    return toString(obj, "0");
}

public static String toString(Long obj, String defaults) {
    if (NumberUtil.isLongNull(obj)) {
        return defaults;
    }
    return String.valueOf(obj);
}

public static String toString(Integer obj) {
    return toString(obj, "0");
}

public static String toString(Integer obj, String defaults) {
    if (NumberUtil.isIntegerNull(obj)) {
        return defaults;
    }
    return String.valueOf(obj);
}

public static String toString(Float obj) {
    return toString(obj, "0");
}

public static String toString(Float obj, String defaults) {
    if (NumberUtil.isFloatNull(obj)) {
        return defaults;
    }
    return String.valueOf(obj);
}

public static String toString(Double obj) {
    return toString(obj, "0");
}

public static String toString(Double obj, String defaults) {
    if (NumberUtil.isDoubleNull(obj)) {
        return defaults;
    }
    return String.valueOf(obj);
}

public static String toString(BigDecimal obj) {
    return toString(obj, "0");
}

public static String toString(BigDecimal obj, String defaults) {
    if (!BigDecimalUtil.isNotNull(obj)) {
        return defaults;
    }
    return String.valueOf(obj);
}

public static String toString(String obj) {
    return toString(obj, "");
}

public static String toString(String obj, String defaults) {
    if (isNullOrEmpty(obj)) {
        return "";
    }
    return obj;
}

private static final char[] DEFAULT_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz".toCharArray();
private static final char[] NUMBER_ALPHABET = "0123456789".toCharArray();

/**
 * 随机数
 *
 * @param size 长度
 * @return
 */
public static String randomNanoId(int size) {
    return NanoId.randomNanoId(null, DEFAULT_ALPHABET, size);
}

/**
 * 随机数 32位
 *
 * @return
 */
public static String randomNanoId() {
    return NanoId.randomNanoId(null, DEFAULT_ALPHABET, 32);
}

/**
 * 随机数
 *
 * @param size 长度
 * @return
 */
public static String randomNumber(int size) {
    return NanoId.randomNanoId(null, NUMBER_ALPHABET, size);
}

/**
 * 拆分 逗号 数组，并去重
 *
 * @param str
 * @return
 */
public static Optional<List<String>> toList(String str) {
    return toList(str, ",");
}

/**
 * 拆分 逗号 数组，并去重
 *
 * @param str
 * @return
 */
public static Optional<List<String>> toList(String str, String separator) {
    String s = StringUtils.trimToEmpty(str);
    if (StringUtils.isBlank(s)) {
        return Optional.empty();
    }

// if (!StringUtils.contains(s, ",")) {
// return Optional.ofNullable(Lists.newArrayList(s));
// }

    List<String> strings = Splitter.on(separator).trimResults().omitEmptyStrings().splitToList(str);
    if (null == strings || strings.size() <= 0) {
        return Optional.empty();
    }
    return Optional.ofNullable(strings.stream().distinct().collect(Collectors.toList()));
}

/**
 * 解析后，用 , 号分割,拼接(连接)成 字符串，并跳过 null 值
 *
 * @param list
 * @return
 */
public static String parse(List<String> list) {
    return parse(list, ",");
}

/**
 * 解析后，用 指定 符号分割,拼接(连接)成 字符串，并跳过 null 值
 *
 * @param list
 * @return
 */
public static String parse(List<String> list, String separator) {
    return Joiner.on(separator).skipNulls().join(list);
}

/**
 * 是否为 null 或者 空字符
 *
 * @param param
 * @return
 */
public static boolean isBlank(String param) {
    return StringUtils.isBlank(param);
}

/**
 * 不为 null 或者 空字符
 *
 * @param param
 * @return
 */
public static boolean isNotBlank(String param) {
    return StringUtils.isNotBlank(param);
}

/**
 * 解析并填充
 *
 * @param source , 号 隔开的，字符串
 * @param map
 * @return
 */
public static String parseToFill(String source, Map<String, String> map) {

    return StringUtil.parseToFill(source,map,",");
}

/**
 * 解析并填充
 *
 * @param source , 号 隔开的，字符串
 * @param map
 * @return
 */
public static String parseToFill(String source, Map<String, String> map, String separator) {
    if (StringUtils.isBlank(source)) {
        return "";
    }
    if (map.isEmpty()) {
        return "";
    }
    Optional<List<String>> strings = toList(source,separator);
    if (strings.isPresent()) {
        StringBuffer sb = new StringBuffer();
        int i = 0;
        for (String str : strings.get()) {
            if (map.containsKey(str)) {
                if (i > 0) {
                    sb.append(",");
                }
                sb.append(map.get(str));
                i++;
            }
        }
        if(StringUtils.isEmpty(sb.toString())){
            return "";
        }
        if(",".equals( sb.toString().substring(sb.toString().length() - 1))){
            return org.springframework.util.StringUtils.isEmpty(sb.toString()) ? null : (sb.toString().substring(0, sb.toString().length() - 1));
        }else {
            return sb.toString();
        }

    }
    return "";
}

/**
 * 格式化文本, {} 表示占位符 此方法只是简单将占位符 {} 按照顺序替换为参数 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可 例：
 * 通常使用：format("this is {} for {}", "a", "b") =》 this is a for b 转义{}
 * ： format("this is \\{} for {}", "a", "b") =》 this is \{} for a 转义\
 * ： format("this is \\\\{} for {}", "a", "b") =》 this is \a for b
 *
 * @param template – 文本模板，被替换的部分用 {} 表示，如果模板为null，返回"null"
 * @param params   – 参数值
 * @return 格式化后的文本，如果模板为null，返回"null"
 */
public static String format(CharSequence template, Object... params) {
    return StrUtil.format(template, params);
}

public static String trim(String str) {
    return StringUtils.trimToEmpty(str);
}

}