Wie ersetzt man String nur einmal ohne Regex in Java?

Ich ersetzen müssen, die eine dynamische Teilstring in einem größeren string, aber nur einmal (d.h. im ersten match). Die String-Klasse stellt nur replace() ersetzt ALLE Instanzen des Teilstrings; es ist ein replaceFirst() Methode, aber es dauert nur regexp anstatt des normalen string. Ich habe zwei Bedenken mit der Verwendung von regex:

1) meine substring ist dynamisch, so könnte enthalten seltsame Zeichen, die etwas bedeuten, sonst in regex, und ich will nicht viel mit Charakter zu entkommen.

2) dieser Austausch geschieht sehr oft, und ich bin mir nicht sicher, ob die Verwendung der regex auf die Leistung auswirkt. Ich kann nicht kompilieren der regex vorher, da die regex selbst ist dynamisch!

Ich muss hier etwas fehlt, da mir scheint das eine sehr einfache Sache... gibt es eine Methode replaceFirst die regelmäßige Einnahme string irgendwo sonst in der java-franework?

InformationsquelleAutor der Frage polyglot | 2009-10-24

  1. 13

    Verwenden bigString.indexof(smallString) um den index des ersten Vorkommens des kleinen string in die große (oder -1, falls nicht vorhanden, in diesem Fall sind Sie fertig). Verwenden Sie dann bigString.substring zu Holen Sie sich die Stücke der großen string vor und nach dem Spiel, und schließlich concat zu setzen, jene, die vor und nach Teile wieder zusammen, mit den beabsichtigten Ersatz in der Mitte.

    InformationsquelleAutor der Antwort Alex Martelli

  2. 21

    Sollten Sie verwenden, bereits getestete und gut dokumentierte Bibliotheken zu Gunsten von das schreiben Ihrer eigenen code!

    StringUtils.replaceOnce("aba", "a", "")    = "ba"

    InformationsquelleAutor der Antwort Daniel Gerber

  3. 15

    Als Laurence vorschlug, die Sie verwenden können Pattern.quote wie diese:

    newString = string.replaceFirst(Pattern.quote(substring), replacement);

    Dieser erstellt eine neue regex, die buchstäblich entspricht dem Teilstring. Ein weiterer Ansatz ist, einfach zu kompilieren, die substring-als literal regex wie diese:

    newString = Pattern.compile(substring, Pattern.LITERAL).
        matcher(string).replaceFirst(replacement);

    Diese möglicherweise etwas effizienter, aber auch etwas weniger klar.

    Könnte man es auch manuell tun, da Sie nur wollen, zum ersetzen des ersten Vorkommens. Aber regexes sind ziemlich effizient, also nicht optimieren zu früh!

    InformationsquelleAutor der Antwort Bennett McElwee

  4. 5

    stellen Sie sicher, dass Sie auch ersetzen \s und $s in die Ersatz-als auch. Dies ist wahrscheinlich das, was Sie wollen, da können Sie keine Untergruppen mit Ihnen ()'s entfernt).

    newStr = str.replaceFirst(Pattern.quote(target), Matcher.quoteReplacement(replacement));

    InformationsquelleAutor der Antwort user1707094

  5. 1

    Muster.zitieren scheint nicht in allen Fällen funktionieren. Versuchen Sie `Muster.Zitat(":-)");

    InformationsquelleAutor der Antwort trans

  6. 1

    StringBuilder-Klasse in java verwendet werden kann, sehr einfach zu tun, eine nicht-regex-basierte Ersetzung einer Zeichenfolge durch eine andere.

    private static String replace(String in, String ths, String that) {

    StringBuilder sb = new StringBuilder(in);

    int idx = sb.indexOf(ths); 

    while (idx > -1)
        sb.replace(idx, idx + ths.length(), that);
        idx = sb.indexOf(ths);
    }

    return sb.toString(); 

}

    InformationsquelleAutor der Antwort Zerovian

  7. 1

    Lösung mit Pattern

    Könnte man das auch ändern String.ersetzen Methode verwendet, die wörtliche interpretation der Zeichen, die ersetzt nur das erste vorkommen des target Zeichenfolge:

    /**
 * Replaces the first subsequence of the <tt>source</tt> character sequence
 * that matches the literal target sequence with the specified literal
 * replacement sequence.
 * 
 * @param source source sequence on which the replacement is made
 * @param target the sequence of char values to be replaced
 * @param replacement the replacement sequence of char values
 * @return the resulting string
 */
private static String replaceFirst1(CharSequence source, CharSequence target, CharSequence replacement) {
    return Pattern.compile(target.toString(), Pattern.LITERAL).matcher(
        source).replaceFirst(Matcher.quoteReplacement(replacement.toString()));
}


    Aus der Dokumentation der Muster.WÖRTLICHE:

    Wenn dieses flag angegeben ist, dann wird der input-string, der angibt, das Muster wird behandelt wie eine Folge von literalen Zeichen. Metazeichen oder escape-Sequenzen, die in der input-Sequenz gegeben werden, keine Besondere Bedeutung.

    Lösung ohne Pattern

    Den anderen und effizienter Weg, natürlich, ist die Verwendung Alex Martelli's Tipp, um die folgende Funktionalität:

    /**
 * Replaces the first subsequence of the <tt>source</tt> string that matches
 * the literal target string with the specified literal replacement string.
 * 
 * @param source source string on which the replacement is made
 * @param target the string to be replaced
 * @param replacement the replacement string
 * @return the resulting string
 */
private static String replaceFirst2(String source, String target, String replacement) {
    int index = source.indexOf(target);
    if (index == -1) {
        return source;
    }

    return source.substring(0, index)
        .concat(replacement)
        .concat(source.substring(index+target.length()));
}

    Zeit der Messung

    Basierend auf 10 läuft, die replaceFirst2 - Methode ausgeführt, die über 5 mal schneller als die replaceFirst1 Methode. Ich habe beide dieser Methoden in einer Schleife mit 100.000 wiederholt und erhielt die folgenden Ergebnisse, in Millisekunden:

     Methode Ergebnisse (in ms) Durchschnittliche 
replaceFirst1: 220 187 249 186 199 211 172 199 281 199 | 210 
replaceFirst2: 40 39 58 45 48 40 42 42 43 59 | 45

    InformationsquelleAutor der Antwort dinomario10

Schreibe einen Kommentar