ersetzen mehrere Teilstrings in einer Zeichenfolge, Array vs HashMap

Question

Es gibt 2 Funktionen unten definiert. Sie tun genau die gleiche Funktion, dh nehmen eine Vorlage (in der man einige Teilstrings ersetzen möchte) und ein Array von Strings-Werten (zu ersetzendes Schlüsselwertpaar, zB: [subStrToReplace1, value1, subStrToReplace1, value2, .....]) und gibt den ersetzten String zurück.

In der zweiten Funktion Iterieren über Wörter der Vorlagen und Suche nach dem relevanten Schlüssel, wenn in hashmap und dann nächstes Wort vorhanden sind. Wenn ich ein Wort durch einen Teilstring ersetzen möchte, den ich wieder durch einen anderen Schlüssel in Werten ersetzen möchte, muss ich zweimal über Template iterieren. Das ist, was ich tat.

Ich würde gerne wissen, welche sollte ich verwenden und warum? Jede Alternative besser als diese sind ebenfalls willkommen.

1. Funktion

public static String populateTemplate1(String template, String... values) { 
    String populatedTemplate = template; 
    for (int i = 0; i < values.length; i += 2) { 
     populatedTemplate = populatedTemplate.replace(values[i], values[i + 1]); 
    } 
    return populatedTemplate; 
} 

2. Funktion

public static String populateTemplate2(String template, String... values) { 
    HashMap<String, String> map = new HashMap<>(); 
    for (int i = 0; i < values.length; i += 2) { 
     map.put(values[i],values[i+1]); 
    } 
    StringBuilder regex = new StringBuilder(); 
    boolean first = true; 
    for (String word : map.keySet()) { 
     if (first) { 
      first = false; 
     } else { 
      regex.append('|'); 
     } 
     regex.append(Pattern.quote(word)); 
    } 
    Pattern pattern = Pattern.compile(regex.toString()); 

    int N0OfIterationOverTemplate =2; 
    // Pattern allowing to extract only the words 
    // Pattern pattern = Pattern.compile("\\w+"); 
    StringBuilder populatedTemplate=new StringBuilder();; 

    String temp_template=template; 

    while(N0OfIterationOverTemplate!=0){ 
     populatedTemplate = new StringBuilder(); 
     Matcher matcher = pattern.matcher(temp_template); 
     int fromIndex = 0; 
     while (matcher.find(fromIndex)) { 
      // The start index of the current word 
      int startIdx = matcher.start(); 
      if (fromIndex < startIdx) { 
       // Add what we have between two words 
       populatedTemplate.append(temp_template, fromIndex, startIdx); 
      } 
      // The current word 
      String word = matcher.group(); 
      // Replace the word by itself or what we have in the map 
      // populatedTemplate.append(map.getOrDefault(word, word)); 

      if (map.get(word) == null) { 
       populatedTemplate.append(word); 
      } 
      else { 
       populatedTemplate.append(map.get(word)); 
      } 

      // Start the next find from the end index of the current word 
      fromIndex = matcher.end(); 
     } 
     if (fromIndex < temp_template.length()) { 
      // Add the remaining sub String 
      populatedTemplate.append(temp_template, fromIndex, temp_template.length()); 
     } 

     N0OfIterationOverTemplate--; 
     temp_template=populatedTemplate.toString(); 
    } 
    return populatedTemplate.toString(); 
} 

Answer 1

Definitiv die erste für mindestens zwei Gründen:

1. Es ist leichter zu lesen und kürzer, so ist es einfacher, zu pflegen, da es viel weniger fehleranfällig ist
2. Sie verlassen sich nicht auf einen regulären Ausdruck, so dass es bei weitem schneller ist

Answer 2

Die erste Funktion ist viel klarer und leichter zu verstehen. Ich würde es vorziehen, wenn Sie nicht (durch einen Profiler) herausfinden, dass es eine beträchtliche Menge an Zeit benötigt und Ihre Bewerbung verlangsamt. Dann können Sie herausfinden, wie Sie es optimieren können.

Answer 3

Warum Dinge kompliziert machen, wenn Sie einfach machen können.

Denken Sie daran, dass einfache Lösungen in der Regel die besten sind.

FYI, wenn die Anzahl der Elemente ist und ungerade Zahl erhalten Sie eine ArrayIndexOutOfBoundsException.

Ich schlage vor, diese Verbesserung:

public static String populateTemplate(String template, String... values) { 
     String populatedTemplate = template; 
     int nextTarget = 2; 
     int lastTarget = values.length - nextTarget; 

     for (int i = 0; i <= lastTarget; i += nextTarget) { 
      String target = values[i]; 
      String replacement = values[i + 1]; 
      populatedTemplate = populatedTemplate.replace(target, replacement); 
     } 
     return populatedTemplate; 
    } 

"Gute Programmierer schreiben Code, den Menschen verstehen". Martin Fowler