第十七篇：汇总，删除String中的指定字符的11种方法

祖母绿宝石

已于 2022-11-30 21:04:41 修改

阅读量2.8w

点赞数 3

分类专栏： JavaSE 文章标签： java 算法数据结构

于 2020-10-10 21:29:18 首次发布

本文链接：https://blog.csdn.net/qq_36963950/article/details/107380223

版权

JavaSE 专栏收录该内容

66 篇文章 0 订阅

订阅专栏

文章目录

方法一

第一种方法 – 通过循环从前往后遍历，如果不是要删除的字符则加到处理后的字符串中，代码如下：

public String deleteCharString0(String sourceString, char chElemData) {
    String resultString = "";
    for (int i = 0; i < sourceString.length(); i++) {
        if (sourceString.charAt(i) != chElemData) {
            resultString += sourceString.charAt(i);
        }
    }
    return resultString;
}

金手指小结：sourceString.charAt(i) 遍历查找，resultString做 += 拼接操作，一共拼接sourceString.length-1次，sourceString.charAt()来拼接。

优点：只是使用 string.charAt() 遍历；

缺点：对string做 += 拼接操作，因为string是final修饰的不可变对象，所以要做n次字符串拼接，效率很低。

方法二

第二种方法 — 通过循环确定要删除字符的位置索引，然后通过分割字符串的形式，将子字符串拼接，注意最后一段子字符串和源字符串中没有要删除字符的情况，代码如下：

    public String deleteCharString1(String sourceString, char chElemData) {
        String resultString = "";
        int iIndex = 0;
        for (int i = 0; i < sourceString.length(); i++) {
            if (sourceString.charAt(i) == chElemData) {
                if (i > 0) {
                    resultString += sourceString.substring(iIndex, i);   // string类型 += ，这是字符串拼接操作
                }
                iIndex = i + 1;
            }
        }
        if (iIndex <= sourceString.length()) {
            resultString += sourceString.substring(iIndex, sourceString.length());
        }
        return resultString;
    }

金手指小结：sourceString.charAt(i) 遍历查找，resultString做 += 拼接操作，拼接次数较方法1少，sourceString.substring来拼接。

方法三

第三种方法 — 原理同上，只不过查找要删除字符位置采用String类中的函数执行，效率不如上面的高，代码如下：

    public String deleteCharString2(String sourceString, char chElemData) {
        String resultString = "";
        int iIndex = 0;
        int tmpCount = 0;
        do {
            tmpCount = sourceString.indexOf(chElemData, iIndex);   // indexof定位到要删除的元素，
            // 然后使用substring拼接，因为要删除的元素chElement可能在sourceString字符串中存在多个，所以要使用dowhile循环
            if (tmpCount > 0) {
                resultString += sourceString.substring(iIndex, tmpCount);
            }
            if (tmpCount != -1) {
                iIndex = tmpCount + 1;
            }
        } while (tmpCount != -1);
        if (iIndex <= sourceString.length()) {
            resultString += sourceString.substring(iIndex, sourceString.length());
        }
        return resultString;
    }

金手指小结：indexof定位到要删除的元素，然后使用substring拼接，因为要删除的元素chElement可能在sourceString字符串中存在多个，所以要使用do…while循环。

方法四

第四种方法 — 原理与上方基本一致，只不过这次采用倒序方式，这里的坑就更多了，一定要注意索引的取值范围和是否合法，代码如下：

public String deleteCharString3(String sourceString, char chElemData) {
    String deleteString = "";
    int iIndex = sourceString.length();
    int tmpCount = 0;
    do {
        tmpCount = sourceString.lastIndexOf(chElemData, iIndex - 1);
        if (tmpCount < sourceString.length() && tmpCount >= 0) {
            deleteString = sourceString.substring(tmpCount + 1, iIndex) + deleteString;
        }
        if (tmpCount != -1) {
            iIndex = tmpCount;
        }
    } while (tmpCount != -1);
    if (iIndex >= 0) {
        deleteString = sourceString.substring(0, iIndex) + deleteString;
    }

    return deleteString;
}

