从字符串中删除所有出现的char

我可以用这个：

String str = "TextX Xto modifyX";
str = str.replace('X','');//that does not work because there is no such character ''

有没有办法X从Java中的字符串中删除所有出现的字符？

我试过了，这不是我想要的： str.replace('X',' '); //replace with space

尝试使用需要CharSequence参数（例如String）而不是的重载char：

str = str.replace("X", "");

使用

public String replaceAll(String regex, String replacement)

将工作。

用法是str.replace("X", "");。

执行中

"Xlakjsdf Xxx".replaceAll("X", "");

返回：

lakjsdf xx

如果您想使用Java字符串做某事，Commons Lang StringUtils是一个不错的选择。

StringUtils.remove("TextX Xto modifyX", 'X');

String test = "09-09-2012";
String arr [] = test.split("-");
String ans = "";

for(String t : arr)
    ans+=t;

这是我从字符串中删除字符的示例。

我喜欢在这种情况下使用RegEx：

str = str.replace(/X/g, '');

g表示全局，因此它将遍历您的整个字符串并将所有X替换为''; 如果要同时替换X和x，则只需说：

str = str.replace(/X|x/g, '');

（在这里查看我的小提琴：小提琴）

您好，请在下面尝试此代码

public class RemoveCharacter {

    public static void main(String[] args){
        String str = "MXy nameX iXs farXazX";
        char x = 'X';
        System.out.println(removeChr(str,x));
    }

    public static String removeChr(String str, char x){
        StringBuilder strBuilder = new StringBuilder();
        char[] rmString = str.toCharArray();
        for(int i=0; i<rmString.length; i++){
            if(rmString[i] == x){

            } else {
                strBuilder.append(rmString[i]);
            }
        }
        return strBuilder.toString();
    }
}

使用replaceAll代替replace

str = str.replaceAll("X,"");

这应该给您想要的答案。

package com.acn.demo.action;

public class RemoveCharFromString {

    static String input = "";
    public static void main(String[] args) {
        input = "abadbbeb34erterb";
        char token = 'b';
        removeChar(token);
    }

    private static void removeChar(char token) {
        // TODO Auto-generated method stub
        System.out.println(input);
        for (int i=0;i<input.length();i++) {
            if (input.charAt(i) == token) {
            input = input.replace(input.charAt(i), ' ');
                System.out.println("MATCH FOUND");
            }
            input = input.replaceAll(" ", "");
            System.out.println(input);
        }
    }
}

这是一个lambda函数，它删除所有作为字符串传递的字符

BiFunction<String,String,String> deleteChars = (fromString, chars) -> {
  StringBuilder buf = new StringBuilder( fromString );
  IntStream.range( 0, buf.length() ).forEach( i -> {
    while( i < buf.length() && chars.indexOf( buf.charAt( i ) ) >= 0 )
      buf.deleteCharAt( i );
  } );
  return( buf.toString() );
};

String str = "TextX XYto modifyZ";
deleteChars.apply( str, "XYZ" ); // –> "Text to modify"

该解决方案考虑到了，与之不同的是replace()，删除字符串时所得的String 永远不会变得大于起始String。因此，它避免了重复分配和追加的同时字符的明智复制StringBuilder的replace()一样。
更不用说不需要删除的Pattern和Matcher实例的无意义生成了replace()。
与replace()此解决方案不同的是，可以一次删除几个字符。

通过性能基准评估主要答案，这证实了人们对当前选择的答案会使引擎盖下正则表达式操作昂贵的担忧

到目前为止，提供的答案有3种主要样式（忽略JavaScript答案;））：

• 使用String.replace（charsToDelete，“”）; 在引擎盖下使用正则表达式
• 使用Lambda
• 使用简单的Java实现

就代码大小而言，显然String.replace是最简洁的。简单的Java实现比Lambda稍微更小，更干净（IMHO）（请不要误解-我经常在合适的地方使用Lambda）

执行速度从快到慢依次为：简单的Java实现，Lambda，然后是String.replace（）（调用regex）。

到目前为止，最快的实现是对简单的Java实现进行了调整，以便它可以将StringBuilder缓冲区预分配为最大可能的结果长度，然后仅将不在“要删除的字符”字符串中的字符追加到缓冲区中。这样可以避免在长度大于16个字符的字符串中发生任何重新分配（StringBuilder的默认分配），并且避免了从Lambda实现中删除字符串副本中的字符而导致的“向左滑动”性能问题。

下面的代码运行一个简单的基准测试，每个实现运行1,000,000次，并记录经过的时间。

每次运行的确切结果会有所不同，但性能的顺序永远不会改变：

Start simple Java implementation
Time: 157 ms
Start Lambda implementation
Time: 253 ms
Start String.replace implementation
Time: 634 ms

Lambda实现（从Kaplan的答案复制而来）可能会更慢，因为它会执行所有字符“左移一位”，将其移到要删除字符的右边。对于较长的带有很多字符需要删除的字符串，这显然会变得更糟。此外，Lambda实现本身可能会有一些开销。

String.replace实现，使用正则表达式，并在每次调用时进行正则表达式“编译”。对此的一种优化将是直接使用正则表达式并缓存已编译的模式，以避免每次编译它的开销。

package com.sample;

import java.util.function.BiFunction;
import java.util.stream.IntStream;

public class Main {

    static public String deleteCharsSimple(String fromString, String charsToDelete)
    {
        StringBuilder buf = new StringBuilder(fromString.length()); // Preallocate to max possible result length
        for(int i = 0; i < fromString.length(); i++)
            if (charsToDelete.indexOf(fromString.charAt(i)) < 0)
                buf.append(fromString.charAt(i));   // char not in chars to delete so add it
        return buf.toString();
    }

    static public String deleteCharsLambda(String fromString1, String charsToDelete)
    {
        BiFunction<String, String, String> deleteChars = (fromString, chars) -> {
            StringBuilder buf = new StringBuilder(fromString);
            IntStream.range(0, buf.length()).forEach(i -> {
                while (i < buf.length() && chars.indexOf(buf.charAt(i)) >= 0)
                    buf.deleteCharAt(i);
            });
            return (buf.toString());
        };

        return deleteChars.apply(fromString1, charsToDelete);
    }

    static public String deleteCharsReplace(String fromString, String charsToDelete)
    {
        return fromString.replace(charsToDelete, "");
    }


    public static void main(String[] args)
    {
        String str = "XXXTextX XXto modifyX";
        String charsToDelete = "X";  // Should only be one char as per OP's requirement

        long start, end;

        System.out.println("Start simple");
        start = System.currentTimeMillis();

        for (int i = 0; i < 1000000; i++)
            deleteCharsSimple(str, charsToDelete);

        end = System.currentTimeMillis();
        System.out.println("Time: " + (end - start));

        System.out.println("Start lambda");
        start = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++)
            deleteCharsLambda(str, charsToDelete);

        end = System.currentTimeMillis();
        System.out.println("Time: " + (end - start));

        System.out.println("Start replace");
        start = System.currentTimeMillis();

        for (int i = 0; i < 1000000; i++)
            deleteCharsReplace(str, charsToDelete);

        end = System.currentTimeMillis();
        System.out.println("Time: " + (end - start));
    }
}

在替换时，您需要将需要删除的字符放在方括号内。示例代码如下：

String s = "$116.42".replaceAll("[$]", "");

您可以使用str = str.replace("X", "");前面提到的方法，这样会很好的。供您参考的''字符不是空（或有效）字符，而是'\0'。

因此，您可以str = str.replace('X', '\0');改用。