Wie ohne StringTokenizer

Question

eine Zeichenfolge wie so Gegeben Token in einer Zeichenfolge ersetzen:

Hello {FIRST_NAME}, this is a personalized message for you. 

Wo FIRST_NAME ein beliebiges Zeichen (einen Schlüssel in der Karte, um die Methode übergeben) ist, eine Routine zu schreiben, die machen würde diese Zeichenfolge in:

Hello Jim, this is a personalized message for you. 

eine Karte mit einem Eintrag FIRST_NAME -> Jim gegeben.

Es scheint, dass StringTokenizer der geradlinigste Ansatz ist, aber die Javadocs sagen wirklich, dass Sie den Regex-Ansatz bevorzugen sollten. Wie würden Sie das in einer Regex-basierten Lösung tun?

Answer 1

Versuchen Sie folgendes:

Hinweis: Die author's final solution baut auf dieser Probe und ist viel übersichtlicher.

public class TokenReplacer { 

    private Pattern tokenPattern; 

    public TokenReplacer() { 
     tokenPattern = Pattern.compile("\\{([^}]+)\\}"); 
    } 

    public String replaceTokens(String text, Map<String, String> valuesByKey) { 
     StringBuilder output = new StringBuilder(); 
     Matcher tokenMatcher = tokenPattern.matcher(text); 

     int cursor = 0; 
     while (tokenMatcher.find()) { 
      // A token is defined as a sequence of the format "{...}". 
      // A key is defined as the content between the brackets. 
      int tokenStart = tokenMatcher.start(); 
      int tokenEnd = tokenMatcher.end(); 
      int keyStart = tokenMatcher.start(1); 
      int keyEnd = tokenMatcher.end(1); 

      output.append(text.substring(cursor, tokenStart)); 

      String token = text.substring(tokenStart, tokenEnd); 
      String key = text.substring(keyStart, keyEnd); 

      if (valuesByKey.containsKey(key)) { 
       String value = valuesByKey.get(key); 
       output.append(value); 
      } else { 
       output.append(token); 
      } 

      cursor = tokenEnd; 
     } 
     output.append(text.substring(cursor)); 

     return output.toString(); 
    } 

} 

Answer 2

Die Dokumente bedeuten, dass Sie lieber einen Regex-basierten Tokenizer, IIRC, schreiben sollten. Was für Sie besser funktionieren könnte, ist ein Standard Regex Search-Replace.

Answer 3

String.replaceAll("{FIRST_NAME}", actualName); 

Überprüfen Sie die Javadocs dafür here.

Answer 4

Nun, ich würde lieber String.format() oder besser MessageFormat verwenden.

Answer 5

Die direkteste scheint etwas entlang der Linien von dieser zu sein:

public static void main(String[] args) { 
    String tokenString = "Hello {FIRST_NAME}, this is a personalized message for you."; 
    Map<String, String> tokenMap = new HashMap<String, String>(); 
    tokenMap.put("{FIRST_NAME}", "Jim"); 
    String transformedString = tokenString; 
    for (String token : tokenMap.keySet()) { 
     transformedString = transformedString.replace(token, tokenMap.get(token)); 
    } 
    System.out.println("New String: " + transformedString); 
} 

Es durch alle Token-Loops und ersetzt jeden Token mit, was Sie brauchen, und verwendet die Standardmethode String für den Austausch und überspringt so die gesamten RegEx Frustrationen.

Answer 6

Mit Import java.util.regex *:.

Pattern p = Pattern.compile("{([^{}]*)}"); 
Matcher m = p.matcher(line); // line being "Hello, {FIRST_NAME}..." 
while (m.find) { 
    String key = m.group(1); 
    if (map.containsKey(key)) { 
    String value= map.get(key); 
    m.replaceFirst(value); 
    } 
} 

So wird die Regex empfohlen, da sie leicht die Orte identifizieren können, die Substitution in der Zeichenfolge erfordern, sowie das Extrahieren des Namens des Schlüssels für die Substitution. Es ist viel effizienter, als die ganze Saite zu zerbrechen.