金手指小结：lastIndexOf定位到要删除的元素，然后使用substring拼接，因为要删除的元素chElement可能在sourceString字符串中存在多个，所以要使用dowhile循环。

方法五

第五种方法 — 通过采用正则的方式和replaceAll函数，本种方法要注意特殊字符，例如正则中的 “.”字符，需要对特殊字符进行转义，代码如下：

public String deleteCharString4(String sourceString, char chElemData) {
    String deleteString = "";
    final String strTable = "|^$*+?.(){}\\";
    String tmpRegex = "["; 
    for (int i = 0; i < strTable.length(); i++) {
        if (strTable.charAt(i) == chElemData) {
            tmpRegex += "\\";
            break;
        }
    }
    tmpRegex += chElemData + "]";
    deleteString = sourceString.replaceAll(tmpRegex, "");
    return deleteString;
}

方法六

第六种方法 — 采用正则的方式将字符串分割成几个子字符串，再将子字符串进行拼接，代码如下：

public String deleteCharString5(String sourceString, char chElemData) {
    String deleteString = "";
    final String strTable = "|^$*+?.(){}\\";
    String tmpRegex = "["; 
    for (int i = 0; i < strTable.length(); i++) {
        if (strTable.charAt(i) == chElemData) {
            tmpRegex += "\\";
            break;
        }
    }
    tmpRegex += chElemData + "]";
    String[] tmpStringArray = sourceString.split(tmpRegex);
    for (int i = 0; i < tmpStringArray.length; i++) {
        deleteString += tmpStringArray[i];
    }
    return deleteString;
}

金手指小结：

第一，返回结果还是String，所以还是要拼接得到结果；

第二，遍历查找过程，因为sourceString变成char数组,使用==比较,循环sourceString.length次。

方法七

第七种方法 — 将字符编程可读序列，在通过 String 类中的方法替换，代码如下：

public String deleteCharString6(String sourceString, char chElemData) {
    String tmpString = "";
    tmpString += chElemData;
    tmpString.subSequence(0, 0);
    String deleteString = "";
    deleteString = sourceString.replace(tmpString, deleteString.subSequence(0, 0));
    return deleteString;
}

方法八

第八种方法 — 把原字符串转化为字符数组，然后原理与直接插入排序原理类似，代码如下：

public String deleteCharString7(String sourceString, char chElemData) {
    String deleteString = "";
    char[] Bytes = sourceString.toCharArray();   // sourceString变为char[]数组
    int iSize = Bytes.length;    // 记录大小size
    for (int i = Bytes.length - 1; i >= 0; i--) {
        if (Bytes[i] == chElemData) {
            for (int j = i; j < iSize - 1; j++) {
                Bytes[j] = Bytes[j + 1];
            }
            iSize--;
        }
    }
    for (int i = 0; i < iSize; i++) {
        deleteString += Bytes[i];     // 还是拼接
    }
    return deleteString;
}

金手指小结：

第一，返回结果还是String，所以还是要拼接得到结果；

第二，遍历查找过程，因为sourceString变成char数组,使用==比较,循环sourceString.length次。

方法九

第九种方法 — 原理与第一种方法类似，本次采用 stringBuffer 类中的 append 方法进行操作，但是效率应该高于第一种。

public String deleteCharString8(String sourceString, char chElemData) {
    StringBuffer stringBuffer = new StringBuffer("");
    for (int i = 0; i < sourceString.length(); i++) {
        if (sourceString.charAt(i) != chElemData) {
            stringBuffer.append(sourceString.charAt(i));
        }
    }
    return stringBuffer.toString();
}

金手指小结：

第一，初始字符串就是返回结果，之前都是return string对象，所以需要字符串拼接，现在return stringbuffer，最后stringbuffer.toString；

第二，遍历查找过程，因为sourceString是String，只能使用charAt(i),循环sourceString.length次；

