【常用工具类】StringUtils 全面总结 ，真的太方便了

一、来源

Apache Commons-Lang3

二、SpringBoot集成

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version>
</dependency>

三、常用方法总结

1、isBlank(String str)
检查字符串是否为空或只包含空格。

StringUtils.isBlank(null); // true
StringUtils.isBlank(""); // true
StringUtils.isBlank("  "); // true
StringUtils.isBlank("hello"); // false

2、isEmpty(String str)
检查字符串是否为空。

StringUtils.isEmpty(null); // true
StringUtils.isEmpty(""); // true
StringUtils.isEmpty("  "); // false
StringUtils.isEmpty("hello"); // false

3、isNotBlank(String str)
检查字符串是否不为空且不只包含空格。

StringUtils.isNotBlank(null); // false
StringUtils.isNotBlank(""); // false
StringUtils.isNotBlank("  "); // false
StringUtils.isNotBlank("hello"); // true

4、isNotEmpty(String str)
检查字符串是否不为空。

StringUtils.isNotEmpty(null); // false
StringUtils.isNotEmpty(""); // false
StringUtils.isNotEmpty("  "); // true
StringUtils.isNotEmpty("hello"); // true

5、trim(String str)
去除字符串两端的空格。

StringUtils.trim(null); // null
StringUtils.trim(""); // ""
StringUtils.trim("  hello  "); // "hello"

6、capitalize(String str)
将字符串的首字母大写。

StringUtils.capitalize(null); // null
StringUtils.capitalize(""); // ""
StringUtils.capitalize("hello"); // "Hello"
StringUtils.capitalize("hello world"); // "Hello world"

7、uncapitalize(String str)
将字符串的首字母小写。

StringUtils.uncapitalize(null); // null
StringUtils.uncapitalize(""); // ""
StringUtils.uncapitalize("Hello"); // "hello"
StringUtils.uncapitalize("Hello World"); // "hello World"

8、equals(String str1, String str2)
比较两个字符串是否相等，可以处理null值。

StringUtils.equals(null, null); // true
StringUtils.equals(null, "hello"); // false
StringUtils.equals("hello", null); // false
StringUtils.equals("hello", "hello"); // true
StringUtils.equals("hello", "Hello"); // false

9、equalsIgnoreCase(String str1, String str2)
比较两个字符串是否相等，忽略大小写。

StringUtils.equalsIgnoreCase(null, null); // true
StringUtils.equalsIgnoreCase(null, "hello"); // false
StringUtils.equalsIgnoreCase("hello", null); // false
StringUtils.equalsIgnoreCase("hello", "hello"); // true
StringUtils.equalsIgnoreCase("hello", "Hello"); // true

10、substring(String str, int start, int end)
获取字符串的子串，从start位置到end位置。

StringUtils.substring(null, 0, 5); // null
StringUtils.substring("", 0, 5); // ""
StringUtils.substring("hello world", 0, 5); // "hello"

11、split(String str, String separator)
将字符串按照指定的分隔符分割成数组。

StringUtils.split(null, ","); // null
StringUtils.split("", ","); // [""]
StringUtils.split("hello,world", ","); // ["hello", "world"]

12、join(String separator, Object… elements)
将多个元素连接成一个字符串，使用指定的分隔符。

StringUtils.join(",", "hello", "world"); // "hello,world"
StringUtils.join(",", "hello", null, "world"); // "hello,,world"
StringUtils.join(",", new String[]{"hello", "world"}); // "hello,world"

13、replace(String str, String search, String replace)
将字符串中的指定内容替换为新的内容。

StringUtils.replace(null, "l", "x"); // null
StringUtils.replace("", "l", "x"); // ""
StringUtils.replace("hello world", "l", "x"); // "hexxo word"

14、contains(String str, String search)
检查字符串是否包含指定的内容。

StringUtils.contains(null, "hello"); // false
StringUtils.contains("", "hello"); // false
StringUtils.contains("hello world", "hello"); // true
StringUtils.contains("hello world", "goodbye"); // false

15、indexOf(String str, String search)
获取字符串中指定内容的第一个出现位置。

StringUtils.indexOf(null, "hello"); // -1
StringUtils.indexOf("", "hello"); // -1
StringUtils.indexOf("hello world", "hello"); // 0
StringUtils.indexOf("hello world", "world"); // 6

16、lastIndexOf(String str, String search)
获取字符串中指定内容的最后一个出现位置。

StringUtils.lastIndexOf(null, "hello"); // -1
StringUtils.lastIndexOf("", "hello"); // -1
StringUtils.lastIndexOf("hello world", "hello"); // 0
StringUtils.lastIndexOf("hello world", "world"); // 6

17、upperCase(String str)
将字符串转换为大写。

StringUtils.upperCase(null); // null
StringUtils.upperCase(""); // ""
StringUtils.upperCase("hello"); // "HELLO"
StringUtils.upperCase("Hello World"); // "HELLO WORLD"