Sie möchten wahrscheinlich mit der Matcher-Linie innen und der Pattern-Linie außerhalb schleifen, damit Sie alle Linien ersetzen können. Das Muster muss nie neu kompiliert werden, und es ist effizienter, dies unnötigerweise zu vermeiden.

Answer 7

Je nachdem, wie lächerlich komplex Ihre Zeichenfolge ist, können Sie versuchen, eine strengere String-Templating-Sprache wie Velocity zu verwenden. In Velocity Fall würden Sie so etwas tun:

Velocity.init(); 
VelocityContext context = new VelocityContext(); 
context.put("name", "Bob"); 
StringWriter output = new StringWriter(); 
Velocity.evaluate(context, output, "", 
     "Hello, #name, this is a personalized message for you."); 
System.out.println(output.toString()); 

Aber das ist wahrscheinlich übertrieben, wenn Sie nur ein oder zwei Werte ersetzt werden soll.

Answer 8

import java.util.HashMap; 

public class ReplaceTest { 

    public static void main(String[] args) { 
    HashMap<String, String> map = new HashMap<String, String>(); 

    map.put("FIRST_NAME", "Jim"); 
    map.put("LAST_NAME", "Johnson"); 
    map.put("PHONE",  "410-555-1212"); 

    String s = "Hello {FIRST_NAME} {LAST_NAME}, this is a personalized message for you."; 

    for (String key : map.keySet()) { 
     s = s.replaceAll("\\{" + key + "\\}", map.get(key)); 
    } 

    System.out.println(s); 
    } 

} 

Answer 9

Vielen Dank für die Antworten!

Gizmos Antwort war definitiv out of the box, und eine großartige Lösung, aber leider nicht geeignet, da das Format nicht auf das beschränkt werden kann, was die Formatter-Klasse in diesem Fall tut.

Adam Paynter kam mit dem richtigen Muster wirklich zum Kern der Sache.

Peter Nix und Sean Bright hatten einen großen Workaround, um alle Komplexitäten der Regex zu vermeiden, aber ich musste einige Fehler melden, wenn es schlechte Token gab, was das nicht tat.

Aber in Bezug auf sowohl eine Regex und eine vernünftige Replace-Schleife, das ist die Antwort, die ich kam (mit ein wenig Hilfe von Google und die vorhandene Antwort, einschließlich Sean Bright's Kommentar zur Verwendung der Gruppe (1) vs Gruppe()):

private static Pattern tokenPattern = Pattern.compile("\\{([^}]*)\\}"); 

public static String process(String template, Map<String, Object> params) { 
    StringBuffer sb = new StringBuffer(); 
    Matcher myMatcher = tokenPattern.matcher(template); 
    while (myMatcher.find()) { 
     String field = myMatcher.group(1); 
     myMatcher.appendReplacement(sb, ""); 
     sb.append(doParameter(field, params)); 
    } 
    myMatcher.appendTail(sb); 
    return sb.toString(); 
} 

Wo doParameter den Wert aus der Karte bekommt und wandelt sie in einen String und wirft eine Ausnahme, wenn sie nicht da ist.

Beachten Sie auch, dass ich das Muster geändert habe, um leere Klammern (d. H. {}) Zu finden, da dies eine Fehlerbedingung ist, auf die ausdrücklich geprüft wird.

EDIT: Beachten Sie, dass appendReplacement nicht agnostisch über den Inhalt der Zeichenfolge ist. Für die Javadocs erkennt es $ und Backslash als Sonderzeichen, also habe ich etwas Escaping hinzugefügt, um das mit dem obigen Beispiel zu behandeln. Nicht auf die leistungsfähigste Weise gemacht, aber in meinem Fall ist es nicht groß genug, um zu versuchen, die String-Kreationen zu optimieren.

Dank des Kommentars von Alan M kann dies noch einfacher gemacht werden, um die speziellen Charakterprobleme von appendReplacement zu vermeiden.

Answer 10

Im Allgemeinen würden wir MessageFormat in einem solchen Fall verwenden, zusammen mit dem Laden des eigentlichen Nachrichtentextes von einem ResourceBundle. Dies gibt Ihnen den zusätzlichen Vorteil, G10N freundlich zu sein.