【Java常用工具类】字符串

最新推荐文章于 2023-08-03 00:33:36 发布

码拉松

最新推荐文章于 2023-08-03 00:33:36 发布

阅读量1k

点赞数 1

分类专栏：常用开发工具类文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/CSDN_WYL2016/article/details/120953698

版权

常用开发工具类专栏收录该内容

5 篇文章 0 订阅

订阅专栏

文章目录

其他工具类

其他工具类

【Java常用工具类】数学计算

【Java常用工具类】日期类

【Java常用工具类】easyexcel基本使用演示

【Java常用工具类】集合操作常用方法

方法解释

1、nullToEmpty(String string)，把null转换成空字符串，如果不是null则不变

    @Test
    public void nullToEmpty() {
        Assert.assertEquals("", StringsUtils.nullToEmpty(null));
        Assert.assertEquals("", StringsUtils.nullToEmpty(""));
        Assert.assertEquals("a", StringsUtils.nullToEmpty("a"));
    }

2、padStart(String string, int minLength, char padChar)，在目标字符串前拼接指定内容

    @Test
    public void padStart() {
        Assert.assertEquals("x", StringsUtils.padStart("x", 1, '-'));
        Assert.assertEquals("-x", StringsUtils.padStart("x", 2, '-'));
        Assert.assertEquals("xx", StringsUtils.padStart("xx", 1, '-'));
    }

3、padEnd(String string, int minLength, char padChar)，在目标字符串后拼接指定内容

    @Test
    public void padEnd() {
        Assert.assertEquals("x--", StringsUtils.padEnd("x", 3, '-'));
    }

4、repeat(String str, int count)，重复拼接str内容count次

    @Test
    public void repeat() {
        String str = "12-";
        Assert.assertEquals("", StringsUtils.repeat(str, 0));
        Assert.assertEquals("12-", StringsUtils.repeat(str, 1));
        Assert.assertEquals("12-12-", StringsUtils.repeat(str, 2));
        Assert.assertEquals("12-12-12-", StringsUtils.repeat(str, 3));
    }

5、commonPrefix(CharSequence a, CharSequence b)，取公共前缀

    @Test
    public void commonPrefix() {
        Assert.assertEquals("ab", StringsUtils.commonPrefix("abcd", "abed"));
    }

6、commonSuffix(CharSequence a, CharSequence b)，取公共后缀

    @Test
    public void commonSuffix() {
        Assert.assertEquals("d", StringsUtils.commonSuffix("abcd", "abed"));
    }

7、splitToList(String separator, String string)，按照separator对string进行分割，返回list

    @Test
    public void splitToIterator() {
        Iterator<String> stringIterator = StringsUtils.splitToIterator(",", "a,b,c");
        String[] strings = new String[3];
        int i = 0;
        while (stringIterator.hasNext()) {
            strings[i++] = stringIterator.next();
        }
        Assert.assertEquals(Arrays.asList(strings), Arrays.asList("a", "b", "c"));
    }

8、splitToIterator(String separator, String string)，功能与splitToList一样，返回iterator

    @Test
    public void splitToList() {
        List<String> stringList = StringsUtils.splitToList(",", "a,b,c");
        Assert.assertEquals(Arrays.asList("a", "b", "c"), stringList);
    }

9、splitToStream(String separator, String string)，功能与splitToList一样，返回stream

    @Test
    public void splitToStream() {
        Stream<String> stringStream = StringsUtils.splitToStream(",", "a,b,c");
        Assert.assertEquals(Arrays.asList("a", "b", "c"), stringStream.collect(Collectors.toList()));
    }

10、splitFixLengthToIterator(int length, String string)，功能与splitToList一样，控制了被分割后的长度

    @Test
    public void splitFixLengthToIterator() {
        Iterator<String> stringIterator = StringsUtils.splitFixLengthToIterator(2, "abcde");
        String[] strings = new String[3];
        int i = 0;
        while (stringIterator.hasNext()) {
            strings[i++] = stringIterator.next();
        }
        Assert.assertEquals(Arrays.asList(strings), Arrays.asList("ab", "cd", "e"));
    }

