Usuń wszystkie wystąpienia znaku z łańcucha

Mogę użyć tego:

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

Czy istnieje sposób na usunięcie wszystkich wystąpień znaków Xz ciągu znaków w Javie?

Próbowałem tego i nie jest to, czego chcę: str.replace('X',' '); //replace with space

Spróbuj użyć przeciążenia, które pobiera CharSequenceargumenty (np. String), Zamiast char:

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

Za pomocą

public String replaceAll(String regex, String replacement)

będzie działać.

Wykorzystanie byłoby str.replace("X", "");.

Wykonywanie

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

zwroty:

lakjsdf xx

Jeśli chcesz coś zrobić z Java Strings, Commons Lang StringUtils to świetne miejsce do oglądania.

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

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

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

To jest przykład, w którym usunąłem znak - z Ciągu.

Lubię używać RegEx przy tej okazji:

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

gdzie g oznacza globalny, więc przejdzie przez cały ciąg i zastąpi wszystkie X znakiem „”; jeśli chcesz zamienić zarówno X, jak i X, po prostu powiesz:

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

(patrz moje skrzypce tutaj: skrzypce )

Witaj Wypróbuj ten kod poniżej

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

Użyj replaceAll zamiast replace

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

To powinno dać ci pożądaną odpowiedź.

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

tutaj jest funkcja lambda, która usuwa wszystkie znaki przekazywane jako ciąg znaków

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"

To rozwiązanie bierze pod uwagę, że wynikowy Ciąg - w przeciwieństwie do replace()- nigdy nie staje się większy niż Ciąg początkowy podczas usuwania znaków. Dzięki temu unika się wielokrotnego przydzielania i kopiowania, jednocześnie dodając znaki do znaku StringBuilderas replace().
Nie wspominając już o bezcelowym generowaniu Patterni Matcherwystąpieniach replace(), które nigdy nie są potrzebne do usunięcia.
W odróżnieniu od replace()tego rozwiązania można usunąć kilka znaków za jednym zamachem.

Ocena głównych odpowiedzi za pomocą wskaźnika wydajności, który potwierdza obawy, że obecnie wybrana odpowiedź powoduje, że kosztowne operacje wyrażenia regularnego są pod maską

Do tej pory dostarczone odpowiedzi są dostępne w 3 głównych stylach (ignorując odpowiedź JavaScript;)):

• Użyj String.replace (charsToDelete, „”); który używa wyrażenia regularnego pod maską
• Użyj Lambda
• Użyj prostej implementacji Java

Jeśli chodzi o rozmiar kodu, String.replace jest najbardziej zwięzły. Prosta implementacja Java jest nieco mniejsza i czystsza (IMHO) niż Lambda (nie zrozum mnie źle - często używam Lambdas tam, gdzie są odpowiednie)

Szybkość wykonywania była w kolejności od najszybszej do najwolniejszej: prosta implementacja Java, Lambda, a następnie String.replace () (która wywołuje wyrażenie regularne).

Zdecydowanie najszybszą implementacją była dostrojona prosta implementacja Java, która wstępnie przypisuje bufor StringBuilder do maksymalnej możliwej długości wyniku, a następnie po prostu dołącza znaki do bufora, które nie znajdują się w ciągu „znaków do usunięcia”. Pozwala to uniknąć wszelkich realokacji, które wystąpiłyby dla ciągów o długości> 16 znaków (domyślny przydział dla StringBuilder) i uniknięto trafienia wydajnościowego „przesuń w lewo” usuwania znaków z kopii ciągu znaków, który jest implementacją Lambda.

Poniższy kod uruchamia prosty test porównawczy, uruchamiając każdą implementację 1 000 000 razy i rejestruje upływ czasu.

Dokładne wyniki różnią się przy każdym uruchomieniu, ale kolejność wydajności nigdy się nie zmienia:

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

Implementacja Lambda (skopiowana z odpowiedzi Kaplana) może być wolniejsza, ponieważ wykonuje „przesunięcie w lewo o jeden” spośród wszystkich znaków na prawo od usuwanej postaci. Oczywiście pogorszy się to w przypadku dłuższych ciągów znaków z dużą ilością znaków wymagających usunięcia. Również w samej implementacji Lambda mogą występować pewne koszty ogólne.

Implementacja String.replace używa wyrażenia regularnego i wykonuje „kompilację” wyrażenia regularnego przy każdym wywołaniu. Optymalizacja tego polega na bezpośrednim użyciu wyrażenia regularnego i buforowaniu skompilowanego wzorca, aby uniknąć kosztu kompilacji za każdym razem.

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

Podczas wymiany musisz umieścić znaki w nawiasach kwadratowych. Przykładowy kod będzie następujący:

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

Możesz używać, str = str.replace("X", "");jak wspomniano wcześniej, i wszystko będzie dobrze. Twoja informacja ''nie jest pustym (lub prawidłowym) znakiem, ale '\0'jest.

Więc możesz użyć str = str.replace('X', '\0');zamiast tego.