其实不用重复造轮子[StringUtils][002]

最新推荐文章于 2023-12-14 08:51:48 发布
最新推荐文章于 2023-12-14 08:51:48 发布
阅读量171 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Utils 文章标签： C C++ C# performance
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ittor/article/details/83761341
本文介绍了一系列实用的字符串操作方法，包括子串提取、字符截取、拆分等常见需求的高效实现方式，帮助开发者提高编程效率。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、Substring

1.包含空指针异常处理的subString，开始

    public static String substring(String str, int start) {
        if (str == null) {
            return null;
        }

        // handle negatives, which means last n characters
        if (start < 0) {
            start = str.length() + start; // remember start is negative
        }

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

        return str.substring(start);
    }

 

2.包含空指针异常处理的SubString，开始，结束

    public static String substring(String str, int start, int end) {
        if (str == null) {
            return null;
        }

        // handle negatives
        if (end < 0) {
            end = str.length() + end; // remember end is negative
        }
        if (start < 0) {
            start = str.length() + start; // remember start is negative
        }

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

        // if start is greater than end, return ""
        if (start > end) {
            return EMPTY;
        }

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

        return str.substring(start, end);
    }
 

二、字符截取（Left/Right/Mid）

1.截取左边len个字符

    public static String left(String str, int len) {
        if (str == null) {
            return null;
        }
        if (len < 0) {
            return EMPTY;
        }
        if (str.length() <= len) {
            return str;
        }
        return str.substring(0, len);
    }

 

2.截取右边len个字符

    public static String right(String str, int len) {
        if (str == null) {
            return null;
        }
        if (len < 0) {
            return EMPTY;
        }
        if (str.length() <= len) {
            return str;
        }
        return str.substring(str.length() - len);
    }
 

3.截取中间len个字符

    public static String mid(String str, int pos, int len) {
        if (str == null) {
            return null;
        }
        if (len < 0 || pos > str.length()) {
            return EMPTY;
        }
        if (pos < 0) {
            pos = 0;
        }
        if (str.length() <= (pos + len)) {
            return str.substring(pos);
        }
        return str.substring(pos, pos + len);
    }
 

三、字符截取（SubStringAfter/SubStringBefore）

1.指定字符串之前的字符

    public static String substringBefore(String str, String separator) {
        if (isEmpty(str) || separator == null) {
            return str;
        }
        if (separator.length() == 0) {
            return EMPTY;
        }
        int pos = str.indexOf(separator);
        if (pos == -1) {
            return str;
        }
        return str.substring(0, pos);
    }
 

2.指定字符串之后的字符

    public static String substringAfter(String str, String separator) {
        if (isEmpty(str)) {
            return str;
        }
        if (separator == null) {
            return EMPTY;
        }
        int pos = str.indexOf(separator);
        if (pos == -1) {
            return EMPTY;
        }
        return str.substring(pos + separator.length());
    }

 

3.倒数。指定字符串之前的字符

    public static String substringBeforeLast(String str, String separator) {
        if (isEmpty(str) || isEmpty(separator)) {
            return str;
        }
        int pos = str.lastIndexOf(separator);
        if (pos == -1) {
            return str;
        }
        return str.substring(0, pos);
    }
 

4.倒数。指定在字符串之后的字符

    public static String substringAfterLast(String str, String separator) {
        if (isEmpty(str)) {
            return str;
        }
        if (isEmpty(separator)) {
            return EMPTY;
        }
        int pos = str.lastIndexOf(separator);
        if (pos == -1 || pos == (str.length() - separator.length())) {
            return EMPTY;
        }
        return str.substring(pos + separator.length());
    }
 

四、子字符串（Substring between）

1. 在某指定字符串中的子字符串

    public static String substringBetween(String str, String tag) {
        return substringBetween(str, tag, tag);
    }
 