11、splitFixLengthToList(int length, String string)，功能与splitFixLengthToIterator一样，返回list

    @Test
    public void splitFixLengthToList() {
        List<String> stringList = StringsUtils.splitFixLengthToList(2, "abc");
        Assert.assertEquals(Arrays.asList("ab", "c"), stringList);
    }

12、splitFixLengthToStream(int length, String string)，功能与splitFixLengthToIterator一样，返回stream

    @Test
    public void splitFixLengthToStream() {
        Stream<String> stringStream = StringsUtils.splitFixLengthToStream(1, "abc");
        Assert.assertEquals(Arrays.asList("a", "b", "c"), stringStream.collect(Collectors.toList()));
    }

13、splitToMap(String separator1, String separator2, String string)，把key、value格式的字符串分割成map

    @Test
    public void splitToMap() {
        Map<String, String> stringStringMap = StringsUtils.splitToMap(",", ":", "boy:tom,girl:tina,cat:kitty");
        Map<String, String> expectedMap = new HashMap<>();
        expectedMap.put("boy", "tom");
        expectedMap.put("girl", "tina");
        expectedMap.put("cat", "kitty");
        Assert.assertEquals(expectedMap, stringStringMap);
    }

14、join(char separator, Iterable<Integer> parts)，用分隔符拼接被分割的集合

    @Test
    public void join() {
        String join = StringsUtils.join('-', Arrays.asList(1, 2, 3));
        Assert.assertEquals("1-2-3", join);
    }

15、joinSkipNulls(char separator, Iterable<Integer> parts)，用分隔符拼接被分割的集合，跳过null值

    @Test
    public void joinSkipNulls() {
        String join = StringsUtils.joinSkipNulls('-', Arrays.asList(1, null, 2));
        Assert.assertEquals("1-2", join);
    }

16、joinSkipUseForNulls(char separator, Iterable<Integer> parts, String nullText)，用分隔符拼接被分割的集合，把null值替换成nullText

    @Test
    public void joinSkipUseForNulls() {
        String join = StringsUtils.joinSkipUseForNulls('-', Arrays.asList(1, null, 2), "0");
        Assert.assertEquals("1-0-2", join);
    }

17、retainFrom(String string, final char startInclusive, final char endInclusive)，提取给定字符串中只包含startInclusive到endInclusive范围的内容

    @Test
    public void retainFrom() {
        String s = StringsUtils.retainFrom("aosijs2938av", 'a', 'z');
        Assert.assertEquals("aosijsav", s);
    }

18、removeFrom(String string, final char startInclusive, final char endInclusive)，删除给定字符串中只startInclusive到endInclusive范围的内容

    @Test
    public void removeFrom() {
        String s = StringsUtils.removeFrom("aosijs2938av", 'a', 'z');
        Assert.assertEquals("2938", s);
    }

19、removeIsChar(String string, char isChar)，在string中把isChar移除

    @Test
    public void removeIsChar() {
        String s = StringsUtils.removeIsChar("aosijs2938av", 'a');
        Assert.assertEquals("osijs2938v", s);
    }

20、removeIsNotChar(String string, char isNotChar)，在string中把除了isNotChar的移除

    @Test
    public void removeIsNotChar() {
        String s = StringsUtils.removeIsNotChar("aosijs2938av", 'a');
        Assert.assertEquals("aa", s);
    }

21、removeAnyChar(String string, String anyStr)，在string中把anyStr移除

    @Test
    public void removeAnyChar() {
        String s = StringsUtils.removeAnyChar("aosijs2938av", "a8");
        Assert.assertEquals("osijs293v", s);
    }

22、removeNotAnyChar(String string, String notAnyStr)，在string中把除了notAnyStr的移除

    @Test
    public void removeNotAnyChar() {
        String s = StringsUtils.removeNotAnyChar("aosijs2938av", "a8");
        Assert.assertEquals("a8a", s);
    }

23、underscoreToCamel(String string)，下划线格式转驼峰

    @Test
    public void underscoreToCamel() {
        String s = StringsUtils.underscoreToCamel("nick_name");
        Assert.assertEquals("nickName", s);
    }