18、lowerCase(String str)
将字符串转换为小写。

StringUtils.lowerCase(null); // null
StringUtils.lowerCase(""); // ""
StringUtils.lowerCase("HELLO"); // "hello"
StringUtils.lowerCase("Hello World"); // "hello world"

四、扩展

直接上扩展类。

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.springframework.util.AntPathMatcher;
import com.yduser.common.constant.Constants;
import com.yduser.common.core.text.StrFormatter;

/**
 * 字符串工具类
 *
 * @author shi
 */
public class StringUtils extends org.apache.commons.lang3.StringUtils {
    /**
     * 空字符串
     */
    private static final String NULLSTR = "";

    /**
     * 下划线
     */
    private static final char SEPARATOR = '_';

    /**
     * 获取参数不为空值
     *
     * @param value defaultValue 要判断的value
     * @return value 返回值
     */
    public static <T> T nvl(T value, T defaultValue) {
        return value != null ? value : defaultValue;
    }

    /**
     * * 判断一个Collection是否为空， 包含List，Set，Queue
     *
     * @param coll 要判断的Collection
     * @return true：为空 false：非空
     */
    public static boolean isEmpty(Collection<?> coll) {
        return isNull(coll) || coll.isEmpty();
    }

    /**
     * * 判断一个Collection是否非空，包含List，Set，Queue
     *
     * @param coll 要判断的Collection
     * @return true：非空 false：空
     */
    public static boolean isNotEmpty(Collection<?> coll) {
        return !isEmpty(coll);
    }

    /**
     * * 判断一个对象数组是否为空
     *
     * @param objects 要判断的对象数组
     *                * @return true：为空 false：非空
     */
    public static boolean isEmpty(Object[] objects) {
        return isNull(objects) || (objects.length == 0);
    }

    /**
     * * 判断一个对象数组是否非空
     *
     * @param objects 要判断的对象数组
     * @return true：非空 false：空
     */
    public static boolean isNotEmpty(Object[] objects) {
        return !isEmpty(objects);
    }

    /**
     * * 判断一个Map是否为空
     *
     * @param map 要判断的Map
     * @return true：为空 false：非空
     */
    public static boolean isEmpty(Map<?, ?> map) {
        return isNull(map) || map.isEmpty();
    }

    /**
     * * 判断一个Map是否为空
     *
     * @param map 要判断的Map
     * @return true：非空 false：空
     */
    public static boolean isNotEmpty(Map<?, ?> map) {
        return !isEmpty(map);
    }

    /**
     * * 判断一个字符串是否为空串
     *
     * @param str String
     * @return true：为空 false：非空
     */
    public static boolean isEmpty(String str) {
        return isNull(str) || NULLSTR.equals(str.trim());
    }

    /**
     * * 判断一个字符串是否为非空串
     *
     * @param str String
     * @return true：非空串 false：空串
     */
    public static boolean isNotEmpty(String str) {
        return !isEmpty(str);
    }

    /**
     * * 判断一个对象是否为空
     *
     * @param object Object
     * @return true：为空 false：非空
     */
    public static boolean isNull(Object object) {
        return object == null;
    }

    /**
     * * 判断一个对象是否非空
     *
     * @param object Object
     * @return true：非空 false：空
     */
    public static boolean isNotNull(Object object) {
        return !isNull(object);
    }

    /**
     * * 判断一个对象是否是数组类型（Java基本型别的数组）
     *
     * @param object 对象
     * @return true：是数组 false：不是数组
     */
    public static boolean isArray(Object object) {
        return isNotNull(object) && object.getClass().isArray();
    }

    /**
     * 去空格
     */
    public static String trim(String str) {
        return (str == null ? "" : str.trim());
    }

    /**
     * 截取字符串
     *
     * @param str   字符串
     * @param start 开始
     * @return 结果
     */
    public static String substring(final String str, int start) {
        if (str == null) {
            return NULLSTR;
        }

        if (start < 0) {
            start = str.length() + start;
        }

        if (start < 0) {
            start = 0;
        }
        if (start > str.length()) {
            return NULLSTR;
        }

        return str.substring(start);
    }

    /**
     * 截取字符串
     *
     * @param str   字符串
     * @param start 开始
     * @param end   结束
     * @return 结果
     */
    public static String substring(final String str, int start, int end) {
        if (str == null) {
            return NULLSTR;
        }

        if (end < 0) {
            end = str.length() + end;
        }
        if (start < 0) {
            start = str.length() + start;
        }

        if (end > str.length()) {
            end = str.length();
        }

        if (start > end) {
            return NULLSTR;
        }

        if (start < 0) {
            start = 0;
        }
        if (end < 0) {
            end = 0;
        }

        return str.substring(start, end);
    }

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

    /**
     * 是否为http(s)://开头
     *
     * @param link 链接
     * @return 结果
     */
    public static boolean ishttp(String link) {
        return StringUtils.startsWithAny(link, Constants.HTTP, Constants.HTTPS);
    }