第三，得到返回结果的操作，找到要删除的，使用stringbuffer代替string操作，使用stringbuffer的append()，保证删除操作不会因为字符串拼接而底层生成新字符串。

优点：在第一步，返回结果变成了stringbuffer，因为第一步，所以第三步stringbuffer.append代替了字符串拼接；

缺陷：第二点，因为sourceString是String，只能使用charAt(i)，仍然循环sourceString.length次。

方法十

第十种方法 — 采用 stringBuffer 类中的 replace and indexOf 方法（^_ 故意凑方法），代码如下：

public String deleteCharString9(String sourceString, char chElemData) {
    String tmpString = "";
    tmpString += chElemData;
    StringBuffer stringBuffer = new StringBuffer(sourceString);
    int iFlag = -1;
    do {
        iFlag = stringBuffer.indexOf(tmpString);
        if (iFlag != -1) {
            stringBuffer = stringBuffer.replace(iFlag, iFlag + 1, "");
        }
    } while (iFlag != -1);
    return stringBuffer.toString();
}

金手指小结：

第一，初始字符串就是返回结果，之前都是return string对象，所以需要字符串拼接，现在return stringbuffer,最后stringbuffer.toString；

第二，遍历查找过程，先用sourceString初始化stringbuffer,stringbuffer保证线程安全,使用indexof代替无脑charAt(),减少循环次数；

第三，得到返回结果的操作，找到要删除的，使用stringbuffer代替string操作，使用stringbuffer的replace()将指定位置char变为空字符串，保证删除操作不会因为字符串拼接而底层生成新字符串。

方法十一

第十一种方法 — 采用 stringBuffer 类中的 deleteCharAt 和 indexOf 直接删除

public String deleteCharString10(String sourceString, char chElemData) {
    String tmpString = "";
    tmpString += chElemData;
    StringBuffer stringBuffer = new StringBuffer(sourceString);
    int iFlag = -1;
    do {
        iFlag = stringBuffer.indexOf(tmpString);
        if (iFlag != -1) {
            stringBuffer.deleteCharAt(iFlag);
        }
    } while (iFlag != -1);
    return stringBuffer.toString();
}

金手指小结：

第一，之前都是return string对象，所以需要字符串拼接，现在return stringbuffer,最后stringbuffer.toString；

第二，先用sourceString初始化stringbuffer,stringbuffer保证线程安全,使用indexof代替无脑charAt(),减少循环次数；

第三，找到要删除的，使用stringbuffer代替string操作，使用stringbuffer的deleteCharAt()保证删除操作不会因为字符串拼接而底层生成新字符串。

尾声

效率最高的是方法十和方法十一，都满足参数为sourceString和deleteChar，返回值为resultString。回顾一下：

方法十：

第一，初始字符串就是返回结果，之前都是return string对象，所以需要字符串拼接，现在return stringbuffer,最后stringbuffer.toString；

第二，遍历查找过程，先用sourceString初始化stringbuffer,stringbuffer保证线程安全,使用indexof代替无脑charAt(),减少循环次数；

方法十一：

第一，之前都是return string对象，所以需要字符串拼接，现在return stringbuffer,最后stringbuffer.toString；

第二，先用sourceString初始化stringbuffer,stringbuffer保证线程安全,使用indexof代替无脑charAt(),减少循环次数；

第三，找到要删除的，使用stringbuffer代替string操作，使用stringbuffer的deleteCharAt()保证删除操作不会因为字符串拼接而底层生成新字符串。

祖母绿宝石

关注

3
点赞
踩
34

收藏

觉得还不错? 一键收藏
打赏
1
评论
第十七篇：汇总，删除String中的指定字符的11种方法

JAVA - String 中删除指定字符（11种方法）第一种方法 – 通过循环从前往后遍历，如果不是要删除的字符则加到处理后的字符串中，代码如下：public String deleteCharString0(String sourceString, char chElemData) { String deleteString = ""; for (int i = 0; i < sourceString.length(); i++) { if (sourceStr
复制链接

扫一扫