24、camelToUnderscore(String string)，驼峰格式转下划线

    @Test
    public void camelToUnderscore() {
        String s = StringsUtils.camelToUnderscore("nickName");
        Assert.assertEquals("nick_name", s);
    }

25、mapJoinSeparatorToString(Map<String, String> map, String separator1, String separator2)，把map中的key、value按照分隔符拼接成字符串

    @Test
    public void mapJoinSeparatorToString() {
        Map<String, String> expectedMap = new HashMap<>();
        expectedMap.put("boy", "tom");
        expectedMap.put("girl", "tina");
        expectedMap.put("cat", "kitty");
        String join = StringsUtils.mapJoinSeparatorToString(expectedMap, ",", ":");
        Assert.assertEquals(join, "cat:kitty,girl:tina,boy:tom");
    }

方法代码


import com.google.common.base.*;

import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Stream;

public class StringsUtils {

    /**
     * 把null转换成空字符串，如果不是null则不变
     * <p>
     * Assert.assertEquals("", StringsUtils.nullToEmpty(null));
     * Assert.assertEquals("", StringsUtils.nullToEmpty(""));
     * Assert.assertEquals("a", StringsUtils.nullToEmpty("a"));
     *
     * @param string 原字符串
     * @return string
     */
    public static String nullToEmpty(String string) {
        return Strings.nullToEmpty(string);
    }

    /**
     * padStart、padEnd，在目标字符串前后拼接指定内容
     * <p>
     * string: 原字符串
     * minLength: 拼接后字符串长度至少为minLength大小
     * padChar: 待拼接的内容
     * <p>
     * Assert.assertEquals("x", StringsUtils.padStart("x", 1, '-'));
     * Assert.assertEquals("-x", StringsUtils.padStart("x", 2, '-'));
     * Assert.assertEquals("xx", StringsUtils.padStart("xx", 1, '-'));
     * Strings.padStart(null, 0, '-');抛出异常
     *
     * @param string    原字符串
     * @param minLength 拼接后字符串长度至少为minLength大小
     * @param padChar   待拼接的内容
     * @return string
     */
    public static String padStart(String string, int minLength, char padChar) {
        return Strings.padStart(string, minLength, padChar);
    }

    /**
     * 与padStart类似
     * <p>
     * Assert.assertEquals("x--", StringsUtils.padEnd("x", 3, '-'));
     * Strings.padEnd(null, 0, '-'); 抛出NPE异常
     *
     * @param string    原字符串
     * @param minLength 拼接后字符串长度至少为minLength大小
     * @param padChar   待拼接的内容
     * @return string
     */
    public static String padEnd(String string, int minLength, char padChar) {
        return Strings.padEnd(string, minLength, padChar);
    }

    /**
     * 实现字符串的重复拼接
     * <p>
     * String str = "12-";
     * Assert.assertEquals("", StringsUtils.repeat(str, 0));
     * Assert.assertEquals("12-", StringsUtils.repeat(str, 1));
     * Assert.assertEquals("12-12-", StringsUtils.repeat(str, 2));
     * Assert.assertEquals("12-12-12-", StringsUtils.repeat(str, 3));
     * StringsUtils.repeat(str, -1); 如果count为负数，则会抛出IllegalArgumentException
     * StringsUtils.repeat("12", (1 << 30)); 抛出ArrayIndexOutOfBoundsException
     * StringsUtils.repeat(null,0); 抛出NPE异常
     *
     * @param string 原字符串
     * @param count  表示原字符串出现的次数
     * @return string
     */
    public static String repeat(String string, int count) {
        return Strings.repeat(string, count);
    }

    /**
     * 取两个字符串的公共前缀
     *
     * @param a "abcd"
     * @param b "abed"
     * @return "ab"
     */
    public static String commonPrefix(CharSequence a, CharSequence b) {
        return Strings.commonPrefix(a, b);
    }

    /**
     * 取两个字符串的公共后缀
     *
     * @param a "abcd"
     * @param b "abed"
     * @return "d"
     */
    public static String commonSuffix(CharSequence a, CharSequence b) {
        return Strings.commonSuffix(a, b);
    }

