Remova todas as ocorrências de char da string

Eu posso usar isso:

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

Existe uma maneira de remover todas as ocorrências de caracteres Xde uma String em Java?

Eu tentei isso e não é o que eu quero: str.replace('X',' '); //replace with space

Tente usar a sobrecarga que recebe CharSequenceargumentos (por exemplo, String) em vez de char:

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

Usando

public String replaceAll(String regex, String replacement)

vai funcionar.

Uso seria str.replace("X", "");.

Executando

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

retorna:

lakjsdf xx

Se você quiser fazer algo com o Java Strings, o Commons Lang StringUtils é um ótimo lugar para procurar.

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

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

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

Este é o exemplo de onde eu removi o caractere - da String.

Eu gosto de usar o RegEx nesta ocasião:

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

onde g significa global para que ele passe por toda a sua string e substitua todo X por ''; se você quiser substituir o X e o x, basta dizer:

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

(veja meu violino aqui: violino )

Olá Experimente este código abaixo

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();
    }
}

Use replaceAll em vez de replace

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

Isso deve lhe dar a resposta desejada.

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);
        }
    }
}

aqui está uma função lambda que remove todos os caracteres passados ​​como string

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"

Essa solução leva em consideração que a String resultante - diferentemente de replace()- nunca se torna maior que a String inicial ao remover caracteres. Portanto, evita a alocação e a cópia repetidas enquanto acrescenta caracteres no modo StringBuildercomo replace()faz.
Sem mencionar a geração inútil Patterne as Matcherinstâncias em replace()que nunca são necessárias para remoção.
Diferentemente replace()desta solução, você pode excluir vários caracteres de uma só vez.

Avaliação das principais respostas com uma referência de desempenho que confirma preocupações de que a resposta escolhida atual faça operações regex dispendiosas sob o capô

Até o momento, as respostas fornecidas estão em três estilos principais (ignorando a resposta JavaScript;)):

• Use String.replace (charsToDelete, ""); que usa regex sob o capô
• Use Lambda
• Use implementação Java simples

Em termos de tamanho do código, claramente o String.replace é o mais conciso. A implementação Java simples é um pouco menor e mais limpa (IMHO) do que o Lambda (não me interpretem mal - eu uso o Lambdas sempre que apropriado)

A velocidade de execução foi, na ordem do mais rápido para o mais lento: implementação simples de Java, Lambda e String.replace () (que chama regex).

De longe, a implementação mais rápida foi a simples implementação Java ajustada para pré-alocar o buffer StringBuilder ao tamanho máximo possível do resultado e, em seguida, simplesmente anexa caracteres ao buffer que não está na string "chars to delete". Isso evita qualquer realocação que ocorreria para Strings> 16 caracteres de comprimento (a alocação padrão para StringBuilder) e evita o impacto de desempenho "deslizar para a esquerda" ao excluir caracteres de uma cópia da string que ocorre é a implementação do Lambda.

O código abaixo executa um teste de benchmark simples, executando cada implementação 1.000.000 de vezes e registra o tempo decorrido.

Os resultados exatos variam a cada execução, mas a ordem do desempenho nunca muda:

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

A implementação do Lambda (como copiada da resposta da Kaplan) pode ser mais lenta porque executa um "deslocamento deixado por um" de todos os caracteres à direita do caractere sendo excluído. Obviamente, isso pioraria para cadeias mais longas, com muitos caracteres exigindo exclusão. Também pode haver alguma sobrecarga na própria implementação do Lambda.

A implementação String.replace, usa regex e faz uma regex "compilar" a cada chamada. Uma otimização disso seria usar o regex diretamente e armazenar em cache o padrão compilado para evitar o custo de compilá-lo a cada vez.

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));
    }
}

Você precisará colocar os caracteres que precisam ser removidos dentro dos colchetes durante o tempo de substituição. O código de exemplo será o seguinte:

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

Você pode usar str = str.replace("X", "");como mencionado anteriormente e ficará bem. Para sua informação, ''não é um caractere vazio (ou válido), mas '\0'é.

Então você pode usar str = str.replace('X', '\0');.