2.在某两个指定字符串中间的子字符串，只返回第一个有效值

    public static String substringBetween(String str, String open, String close) {
        if (str == null || open == null || close == null) {
            return null;
        }
        int start = str.indexOf(open);
        if (start != -1) {
            int end = str.indexOf(close, start + open.length());
            if (end != -1) {
                return str.substring(start + open.length(), end);
            }
        }
        return null;
    }
 

3. 在某两个指定字符串之间的子字符串，以数组形式返回所有有效值

    public static String[] substringsBetween(String str, String open, String close) {
        if (str == null || isEmpty(open) || isEmpty(close)) {
            return null;
        }
        int strLen = str.length();
        if (strLen == 0) {
            return ArrayUtils.EMPTY_STRING_ARRAY;
        }
        int closeLen = close.length();
        int openLen = open.length();
        List list = new ArrayList();
        int pos = 0;
        while (pos < (strLen - closeLen)) {
            int start = str.indexOf(open, pos);
            if (start < 0) {
                break;
            }
            start += openLen;
            int end = str.indexOf(close, start);
            if (end < 0) {
                break;
            }
            list.add(str.substring(start, end));
            pos = end + closeLen;
        }
        if (list.isEmpty()) {
            return null;
        } 
        return (String[]) list.toArray(new String [list.size()]);
    }
 

五、拆分（Splitting）

1.将包含空白字符的字符串拆分成一个数组，以空白字符作为分隔符条件

    public static String[] split(String str) {
        return split(str, null, -1);
    }
 

2.将字符串中按照指定字符作为分隔符，拆分成一个数组

    public static String[] split(String str, char separatorChar) {
        return splitWorker(str, separatorChar, false);
    }
  
    public static String[] split(String str, String separatorChars) {
        return splitWorker(str, separatorChars, -1, false);
    }
 

3.将字符串拆分成指定max大小的数组

    public static String[] split(String str, String separatorChars, int max) {
        return splitWorker(str, separatorChars, max, false);
    }
 

4.将字符串按照指定字符串拆分成数据

    public static String[] splitByWholeSeparator(String str, String separator) {
        return splitByWholeSeparatorWorker( str, separator, -1, false ) ;
    }
  
    public static String[] splitByWholeSeparator( String str, String separator, int max ) {
        return splitByWholeSeparatorWorker(str, separator, max, false);
    }
 

5.将字符串按照指定字符串拆分成数组，如果含有多个separator，则separtor也会作为数组值返回

    public static String[] splitByWholeSeparatorPreserveAllTokens(String str, String separator) {
        return splitByWholeSeparatorWorker(str, separator, -1, true);
    }
  
    public static String[] splitByWholeSeparatorPreserveAllTokens(String str, String separator, int max) {
        return splitByWholeSeparatorWorker(str, separator, max, true);
    }
 

拆分

    private static String[] splitByWholeSeparatorWorker(String str, String separator, int max, 
                                                        boolean preserveAllTokens) 
    {
        if (str == null) {
            return null;
        }

        int len = str.length();

        if (len == 0) {
            return ArrayUtils.EMPTY_STRING_ARRAY;
        }

        if ((separator == null) || (EMPTY.equals(separator))) {
            // Split on whitespace.
            return splitWorker(str, null, max, preserveAllTokens);
        }

        int separatorLength = separator.length();

        ArrayList substrings = new ArrayList();
        int numberOfSubstrings = 0;
        int beg = 0;
        int end = 0;
        while (end < len) {
            end = str.indexOf(separator, beg);

            if (end > -1) {
                if (end > beg) {
                    numberOfSubstrings += 1;

                    if (numberOfSubstrings == max) {
                        end = len;
                        substrings.add(str.substring(beg));
                    } else {
                        // The following is OK, because String.substring( beg, end ) excludes
                        // the character at the position 'end'.
                        substrings.add(str.substring(beg, end));

                        // Set the starting point for the next search.
                        // The following is equivalent to beg = end + (separatorLength - 1) + 1,
                        // which is the right calculation:
                        beg = end + separatorLength;
                    }
                } else {
                    // We found a consecutive occurrence of the separator, so skip it.
                    if (preserveAllTokens) {
                        numberOfSubstrings += 1;
                        if (numberOfSubstrings == max) {
                            end = len;
                            substrings.add(str.substring(beg));
                        } else {
                            substrings.add(EMPTY);
                        }
                    }
                    beg = end + separatorLength;
                }
            } else {
                // String.substring( beg ) goes from 'beg' to the end of the String.
                substrings.add(str.substring(beg));
                end = len;
            }
        }

        return (String[]) substrings.toArray(new String[substrings.size()]);
    }
 

