Eliminar todas las apariciones de char de la cadena

Puedo usar esto:

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

¿Hay alguna manera de eliminar todas las apariciones de caracteres Xde una Cadena en Java?

Intenté esto y no es lo que quiero: str.replace('X',' '); //replace with space

Intente usar la sobrecarga que toma CharSequenceargumentos (por ejemplo, String) en lugar de char:

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

Utilizando

public String replaceAll(String regex, String replacement)

trabajará.

El uso sería str.replace("X", "");.

Ejecutando

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

devoluciones:

lakjsdf xx

Si desea hacer algo con Java Strings, Commons Lang StringUtils es un gran lugar para buscar.

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

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

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

Este es el ejemplo de donde he eliminado el personaje: de la cadena.

Me gusta usar RegEx en esta ocasión:

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

donde g significa global, por lo que pasará por toda la cadena y reemplazará todas las X con '' Si desea reemplazar X y X, simplemente diga:

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

(Mira mi violín aquí: violín )

Hola Prueba este código a continuación

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 en lugar de reemplazar

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

Esto debería darte la respuesta deseada.

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

Aquí hay una función lambda que elimina todos los caracteres pasados ​​como cadena

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"

Esta solución tiene en cuenta que la Cadena resultante, a diferencia de replace(), nunca se vuelve más grande que la Cadena inicial al eliminar caracteres. Por lo tanto, evita la asignación y la copia repetidas al tiempo que se agrega carácter a lo StringBuilderque se replace()hace.
Sin mencionar la generación inútil Patterny las Matcherinstancias en replace()que nunca son necesarias para la eliminación.
A diferencia de replace()esta solución, puede eliminar varios caracteres de una sola vez.

Evaluación de las respuestas principales con un punto de referencia de rendimiento que confirma las preocupaciones de que la respuesta actual elegida haga costosas operaciones de expresiones regulares bajo el capó

Hasta la fecha, las respuestas proporcionadas vienen en 3 estilos principales (ignorando la respuesta de JavaScript;)):

• Use String.replace (charsToDelete, ""); que usa expresiones regulares debajo del capó
• Utilizar lambda
• Use una implementación simple de Java

En términos de tamaño de código, claramente el String.replace es el más conciso. La implementación simple de Java es un poco más pequeña y limpia (en mi humilde opinión) que la Lambda (no me malinterpreten, uso Lambdas a menudo cuando son apropiadas)

La velocidad de ejecución fue, en orden de más rápida a más lenta: implementación simple de Java, Lambda y luego String.replace () (que invoca expresiones regulares).

Con mucho, la implementación más rápida fue la implementación simple de Java ajustada para que preasigne el búfer StringBuilder a la longitud máxima posible del resultado y luego simplemente agregue caracteres al búfer que no están en la cadena "caracteres para eliminar". Esto evita las reasignaciones que se producirían para cadenas> 16 caracteres de longitud (la asignación predeterminada para StringBuilder) y evita el impacto de rendimiento "deslizar a la izquierda" de eliminar caracteres de una copia de la cadena que se produce es la implementación de Lambda.

El siguiente código ejecuta una prueba de referencia simple, ejecuta cada implementación 1,000,000 de veces y registra el tiempo transcurrido.

Los resultados exactos varían con cada ejecución, pero el orden de rendimiento nunca cambia:

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

La implementación de Lambda (como se copió de la respuesta de Kaplan) puede ser más lenta porque realiza un "desplazamiento a la izquierda por uno" de todos los caracteres a la derecha del carácter que se está eliminando. Obviamente, esto empeoraría para cadenas más largas con muchos caracteres que requieren eliminación. También puede haber algo de sobrecarga en la implementación de Lambda en sí.

La implementación String.replace, utiliza expresiones regulares y realiza una "compilación" de expresiones regulares en cada llamada. Una optimización de esto sería usar regex directamente y almacenar en caché el patrón compilado para evitar el costo de compilarlo 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));
    }
}

Deberá poner los caracteres que deben eliminarse dentro de los corchetes durante el tiempo de reemplazo. El código de ejemplo será el siguiente:

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

Puede usar str = str.replace("X", "");como se mencionó anteriormente y estará bien. Para su información ''no es un carácter vacío (o válido) pero '\0'es.

Entonces podrías usar str = str.replace('X', '\0');en su lugar.