Supprimer toutes les occurrences de char de la chaîne

Je peux utiliser ceci:

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

Existe-t-il un moyen de supprimer toutes les occurrences de caractère Xd'une chaîne en Java?

J'ai essayé ça et ce n'est pas ce que je veux: str.replace('X',' '); //replace with space

Essayez d'utiliser la surcharge qui prend des CharSequencearguments (par exemple, String) plutôt que char:

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

En utilisant

public String replaceAll(String regex, String replacement)

marchera.

L'utilisation serait str.replace("X", "");.

Exécution

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

Retour:

lakjsdf xx

Si vous voulez faire quelque chose avec Java Strings, Commons Lang StringUtils est un endroit idéal pour regarder.

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

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

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

Ceci est l'exemple pour lequel j'ai supprimé le caractère - de la chaîne.

J'aime utiliser RegEx à cette occasion:

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

où g signifie global donc il passera par toute votre chaîne et remplacera tous les X par ''; si vous voulez remplacer X et x, vous dites simplement:

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

(voir mon violon ici: violon )

Bonjour Essayez ce code ci-dessous

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

Utilisez replaceAll au lieu de replace

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

Cela devrait vous donner la réponse souhaitée.

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

voici une fonction lambda qui supprime tous les caractères passés en chaîne

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"

Cette solution tient compte du fait que la chaîne résultante - à la différence de replace()- ne devient jamais plus grande que la chaîne de départ lors de la suppression de caractères. Ainsi, il évite l'attribution et la copie répétées tout en ajoutant des caractères aux StringBuilderas replace().
Sans parler de la génération inutile Patternet des Matcherinstances replace()qui ne sont jamais nécessaires pour la suppression.
À la différence de replace()cette solution, vous pouvez supprimer plusieurs caractères en un seul coup.

Évaluation des principales réponses avec un repère de performance qui confirme les inquiétudes selon lesquelles la réponse actuellement choisie rend les opérations de regex coûteuses sous le capot

À ce jour, les réponses fournies se déclinent en 3 styles principaux (en ignorant la réponse JavaScript;)):

• Utilisez String.replace (charsToDelete, ""); qui utilise des regex sous le capot
• Utilisez Lambda
• Utilisez une implémentation Java simple

En termes de taille de code, String.replace est clairement le plus laconique. L'implémentation Java simple est légèrement plus petite et plus propre (à mon humble avis) que la Lambda (ne vous méprenez pas - j'utilise souvent Lambdas là où elles sont appropriées)

La vitesse d'exécution était, dans l'ordre du plus rapide au plus lent: implémentation Java simple, Lambda puis String.replace () (qui invoque l'expression régulière).

De loin, l'implémentation la plus rapide a été l'implémentation Java simple, réglée de manière à préallouer le tampon StringBuilder à la longueur de résultat maximale possible, puis à simplement ajouter des caractères au tampon qui ne se trouvent pas dans la chaîne "caractères à supprimer". Cela évite toute réallocation qui se produirait pour des chaînes de plus de 16 caractères (l'allocation par défaut pour StringBuilder) et cela évite le hit de performance "slide left" de supprimer des caractères d'une copie de la chaîne qui se produit est l'implémentation Lambda.

Le code ci-dessous exécute un test de référence simple, exécutant chaque implémentation 1 000 000 fois et enregistre le temps écoulé.

Les résultats exacts varient à chaque exécution, mais l'ordre des performances ne change jamais:

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

L'implémentation Lambda (telle que copiée à partir de la réponse de Kaplan) peut être plus lente car elle effectue un "décalage à gauche d'un" de tous les caractères à droite du caractère supprimé. Cela empirerait évidemment pour les chaînes plus longues avec beaucoup de caractères à supprimer. Il peut également y avoir des frais généraux dans l'implémentation de Lambda elle-même.

L'implémentation String.replace utilise regex et effectue une "compilation" regex à chaque appel. Une optimisation de ceci serait d'utiliser directement l'expression régulière et de mettre en cache le modèle compilé pour éviter le coût de le compiler à chaque fois.

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

Vous devrez mettre les caractères à supprimer entre crochets pendant le temps de remplacement. L'exemple de code sera le suivant:

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

Vous pouvez utiliser str = str.replace("X", "");comme mentionné précédemment et tout ira bien. Car votre information ''n'est pas un caractère vide (ou valide) mais l' '\0'est.

Vous pouvez donc utiliser à la str = str.replace('X', '\0');place.