6.返回包含separator的数组

    public static String[] splitPreserveAllTokens(String str) {
        return splitWorker(str, null, -1, true);
    }
  
    public static String[] splitPreserveAllTokens(String str, char separatorChar) {
        return splitWorker(str, separatorChar, true);
    }

 

拆分

    private static String[] splitWorker(String str, char separatorChar, boolean preserveAllTokens) {
        // Performance tuned for 2.0 (JDK1.4)

        if (str == null) {
            return null;
        }
        int len = str.length();
        if (len == 0) {
            return ArrayUtils.EMPTY_STRING_ARRAY;
        }
        List list = new ArrayList();
        int i = 0, start = 0;
        boolean match = false;
        boolean lastMatch = false;
        while (i < len) {
            if (str.charAt(i) == separatorChar) {
                if (match || preserveAllTokens) {
                    list.add(str.substring(start, i));
                    match = false;
                    lastMatch = true;
                }
                start = ++i;
                continue;
            }
            lastMatch = false;
            match = true;
            i++;
        }
        if (match || (preserveAllTokens && lastMatch)) {
            list.add(str.substring(start, i));
        }
        return (String[]) list.toArray(new String[list.size()]);
    }

 

7.拆分为数组（StringUtils.splitPreserveAllTokens("ab::cd:ef", ":")  = ["ab", "", cd", "ef"]）

    public static String[] splitPreserveAllTokens(String str, String separatorChars) {
        return splitWorker(str, separatorChars, -1, true);
    }
  
    public static String[] splitPreserveAllTokens(String str, String separatorChars, int max) {
        return splitWorker(str, separatorChars, max, true);
    }
  
    private static String[] splitWorker(String str, String separatorChars, int max, boolean preserveAllTokens) {
        // Performance tuned for 2.0 (JDK1.4)
        // Direct code is quicker than StringTokenizer.
        // Also, StringTokenizer uses isSpace() not isWhitespace()

        if (str == null) {
            return null;
        }
        int len = str.length();
        if (len == 0) {
            return ArrayUtils.EMPTY_STRING_ARRAY;
        }
        List list = new ArrayList();
        int sizePlus1 = 1;
        int i = 0, start = 0;
        boolean match = false;
        boolean lastMatch = false;
        if (separatorChars == null) {
            // Null separator means use whitespace
            while (i < len) {
                if (Character.isWhitespace(str.charAt(i))) {
                    if (match || preserveAllTokens) {
                        lastMatch = true;
                        if (sizePlus1++ == max) {
                            i = len;
                            lastMatch = false;
                        }
                        list.add(str.substring(start, i));
                        match = false;
                    }
                    start = ++i;
                    continue;
                }
                lastMatch = false;
                match = true;
                i++;
            }
        } else if (separatorChars.length() == 1) {
            // Optimise 1 character case
            char sep = separatorChars.charAt(0);
            while (i < len) {
                if (str.charAt(i) == sep) {
                    if (match || preserveAllTokens) {
                        lastMatch = true;
                        if (sizePlus1++ == max) {
                            i = len;
                            lastMatch = false;
                        }
                        list.add(str.substring(start, i));
                        match = false;
                    }
                    start = ++i;
                    continue;
                }
                lastMatch = false;
                match = true;
                i++;
            }
        } else {
            // standard case
            while (i < len) {
                if (separatorChars.indexOf(str.charAt(i)) >= 0) {
                    if (match || preserveAllTokens) {
                        lastMatch = true;
                        if (sizePlus1++ == max) {
                            i = len;
                            lastMatch = false;
                        }
                        list.add(str.substring(start, i));
                        match = false;
                    }
                    start = ++i;
                    continue;
                }
                lastMatch = false;
                match = true;
                i++;
            }
        }
        if (match || (preserveAllTokens && lastMatch)) {
            list.add(str.substring(start, i));
        }
        return (String[]) list.toArray(new String[list.size()]);
    }

 

7.根据字符类型进行拆分（StringUtils.splitByCharacterType("foo200Bar")  = ["foo", "200", "B", "ar"]）

    public static String[] splitByCharacterType(String str) {
        return splitByCharacterType(str, false);
    }

 8.根据字符类型进行拆分，不区分大小写（StringUtils.splitByCharacterTypeCamelCase("foo200Bar")  = ["foo", "200", "Bar"]；StringUtils.splitByCharacterTypeCamelCase("ASFRules")   = ["ASF", "Rules"]）

    public static String[] splitByCharacterTypeCamelCase(String str) {
        return splitByCharacterType(str, true);
    }
  
    private static String[] splitByCharacterType(String str, boolean camelCase) {
        if (str == null) {
            return null;
        }
        if (str.length() == 0) {
            return ArrayUtils.EMPTY_STRING_ARRAY;
        }
        char[] c = str.toCharArray();
        List list = new ArrayList();
        int tokenStart = 0;
        int currentType = Character.getType(c[tokenStart]);
        for (int pos = tokenStart + 1; pos < c.length; pos++) {
            int type = Character.getType(c[pos]);
            if (type == currentType) {
                continue;
            }
            if (camelCase && type == Character.LOWERCASE_LETTER && currentType == Character.UPPERCASE_LETTER) {
                int newTokenStart = pos - 1;
                if (newTokenStart != tokenStart) {
                    list.add(new String(c, tokenStart, newTokenStart - tokenStart));
                    tokenStart = newTokenStart;
                }
            } else {
                list.add(new String(c, tokenStart, pos - tokenStart));
                tokenStart = pos;
            }
            currentType = type;
        }
        list.add(new String(c, tokenStart, c.length - tokenStart));
        return (String[]) list.toArray(new String[list.size()]);
    }
 

 

 

 

 

【微服务】springboot 适配多数据源设计与实现
congge
07-04 7091
springboot多数据源配置详解
Spring Boot 自动配置原理解析！
最新发布
**My Coding Family**
06-05 1033
🏆本文收录于「滚雪球学SpringBoot」专栏，手把手带你零基础入门Spring Boot，从入门到就业，助你早日登顶实现财富自由🚀；同时，欢迎大家关注&&收藏&&订阅！持续更新中，up！up！up！！
程序员必须遵守的6个编程原则，不要重复造轮子！
shopju的博客
04-22 2842
对于程序员而言，遵守编程原则能够显著提高编程能力。 同时，也能开发出BUG更少，更完美的程序。 下面w3cschool就来分享程序员必须知道的6个编程原则： 0、避免过早优化 过早优化是一切罪恶的根源”—Donald Knuth。 如果你没有弄清楚未来变化的走向而去优化，实际上让代码变得复杂外，到头来是竹篮打水一场空。 因为优化可能无法很好实现新的需求，对于优化预期的猜测也有可能是...
在开发中如何才能避免重复造轮子和GET新技能
钢笔布莱恩特的博客
04-18 4192
Google，GitHub，StackOverflow1.不是所有的程序员都不重复造轮子的：有些程序员就是喜欢自己造轮子。高手和菜鸟是不是都适宜这种想法姑且不论。但很多C++团队都喜欢自己写自己的字符串策略，自己的内存分配策略，抱有坚决不用STL的态度，可以说是现在很多遗留的C++项目看起来好像另一种语言写的一样的一个主要原因。之前某大牛还在微博上抱怨过，为什么公司那么喜欢重复造轮，否则他第一天就可
string.substring()的使用注意事项
JinKin_OldWang的博客
06-29 5091
在java开发中，难免会用到string.substring()方法，往往会在开发的过程中忽略其的一些潜在异常处理。 下面来分享一下我遇到的总结而来的注意事项。 string.substring(int beginIndex, int endIndex) 先上源码： public String substring(int beginIndex, int endIndex) { ...
在一大段字符串中截取需要的额字符串方法：StringUtils.substringBetween（）
BD_fuhong的博客
06-14 6732
import org.apache.commons.lang.StringUtils; import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegularExpression { public static void main(String[] args) { //1、...
Java中空指针异常及其处理
Anur IjuoKaruKas的博客
03-19 8185
在Java中，null值可以被分配给一个对象的引用，表示该对象当前正在指向未知的数据。当程序试图访问这个引用时，将会抛出 NullPointerException。 那么如何避免程序抛出空指针异常？ 1、避免去调用可能为null的对象的方法（静态方法除外） String str = null; if(str.equals("Test")) { /* The code ...
【微服务】springboot 通用限流方案设计与实现
congge
06-24 9469
springboot限流方案总结
Redis核心知识点深度剖析：原理、机制与应用
禅与计算机程序设计的艺术
12-14 1724
C语言的字符串用\0收尾，在redis的使用场景下，很可能因为这个结束符导致数据被截断。C语言字符串获取长度需要进行遍历，即O(n)级别的时间复杂度。C语言进行字符串拼接总是需要预先做好分配，否则很容易出现缓冲区溢出的问题。对于不断扩大的字符串还需要反复创建新的字符数组解决问题。用于表示地理坐标信息，从而实现经纬度数据检索，它主要支持的命令有：Redis 的 GEO 模块提供了一系列用于处理地理位置数据的命令。
使用这45个小技巧，帮助你写出更优雅的代码
Java_LingFeng的博客
10-25 1002
不知道大家有没有经历过维护一个已经离职的人的代码的痛苦，一个方法写老长，还有很多的if else ，根本无法阅读，更不知道代码背后的含义，最重要的是没有人可以问，此时只能心里默默地问候这个留坑的兄弟。。
判断null、string、使用注意substring使用
weixin_34112181的博客
08-13 1631
2019独角兽企业重金招聘Python工程师标准>>> ...
substring()方法的异常处理问题
dancer
08-01 6092
JDK中的源码如上. 我们在这里定义一个字符串: String str = "abc"; 我们对其进行分割. str.substring(3, 3); 你会发现没有报错.按理说这个应该是越界异常...... 因为3已经越界,下表是取不到这个位置的. .....我就想表达这个意思,其他的没有了...
Java8_StringUtils常用方法
HYN205的博客
04-01 1215
org.apache.commons.lang.StringUtils Operations onStringthat arenullsafe.字符串是null安全的，不会抛出NullPointerException，都做了相应的处理。 判空：IsEmpty/IsBlank：checks if a String contains text - 检查字符串是否有内容 Trim/Stri...
cas shiro 前后端分离 登录_前后端分离如何做SSO单点登录？
weixin_29817791的博客
12-15 567
在前面的文章中单点登录系统SSO是如何实现的？我们实现了一个简单的单点登录，但是那里面有几个问题：一个是全局的token是在url中明文传递的，如果把这个url分享出去，任何人都可以使用这个token，还一个问题，现在的很多系统都是前后端分离的，我们之前介绍的还是传统的服务端渲染方式。本文就来看下如何解决这两个问题。实现的思路跟之前基本上差不多，我们这次画一个图来看一下：（1）用户在http://...
org.springframework.util包中的StringUtils.split方法只分割一次，并且找不到分隔符会报错
weixin_44371237的博客
05-14 976
String ids ="11453","11435","11433" String[] ids = StringUtils.split(chkId, ","); for (String id:ids) { log.info(id.toString()); } 结果： 11453 11435,11433 这是个坑，只分割一次，造成实际数组取值错误
StringUtils类API及使用方法详解
caidaqin001的专栏
08-20 966
依赖包： <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 --> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-lang3</artifactId> <version>3.11</version>...
stringutils
03-21
### StringUtils 类的功能概述 `StringUtils` 是 Apache Commons Library 中的一部分，属于 `org.apache.commons.lang3` 包下的工具类[^2]。该类主要用于简化字符串操作，提供了许多静态方法来处理常见的字符串问题。这些方法能够帮助开发者更高效地完成字符串的判断、转换和格式化等工作。 以下是 `StringUtils` 的主要功能分类及其描述： #### 1. 字符串判空 `StringUtils` 提供了一系列用于检测字符串是否为空或者仅包含空白字符的方法。例如： - `isEmpty(String str)`：如果字符串为 null 或长度为零，则返回 true。 - `isNotEmpty(String str)`：与 isEmpty 方法相反，当字符串不为空时返回 true。 - `isBlank(String str)`：如果字符串为 null 或者只包含空白字符（如空格），则返回 true。 - `isNotBlank(String str)`：与 isBlank 方法相反，当字符串既不是 null 又含有非空白字符时返回 true。 ```java System.out.println(StringUtils.isEmpty(null)); // 输出: true System.out.println(StringUtils.isBlank("")); // 输出: true System.out.println(StringUtils.isNotBlank("abc")); // 输出: true ``` #### 2. 去除多余字符 此类方法可以帮助去除字符串两端或内部多余的空白字符及其他指定字符。 - `trim(String str)`：移除字符串首尾的空白字符。 - `strip(String str, String stripChars)`：删除字符串开头和结尾处由参数定义的一组字符。 - `removeStart(String str, String remove)` 和 `removeEnd(String str, String remove)`：分别去掉字符串前缀或后缀部分匹配的内容。 ```java String result = StringUtils.strip(" Hello World! ", " H!"); // 结果："ello World" ``` #### 3. 大小写转换 通过调用以下函数实现大小写的统一管理。 - `upperCase(String str)` - `lowerCase(String str)` ```java System.out.println(StringUtils.upperCase("hello")); // HELLO System.out.println(StringUtils.lowerCase("WORLD")); // world ``` #### 4. 子串查找与替换 支持灵活定位子序列位置以及批量替换单词等功能。 - `contains(CharSequence seq, CharSequence searchSeq)` - `replaceEachRepeatedly(String text, String[] searchList, String[] replacementList)` ```java boolean foundA = StringUtils.contains("ABCDEF", 'A'); // true String replacedText = StringUtils.replaceEachRepeatedly( "a_b_c_", new String[]{"_"}, new String[]{"/"}); // a/b/c/ ``` #### 5. 随机生成器 利用随机数种子创建固定长度的新密码或者其他形式的数据片段。 - `RandomStringUtils.random(int count)` - `RandomStringUtils.randomAlphabetic(int count)` ```java String randomStr = RandomStringUtils.random(8); System.out.println(randomStr.length()); // 8 ``` --- ### 使用场景举例 假设我们需要开发一款应用程序，在其中验证用户输入邮箱地址的有效性并清理数据。我们可以借助于 `StringUtils` 来快速构建逻辑框架如下所示： ```java public boolean isValidEmail(String email){ if (StringUtils.isBlank(email)) { return false; } String trimmedEmail = StringUtils.trim(email); int atIndex = trimmedEmail.indexOf("@"); ... } ``` 上述代码展示了如何运用 `StringUtils.isBlank()` 判断字段是否存在有效值；再经过去掉冗余空间之后进一步分析结构特性等等。 --- ### 总结 综上所述，Apache Commons Lang 库内的 `StringUtils` 已成为众多 Java 开发人员日常工作中不可或缺的好帮手之一。凭借其丰富的预设算法集合，极大地减少了重复编码量的同时提高了程序可读性和稳定性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值