    /**
     * 字符串转set
     *
     * @param str 字符串
     * @param sep 分隔符
     * @return set集合
     */
    public static final Set<String> str2Set(String str, String sep) {
        return new HashSet<String>(str2List(str, sep, true, false));
    }

    /**
     * 字符串转list
     *
     * @param str         字符串
     * @param sep         分隔符
     * @param filterBlank 过滤纯空白
     * @param trim        去掉首尾空白
     * @return list集合
     */
    public static final List<String> str2List(String str, String sep, boolean filterBlank, boolean trim) {
        List<String> list = new ArrayList<String>();
        if (StringUtils.isEmpty(str)) {
            return list;
        }

        // 过滤空白字符串
        if (filterBlank && StringUtils.isBlank(str)) {
            return list;
        }
        String[] split = str.split(sep);
        for (String string : split) {
            if (filterBlank && StringUtils.isBlank(string)) {
                continue;
            }
            if (trim) {
                string = string.trim();
            }
            list.add(string);
        }

        return list;
    }

    /**
     * 查找指定字符串是否包含指定字符串列表中的任意一个字符串同时串忽略大小写
     *
     * @param cs                  指定字符串
     * @param searchCharSequences 需要检查的字符串数组
     * @return 是否包含任意一个字符串
     */
    public static boolean containsAnyIgnoreCase(CharSequence cs, CharSequence... searchCharSequences) {
        if (isEmpty(cs) || isEmpty(searchCharSequences)) {
            return false;
        }
        for (CharSequence testStr : searchCharSequences) {
            if (containsIgnoreCase(cs, testStr)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 驼峰转下划线命名
     */
    public static String toUnderScoreCase(String str) {
        if (str == null) {
            return null;
        }
        StringBuilder sb = new StringBuilder();
        // 前置字符是否大写
        boolean preCharIsUpperCase = true;
        // 当前字符是否大写
        boolean curreCharIsUpperCase = true;
        // 下一字符是否大写
        boolean nexteCharIsUpperCase = true;
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (i > 0) {
                preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));
            } else {
                preCharIsUpperCase = false;
            }

            curreCharIsUpperCase = Character.isUpperCase(c);

            if (i < (str.length() - 1)) {
                nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));
            }

            if (preCharIsUpperCase && curreCharIsUpperCase && !nexteCharIsUpperCase) {
                sb.append(SEPARATOR);
            } else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase) {
                sb.append(SEPARATOR);
            }
            sb.append(Character.toLowerCase(c));
        }

        return sb.toString();
    }

    /**
     * 是否包含字符串
     *
     * @param str  验证字符串
     * @param strs 字符串组
     * @return 包含返回true
     */
    public static boolean inStringIgnoreCase(String str, String... strs) {
        if (str != null && strs != null) {
            for (String s : strs) {
                if (str.equalsIgnoreCase(trim(s))) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：HELLO_WORLD->HelloWorld
     *
     * @param name 转换前的下划线大写方式命名的字符串
     * @return 转换后的驼峰式命名的字符串
     */
    public static String convertToCamelCase(String name) {
        StringBuilder result = new StringBuilder();
        // 快速检查
        if (name == null || name.isEmpty()) {
            // 没必要转换
            return "";
        } else if (!name.contains("_")) {
            // 不含下划线，仅将首字母大写
            return name.substring(0, 1).toUpperCase() + name.substring(1);
        }
        // 用下划线将原始字符串分割
        String[] camels = name.split("_");
        for (String camel : camels) {
            // 跳过原始字符串中开头、结尾的下换线或双重下划线
            if (camel.isEmpty()) {
                continue;
            }
            // 首字母大写
            result.append(camel.substring(0, 1).toUpperCase());
            result.append(camel.substring(1).toLowerCase());
        }
        return result.toString();
    }

    /**
     * 驼峰式命名法 例如：user_name->userName
     */
    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();
    }

    /**
     * 查找指定字符串是否匹配指定字符串列表中的任意一个字符串
     *
     * @param str  指定字符串
     * @param strs 需要检查的字符串数组
     * @return 是否匹配
     */
    public static boolean matches(String str, List<String> strs) {
        if (isEmpty(str) || isEmpty(strs)) {
            return false;
        }
        for (String pattern : strs) {
            if (isMatch(pattern, str)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 判断url是否与规则配置:
     * ? 表示单个字符;
     * * 表示一层路径内的任意字符串，不可跨层级;
     * ** 表示任意层路径;
     *
     * @param pattern 匹配规则
     * @param url     需要匹配的url
     * @return
     */
    public static boolean isMatch(String pattern, String url) {
        AntPathMatcher matcher = new AntPathMatcher();
        return matcher.match(pattern, url);
    }

    @SuppressWarnings("unchecked")
    public static <T> T cast(Object obj) {
        return (T) obj;
    }
}

扩展类参考(若依开源项目 - Gitee.com)