    /**
     * 按照separator对string进行分割
     * <p>
     * splitter: ‘,’
     * string: "a,b,c"
     * 结果: [a,b,c]
     *
     * @param separator 分割符
     * @param string    待分割字符串
     * @return iterator
     */
    public static Iterator<String> splitToIterator(String separator, String string) {
        Splitter COMMA_SPLITTER = Splitter.on(separator);
        return COMMA_SPLITTER.split(string).iterator();
    }

    /**
     * 与splitToIterator类似
     *
     * @param separator 分割符
     * @param string    待分割字符串
     * @return list
     */
    public static List<String> splitToList(String separator, String string) {
        Splitter COMMA_SPLITTER = Splitter.on(separator);
        return COMMA_SPLITTER.splitToList(string);
    }

    /**
     * 与splitToIterator类似
     *
     * @param separator 分割符
     * @param string    待分割字符串
     * @return stream
     */
    public static Stream<String> splitToStream(String separator, String string) {
        Splitter COMMA_SPLITTER = Splitter.on(separator);
        return COMMA_SPLITTER.splitToStream(string);
    }

    /**
     * 与splitToIterator类似,但是被分割出来的单个字符长度不会超过length
     * <p>
     * length: 2, string: "abcde" -> "ab", "cd", "e"
     * length: 2, string: "abcdef" -> "ab", "cd", "ef"
     * length: 4, string: "abc" -> "abc"
     * length: 4, string: "abcd" -> "abcd"
     *
     * @param length 被分割后的单个字符最大长度
     * @param string 原字符串
     * @return string
     */
    public static Iterator<String> splitFixLengthToIterator(int length, String string) {
        return Splitter.fixedLength(length).split(string).iterator();
    }

    /**
     * 与splitFixLengthToIterator类似
     *
     * @param length 被分割后的单个字符最大长度
     * @param string 原字符串
     * @return list
     */
    public static List<String> splitFixLengthToList(int length, String string) {
        return Splitter.fixedLength(length).splitToList(string);
    }

    /**
     * 与splitFixLengthToIterator类似
     *
     * @param length 被分割后的单个字符最大长度
     * @param string 原字符串
     * @return stream
     */
    public static Stream<String> splitFixLengthToStream(int length, String string) {
        return Splitter.fixedLength(length).splitToStream(string);
    }

    /**
     * 把key、value格式的字符串分割成map
     * <p>
     * boy:tom,girl:tina,cat:kitty,dog:tommy -> {boy=tom, girl=tina, cat=kitty, dog=tommy}
     *
     * @param separator1 map分组
     * @param separator2 key分组
     * @param string     原字符串
     * @return map
     */
    public static Map<String, String> splitToMap(String separator1, String separator2, String string) {
        return Splitter.on(separator1)
                .withKeyValueSeparator(separator2)
                .split(string);
    }

    /**
     * 用分隔符拼接被分割的集合
     * <p>
     * separator: '-'
     * parts: Arrays.asList(1, 2, 3)
     * 结果: "1-2-3"
     *
     * @param separator 分隔符
     * @param parts     待分割的集合
     * @return string
     */
    public static String join(char separator, Iterable<Integer> parts) {
        Joiner onChar = Joiner.on(separator);
        return onChar.join(parts);
    }

    /**
     * 用分隔符拼接被分割的集合，跳过null值
     * <p>
     * separator: '-'
     * parts: Arrays.asList(1, null, 2)
     * 结果: "1-2"
     *
     * @param separator 分隔符
     * @param parts     待分割的集合
     * @return string
     */
    public static String joinSkipNulls(char separator, Iterable<Integer> parts) {
        Joiner onChar = Joiner.on(separator);
        return onChar.skipNulls().join(parts);
    }

    /**
     * 用分隔符拼接被分割的集合，把null值替换成nullText
     * <p>
     * separator: '-'
     * parts: Arrays.asList(1, null, 2)
     * nullText: "0"
     * 结果: "1-0-2"
     *
     * @param separator 分隔符
     * @param parts     待分割的集合
     * @return string
     */
    public static String joinSkipUseForNulls(char separator, Iterable<Integer> parts, String nullText) {
        Joiner onChar = Joiner.on(separator);
        return onChar.useForNull(nullText).join(parts);
    }

    /**
     * 把map中的key、value按照分隔符拼接成字符串
     * <p>
     * map: {boy=tom, girl=tina, cat=kitty, dog=tommy}
     * separator1: ","
     * separator2: ":"
     * 结果: boy:tom,girl:tina,cat:kitty,dog:tommy
     *
     * @param map        map
     * @param separator1 分割每个key
     * @param separator2 分割key和value
     * @return string
     */
    public static String mapJoinSeparatorToString(Map<String, String> map, String separator1, String separator2) {
        return Joiner.on(separator1).withKeyValueSeparator(separator2).join(map);
    }

    /**
     * 提取给定字符串中只包含startInclusive到endInclusive范围的内容
     * <p>
     * string: "aosijs2938av"
     * startInclusive: 'a'
     * endInclusive: 'z'
     * 结果 aosijsav
     *
     * @param string         原字符串
     * @param startInclusive 开始范围
     * @param endInclusive   结束范围
     * @return string
     */
    public static String retainFrom(String string, final char startInclusive, final char endInclusive) {
        return CharMatcher.inRange(startInclusive, endInclusive).retainFrom(string);
    }

    /**
     * 删除给定字符串中只startInclusive到endInclusive范围的内容
     * <p>
     * string: "aosijs2938av"
     * startInclusive: 'a'
     * endInclusive: 'z'
     * 结果 2938
     *
     * @param string         原字符串
     * @param startInclusive 开始范围
     * @param endInclusive   结束范围
     * @return string
     */
    public static String removeFrom(String string, final char startInclusive, final char endInclusive) {
        return CharMatcher.inRange(startInclusive, endInclusive).removeFrom(string);
    }

    /**
     * 在string中把isChar移除
     * <p>
     * string: "aosijs2938av"
     * isChar: 'a'
     * 结果: "osijs2938v"
     *
     * @param string 原字符串
     * @param isChar 要删除的字符
     * @return string
     */
    public static String removeIsChar(String string, char isChar) {
        return CharMatcher.is(isChar).removeFrom(string);
    }

    /**
     * 在string中把除了isNotChar的移除
     * <p>
     * string: "aosijs2938av"
     * isNotChar: 'a'
     * 结果: "aa"
     *
     * @param string    原字符串
     * @param isNotChar 要保留的字符
     * @return string
     */
    public static String removeIsNotChar(String string, char isNotChar) {
        return CharMatcher.isNot(isNotChar).removeFrom(string);
    }

    /**
     * 在string中把anyStr移除
     * <p>
     * string: "aosijs2938av"
     * anyStr: 'a8'
     * 结果: "osijs293v"
     *
     * @param string 原字符串
     * @param anyStr 要删除的字符串，不是全值匹配
     * @return string
     */
    public static String removeAnyChar(String string, String anyStr) {
        return CharMatcher.anyOf(anyStr).removeFrom(string);
    }

    /**
     * 在string中把除了notAnyStr的移除
     * <p>
     * string: "aosijs2938av"
     * notAnyStr: 'a8'
     * 结果: "a8a"
     *
     * @param string    原字符串
     * @param notAnyStr 要保留的字符串，不是全值匹配
     * @return string
     */
    public static String removeNotAnyChar(String string, String notAnyStr) {
        return CharMatcher.noneOf(notAnyStr).removeFrom(string);
    }

    /**
     * 下划线格式转驼峰
     * nick_name -> nickName
     *
     * @param string 原字符串
     * @return string
     */
    public static String underscoreToCamel(String string) {
        return CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, string);
    }

    /**
     * 驼峰格式转下划线
     * nickName -> nick_name
     *
     * @param string 原字符串
     * @return string
     */
    public static String camelToUnderscore(String string) {
        return CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, string);
    }
}

码拉松

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
0
评论
【Java常用工具类】字符串

文章目录方法解释1、nullToEmpty(String string)，把null转换成空字符串，如果不是null则不变2、padStart(String string, int minLength, char padChar)，在目标字符串前拼接指定内容3、padEnd(String string, int minLength, char padChar)，在目标字符串后拼接指定内容4、repeat(String str, int count)，重复拼接str内容count次5、commonPrefix
复制链接

扫一扫