Comment puis-je remplacer deux chaînes de manière à ce que l'une ne remplace pas l'autre?

Disons que j'ai le code suivant:

String word1 = "bar";
String word2 = "foo";
String story = "Once upon a time, there was a foo and a bar."
story = story.replace("foo", word1);
story = story.replace("bar", word2);

Une fois ce code exécuté, la valeur de storysera"Once upon a time, there was a foo and a foo."

Un problème similaire se produit si je les remplace dans l'ordre inverse:

String word1 = "bar";
String word2 = "foo";
String story = "Once upon a time, there was a foo and a bar."
story = story.replace("bar", word2);
story = story.replace("foo", word1);

La valeur de storysera"Once upon a time, there was a bar and a bar."

Mon objectif est de storydevenir "Once upon a time, there was a bar and a foo."Comment pourrais-je accomplir cela?

Utilisez la replaceEach()méthode d' Apache Commons StringUtils :

StringUtils.replaceEach(story, new String[]{"foo", "bar"}, new String[]{"bar", "foo"})

Vous utilisez une valeur intermédiaire (qui n'est pas encore présente dans la phrase).

story = story.replace("foo", "lala");
story = story.replace("bar", "foo");
story = story.replace("lala", "bar");

En réponse à la critique: si vous utilisez une chaîne assez grande et peu commune comme zq515sqdqs5d5sq1dqs4d1q5dqqé "& é5d4sqjshsjddjhodfqsqc, nvùq ^ µù; d & € sdq: d:;) àçàçlala où il est peu probable que je débatte de ce point qu'un utilisateur entrera jamais ceci. La seule façon de savoir si un utilisateur le fera est de connaître le code source et à ce stade, vous êtes avec un tout autre niveau de soucis.

Oui, il existe peut-être des méthodes regex sophistiquées. Je préfère quelque chose de lisible dont je sais qu'il ne m'éclatera pas non plus.

Réitérant également l'excellent conseil donné par @David Conrad dans les commentaires :

N'utilisez pas une chaîne intelligemment (stupidement) choisie pour être improbable. Utilisez des caractères de la zone d'utilisation privée Unicode, U + E000..U + F8FF. Supprimez d'abord ces caractères, car ils ne devraient pas être légitimement dans l'entrée (ils n'ont qu'une signification spécifique à l'application dans certaines applications), puis utilisez-les comme espaces réservés lors du remplacement.

Vous pouvez essayer quelque chose comme ça, en utilisant Matcher#appendReplacementet Matcher#appendTail:

String word1 = "bar";
String word2 = "foo";
String story = "Once upon a time, there was a foo and a bar.";

Pattern p = Pattern.compile("foo|bar");
Matcher m = p.matcher(story);
StringBuffer sb = new StringBuffer();
while (m.find()) {
    /* do the swap... */
    switch (m.group()) {
    case "foo":
        m.appendReplacement(sb, word1);
        break;
    case "bar":
        m.appendReplacement(sb, word2);
        break;
    default:
        /* error */
        break;
    }
}
m.appendTail(sb);

System.out.println(sb.toString());

Il était une fois un bar et un foo.

Ce n'est pas un problème facile. Et plus vous avez de paramètres de remplacement de recherche, plus cela devient compliqué. Vous avez plusieurs options, dispersées sur la palette de moche-élégant, efficace-gaspillage:

• Utilisation StringUtils.replaceEachdepuis Apache Commons comme @AlanHay recommandé. C'est une bonne option si vous êtes libre d'ajouter de nouvelles dépendances dans votre projet. Vous pourriez avoir de la chance: la dépendance peut déjà être incluse dans votre projet

• Utilisez un espace réservé temporaire comme @Jeroen l'a suggéré et effectuez le remplacement en 2 étapes:

  1. Remplacez tous les modèles de recherche par une balise unique qui n'existe pas dans le texte d'origine
  2. Remplacez les espaces réservés par le véritable remplacement de la cible

  Ce n'est pas une bonne approche, pour plusieurs raisons: il faut s'assurer que les balises utilisées dans la première étape sont vraiment uniques; il effectue plus d'opérations de remplacement de chaîne que nécessaire

• Construisez une expression régulière à partir de tous les modèles et utilisez la méthode avec MatcheretStringBuffer comme suggéré par @arshajii . Ce n'est pas terrible, mais pas terrible non plus, car la construction de l'expression régulière est un peu hackish, et cela implique StringBufferce qui s'est démodé il y a quelque temps en faveur de StringBuilder.

• Utilisez une solution récursive proposée par @mjolka , en fractionnant la chaîne au niveau des modèles correspondants et en effectuant une récurrence sur les segments restants. C'est une solution fine, compacte et assez élégante. Sa faiblesse réside dans les opérations potentiellement nombreuses de sous-chaînes et de concaténation, et les limites de taille de pile qui s'appliquent à toutes les solutions récursives

• Divisez le texte en mots et utilisez les flux Java 8 pour effectuer les remplacements avec élégance, comme @msandiford l'a suggéré, mais bien sûr, cela ne fonctionne que si vous êtes d'accord avec le fractionnement aux limites des mots, ce qui le rend inapproprié comme solution générale

Voici ma version, basée sur des idées empruntées à l'implémentation d' Apache . Ce n'est ni simple ni élégant, mais cela fonctionne et devrait être relativement efficace, sans étapes inutiles. En un mot, cela fonctionne comme ceci: recherchez à plusieurs reprises le modèle de recherche correspondant suivant dans le texte, et utilisez a StringBuilderpour accumuler les segments sans correspondance et les remplacements.

public static String replaceEach(String text, String[] searchList, String[] replacementList) {
    // TODO: throw new IllegalArgumentException() if any param doesn't make sense
    //validateParams(text, searchList, replacementList);

    SearchTracker tracker = new SearchTracker(text, searchList, replacementList);
    if (!tracker.hasNextMatch(0)) {
        return text;
    }

    StringBuilder buf = new StringBuilder(text.length() * 2);
    int start = 0;

    do {
        SearchTracker.MatchInfo matchInfo = tracker.matchInfo;
        int textIndex = matchInfo.textIndex;
        String pattern = matchInfo.pattern;
        String replacement = matchInfo.replacement;

        buf.append(text.substring(start, textIndex));
        buf.append(replacement);

        start = textIndex + pattern.length();
    } while (tracker.hasNextMatch(start));

    return buf.append(text.substring(start)).toString();
}

private static class SearchTracker {

    private final String text;

    private final Map<String, String> patternToReplacement = new HashMap<>();
    private final Set<String> pendingPatterns = new HashSet<>();

    private MatchInfo matchInfo = null;

    private static class MatchInfo {
        private final String pattern;
        private final String replacement;
        private final int textIndex;

        private MatchInfo(String pattern, String replacement, int textIndex) {
            this.pattern = pattern;
            this.replacement = replacement;
            this.textIndex = textIndex;
        }
    }

    private SearchTracker(String text, String[] searchList, String[] replacementList) {
        this.text = text;
        for (int i = 0; i < searchList.length; ++i) {
            String pattern = searchList[i];
            patternToReplacement.put(pattern, replacementList[i]);
            pendingPatterns.add(pattern);
        }
    }

    boolean hasNextMatch(int start) {
        int textIndex = -1;
        String nextPattern = null;

        for (String pattern : new ArrayList<>(pendingPatterns)) {
            int matchIndex = text.indexOf(pattern, start);
            if (matchIndex == -1) {
                pendingPatterns.remove(pattern);
            } else {
                if (textIndex == -1 || matchIndex < textIndex) {
                    textIndex = matchIndex;
                    nextPattern = pattern;
                }
            }
        }

        if (nextPattern != null) {
            matchInfo = new MatchInfo(nextPattern, patternToReplacement.get(nextPattern), textIndex);
            return true;
        }
        return false;
    }
}

Tests unitaires:

@Test
public void testSingleExact() {
    assertEquals("bar", StringUtils.replaceEach("foo", new String[]{"foo"}, new String[]{"bar"}));
}

@Test
public void testReplaceTwice() {
    assertEquals("barbar", StringUtils.replaceEach("foofoo", new String[]{"foo"}, new String[]{"bar"}));
}

@Test
public void testReplaceTwoPatterns() {
    assertEquals("barbaz", StringUtils.replaceEach("foobar",
            new String[]{"foo", "bar"},
            new String[]{"bar", "baz"}));
}

@Test
public void testReplaceNone() {
    assertEquals("foofoo", StringUtils.replaceEach("foofoo", new String[]{"x"}, new String[]{"bar"}));
}

@Test
public void testStory() {
    assertEquals("Once upon a foo, there was a bar and a baz, and another bar and a cat.",
            StringUtils.replaceEach("Once upon a baz, there was a foo and a bar, and another foo and a cat.",
                    new String[]{"foo", "bar", "baz"},
                    new String[]{"bar", "baz", "foo"})
    );
}

Recherchez le premier mot à remplacer. Si c'est dans la chaîne, recurse sur la partie de la chaîne avant l'occurrence et sur la partie de la chaîne après l'occurrence.

Sinon, continuez avec le mot suivant à remplacer.

Une implémentation naïve pourrait ressembler à ceci

public static String replaceAll(String input, String[] search, String[] replace) {
  return replaceAll(input, search, replace, 0);
}

private static String replaceAll(String input, String[] search, String[] replace, int i) {
  if (i == search.length) {
    return input;
  }
  int j = input.indexOf(search[i]);
  if (j == -1) {
    return replaceAll(input, search, replace, i + 1);
  }
  return replaceAll(input.substring(0, j), search, replace, i + 1) +
         replace[i] +
         replaceAll(input.substring(j + search[i].length()), search, replace, i);
}

Exemple d'utilisation:

String input = "Once upon a baz, there was a foo and a bar.";
String[] search = new String[] { "foo", "bar", "baz" };
String[] replace = new String[] { "bar", "baz", "foo" };
System.out.println(replaceAll(input, search, replace));

Production:

Once upon a foo, there was a bar and a baz.

Une version moins naïve:

public static String replaceAll(String input, String[] search, String[] replace) {
  StringBuilder sb = new StringBuilder();
  replaceAll(sb, input, 0, input.length(), search, replace, 0);
  return sb.toString();
}

private static void replaceAll(StringBuilder sb, String input, int start, int end, String[] search, String[] replace, int i) {
  while (i < search.length && start < end) {
    int j = indexOf(input, search[i], start, end);
    if (j == -1) {
      i++;
    } else {
      replaceAll(sb, input, start, j, search, replace, i + 1);
      sb.append(replace[i]);
      start = j + search[i].length();
    }
  }
  sb.append(input, start, end);
}

Malheureusement, Java Stringn'a pas de indexOf(String str, int fromIndex, int toIndex)méthode. J'ai omis l'implémentation d' indexOfici car je ne suis pas certain qu'elle soit correcte, mais elle peut être trouvée sur ideone , avec quelques timings approximatifs de diverses solutions publiées ici.

One-liner dans Java 8:

    story = Pattern
        .compile(String.format("(?<=%1$s)|(?=%1$s)", "foo|bar"))
        .splitAsStream(story)
        .map(w -> ImmutableMap.of("bar", "foo", "foo", "bar").getOrDefault(w, w))
        .collect(Collectors.joining());

• Rechercher des expressions régulières ( ?<=, ?=): http://www.regular-expressions.info/lookaround.html
• Si les mots peuvent contenir des caractères regex spéciaux, utilisez Pattern.quote pour les échapper.
• J'utilise goyava ImmutableMap pour plus de concision, mais évidemment toute autre carte fera également l'affaire.

Voici une possibilité de flux Java 8 qui pourrait être intéressante pour certains:

String word1 = "bar";
String word2 = "foo";

String story = "Once upon a time, there was a foo and a bar.";

// Map is from untranslated word to translated word
Map<String, String> wordMap = new HashMap<>();
wordMap.put(word1, word2);
wordMap.put(word2, word1);

// Split on word boundaries so we retain whitespace.
String translated = Arrays.stream(story.split("\\b"))
    .map(w -> wordMap.getOrDefault(w,  w))
    .collect(Collectors.joining());

System.out.println(translated);

Voici une approximation du même algorithme en Java 7:

String word1 = "bar";
String word2 = "foo";
String story = "Once upon a time, there was a foo and a bar.";

// Map is from untranslated word to translated word
Map<String, String> wordMap = new HashMap<>();
wordMap.put(word1, word2);
wordMap.put(word2, word1);

// Split on word boundaries so we retain whitespace.
StringBuilder translated = new StringBuilder();
for (String w : story.split("\\b"))
{
  String tw = wordMap.get(w);
  translated.append(tw != null ? tw : w);
}

System.out.println(translated);

Si vous souhaitez remplacer des mots dans une phrase qui sont séparés par un espace comme indiqué dans votre exemple, vous pouvez utiliser cet algorithme simple.

1. Histoire partagée sur un espace blanc
2. Remplacez chaque élément, si foo remplacez-le par bar et vice-varsa
3. Rejoignez le tableau en une seule chaîne

Si le fractionnement sur l'espace n'est pas acceptable, on peut suivre cet algorithme alternatif. Vous devez d'abord utiliser la chaîne la plus longue. Si les chaînes sont foo et foo, vous devez d'abord utiliser foo, puis foo.

1. Diviser sur le mot foo
2. Remplacez bar par foo chaque élément du tableau
3. Rejoignez ce tableau en ajoutant une barre après chaque élément sauf le dernier

Voici une réponse moins compliquée avec Map.

private static String replaceEach(String str,Map<String, String> map) {

         Object[] keys = map.keySet().toArray();
         for(int x = 0 ; x < keys.length ; x ++ ) {
             str = str.replace((String) keys[x],"%"+x);
         }

         for(int x = 0 ; x < keys.length ; x ++) {
             str = str.replace("%"+x,map.get(keys[x]));
         }
         return str;
     }

Et la méthode s'appelle

Map<String, String> replaceStr = new HashMap<>();
replaceStr.put("Raffy","awesome");
replaceStr.put("awesome","Raffy");
String replaced = replaceEach("Raffy is awesome, awesome awesome is Raffy Raffy", replaceStr);

Le résultat est: génial est Raffy, Raffy Raffy est génial génial

Si vous souhaitez pouvoir gérer plusieurs occurrences des chaînes de recherche à remplacer, vous pouvez le faire facilement en fractionnant la chaîne sur chaque terme de recherche, puis en la remplaçant. Voici un exemple:

String regex = word1 + "|" + word2;
String[] values = Pattern.compile(regex).split(story);

String result;
foreach subStr in values
{
   subStr = subStr.replace(word1, word2);
   subStr = subStr.replace(word2, word1);
   result += subStr;
}

Vous pouvez atteindre votre objectif avec le bloc de code suivant:

String word1 = "bar";
String word2 = "foo";
String story = "Once upon a time, in a foo, there was a foo and a bar.";
story = String.format(story.replace(word1, "%1$s").replace(word2, "%2$s"),
    word2, word1);

Il remplace les mots quel que soit l'ordre. Vous pouvez étendre ce principe dans une méthode utilitaire, comme:

private static String replace(String source, String[] targets, String[] replacements) throws IllegalArgumentException {
    if (source == null) {
        throw new IllegalArgumentException("The parameter \"source\" cannot be null.");
    }

    if (targets == null || replacements == null) {
        throw new IllegalArgumentException("Neither parameters \"targets\" or \"replacements\" can be null.");
    }

    if (targets.length == 0 || targets.length != replacements.length) {
        throw new IllegalArgumentException("The parameters \"targets\" and \"replacements\" must have at least one item and have the same length.");
    }

    String outputMask = source;
    for (int i = 0; i < targets.length; i++) {
        outputMask = outputMask.replace(targets[i], "%" + (i + 1) + "$s");
    }

    return String.format(outputMask, (Object[])replacements);
}

Qui serait consommé comme:

String story = "Once upon a time, in a foo, there was a foo and a bar.";
story = replace(story, new String[] { "bar", "foo" },
    new String[] { "foo", "bar" }));

Cela fonctionne et est simple:

public String replaceBoth(String text, String token1, String token2) {            
    return text.replace(token1, "\ufdd0").replace(token2, token1).replace("\ufdd0", token2);
    }

Vous l'utilisez comme ceci:

replaceBoth("Once upon a time, there was a foo and a bar.", "foo", "bar");

Remarque: cela compte sur les chaînes ne contenant pas de caractère \ufdd0, qui est un caractère réservé en permanence à un usage interne par Unicode (voir http://www.unicode.org/faq/private_use.html ):

Je ne pense pas que ce soit nécessaire, mais si vous voulez être absolument sûr, vous pouvez utiliser:

public String replaceBoth(String text, String token1, String token2) {
    if (text.contains("\ufdd0") || token1.contains("\ufdd0") || token2.contains("\ufdd0")) throw new IllegalArgumentException("Invalid character.");
    return text.replace(token1, "\ufdd0").replace(token2, token1).replace("\ufdd0", token2);
    }

Échange d'une seule occurrence

S'il n'y a qu'une seule occurrence de chacune des chaînes échangeables dans l'entrée, vous pouvez effectuer les opérations suivantes:

Avant de procéder à tout remplacement, récupérez les indices des occurrences des mots. Après cela, nous ne remplaçons que le mot trouvé à ces index, et non toutes les occurrences. Cette solution utilise StringBuilderet ne produit pas des intermédiaires Stringcomme String.replace().

Une chose à noter: si les mots échangeables ont des longueurs différentes, après le premier remplacement, le deuxième index peut changer (si le 1er mot se produit avant le 2ème) exactement avec la différence des 2 longueurs. Donc, aligner le deuxième index garantira que cela fonctionne même si nous échangeons des mots de différentes longueurs.

public static String swap(String src, String s1, String s2) {
    StringBuilder sb = new StringBuilder(src);
    int i1 = src.indexOf(s1);
    int i2 = src.indexOf(s2);

    sb.replace(i1, i1 + s1.length(), s2); // Replace s1 with s2
    // If s1 was before s2, idx2 might have changed after the replace
    if (i1 < i2)
        i2 += s2.length() - s1.length();
    sb.replace(i2, i2 + s2.length(), s1); // Replace s2 with s1

    return sb.toString();
}

Permutation du nombre arbitraire d'occurrences

Comme dans le cas précédent, nous allons d'abord collecter les index (occurrences) des mots, mais dans ce cas, il s'agira d'une liste d'entiers pour chaque mot, pas seulement un int. Pour cela, nous utiliserons la méthode utilitaire suivante:

public static List<Integer> occurrences(String src, String s) {
    List<Integer> list = new ArrayList<>();
    for (int idx = 0;;)
        if ((idx = src.indexOf(s, idx)) >= 0) {
            list.add(idx);
            idx += s.length();
        } else
            return list;
}

Et en utilisant cela, nous remplacerons les mots par l'autre en diminuant l'indice (ce qui peut nécessiter d'alterner entre les 2 mots échangeables) afin que nous n'ayons même pas à corriger les index après un remplacement:

public static String swapAll(String src, String s1, String s2) {
    List<Integer> l1 = occurrences(src, s1), l2 = occurrences(src, s2);

    StringBuilder sb = new StringBuilder(src);

    // Replace occurrences by decreasing index, alternating between s1 and s2
    for (int i1 = l1.size() - 1, i2 = l2.size() - 1; i1 >= 0 || i2 >= 0;) {
        int idx1 = i1 < 0 ? -1 : l1.get(i1);
        int idx2 = i2 < 0 ? -1 : l2.get(i2);
        if (idx1 > idx2) { // Replace s1 with s2
            sb.replace(idx1, idx1 + s1.length(), s2);
            i1--;
        } else { // Replace s2 with s1
            sb.replace(idx2, idx2 + s2.length(), s1);
            i2--;
        }
    }

    return sb.toString();
}

Il est facile d'écrire une méthode pour faire cela en utilisant String.regionMatches:

public static String simultaneousReplace(String subject, String... pairs) {
    if (pairs.length % 2 != 0) throw new IllegalArgumentException(
        "Strings to find and replace are not paired.");
    StringBuilder sb = new StringBuilder();
    outer:
    for (int i = 0; i < subject.length(); i++) {
        for (int j = 0; j < pairs.length; j += 2) {
            String find = pairs[j];
            if (subject.regionMatches(i, find, 0, find.length())) {
                sb.append(pairs[j + 1]);
                i += find.length() - 1;
                continue outer;
            }
        }
        sb.append(subject.charAt(i));
    }
    return sb.toString();
}

Essai:

String s = "There are three cats and two dogs.";
s = simultaneousReplace(s,
    "cats", "dogs",
    "dogs", "budgies");
System.out.println(s);

Production:

Il y a trois chiens et deux perruches.

Ce n'est pas immédiatement évident, mais une fonction comme celle-ci peut toujours dépendre de l'ordre dans lequel les remplacements sont spécifiés. Considérer:

String truth = "Java is to JavaScript";
truth += " as " + simultaneousReplace(truth,
    "JavaScript", "Hamster",
    "Java", "Ham");
System.out.println(truth);

Production:

Java est à JavaScript comme Ham est à Hamster

Mais inversez les remplacements:

truth += " as " + simultaneousReplace(truth,
    "Java", "Ham",
    "JavaScript", "Hamster");

Production:

Java est à JavaScript comme Ham est à HamScript

Oups! :)

Par conséquent, il est parfois utile de s'assurer de rechercher la correspondance la plus longue (comme le fait la strtrfonction PHP , par exemple). Cette version de la méthode fera cela:

public static String simultaneousReplace(String subject, String... pairs) {
    if (pairs.length % 2 != 0) throw new IllegalArgumentException(
        "Strings to find and replace are not paired.");
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < subject.length(); i++) {
        int longestMatchIndex = -1;
        int longestMatchLength = -1;
        for (int j = 0; j < pairs.length; j += 2) {
            String find = pairs[j];
            if (subject.regionMatches(i, find, 0, find.length())) {
                if (find.length() > longestMatchLength) {
                    longestMatchIndex = j;
                    longestMatchLength = find.length();
                }
            }
        }
        if (longestMatchIndex >= 0) {
            sb.append(pairs[longestMatchIndex + 1]);
            i += longestMatchLength - 1;
        } else {
            sb.append(subject.charAt(i));
        }
    }
    return sb.toString();
}

Notez que les méthodes ci-dessus sont sensibles à la casse. Si vous avez besoin d'une version insensible à la casse, il est facile de modifier ce qui précède car String.regionMatchespeut prendre un ignoreCaseparamètre.

Si vous ne voulez pas de dépendances, vous pouvez simplement utiliser un tableau qui n'autorise qu'une seule modification. Ce n'est pas la solution la plus efficace, mais elle devrait fonctionner.

public String replace(String sentence, String[]... replace){
    String[] words = sentence.split("\\s+");
    int[] lock = new int[words.length];
    StringBuilder out = new StringBuilder();

    for (int i = 0; i < words.length; i++) {
        for(String[] r : replace){
            if(words[i].contains(r[0]) && lock[i] == 0){
                words[i] = words[i].replace(r[0], r[1]);
                lock[i] = 1;
            }
        }

        out.append((i < (words.length - 1) ? words[i] + " " : words[i]));
    }

    return out.toString();
}

Ensuite, cela fonctionnerait.

String story = "Once upon a time, there was a foo and a bar.";

String[] a = {"foo", "bar"};
String[] b = {"bar", "foo"};
String[] c = {"there", "Pocahontas"};
story = replace(story, a, b, c);

System.out.println(story); // Once upon a time, Pocahontas was a bar and a foo.

Vous effectuez plusieurs opérations de recherche-remplacement sur l'entrée. Cela produira des résultats indésirables lorsque les chaînes de remplacement contiennent des chaînes de recherche. Prenons l'exemple de foo-> bar, bar-foo, voici les résultats pour chaque itération:

1. Il était une fois un foo et un bar. (contribution)
2. Il était une fois un bar et un bar. (foo-> bar)
3. Il était une fois un foo et un foo. (bar-> foo, sortie)

Vous devez effectuer le remplacement en une seule itération sans revenir en arrière. Une solution de force brute est la suivante:

1. Rechercher l'entrée de la position actuelle à la fin pour plusieurs chaînes de recherche jusqu'à ce qu'une correspondance soit trouvée
2. Remplacez la chaîne de recherche correspondante par la chaîne de remplacement correspondante
3. Définit la position actuelle sur le caractère suivant après la chaîne remplacée
4. Répéter

Une fonction telle que String.indexOfAny(String[]) -> int[]{index, whichString}serait utile. Voici un exemple (pas le plus efficace):

private static String replaceEach(String str, String[] searchWords, String[] replaceWords) {
    String ret = "";
    while (str.length() > 0) {
        int i;
        for (i = 0; i < searchWords.length; i++) {
            String search = searchWords[i];
            String replace = replaceWords[i];
            if (str.startsWith(search)) {
                ret += replace;
                str = str.substring(search.length());
                break;
            }
        }
        if (i == searchWords.length) {
            ret += str.substring(0, 1);
            str = str.substring(1);
        }
    }
    return ret;
}

Quelques tests:

System.out.println(replaceEach(
    "Once upon a time, there was a foo and a bar.",
    new String[]{"foo", "bar"},
    new String[]{"bar", "foo"}
));
// Once upon a time, there was a bar and a foo.

System.out.println(replaceEach(
    "a p",
    new String[]{"a", "p"},
    new String[]{"apple", "pear"}
));
// apple pear

System.out.println(replaceEach(
    "ABCDE",
    new String[]{"A", "B", "C", "D", "E"},
    new String[]{"B", "C", "E", "E", "F"}
));
// BCEEF

System.out.println(replaceEach(
    "ABCDEF",
    new String[]{"ABCDEF", "ABC", "DEF"},
    new String[]{"XXXXXX", "YYY", "ZZZ"}
));
// XXXXXX
// note the order of search strings, longer strings should be placed first 
// in order to make the replacement greedy

Démo sur IDEONE
Démo sur IDEONE, code alternatif

Vous pouvez toujours le remplacer par un mot dont vous êtes sûr qu'il n'apparaîtra nulle part ailleurs dans la chaîne, puis effectuer le deuxième remplacement plus tard:

String word1 = "bar";
String word2 = "foo";
String story = "Once upon a time, there was a foo and a bar."
story = story.replace("foo", "StringYouAreSureWillNeverOccur").replace("bar", "word2").replace("StringYouAreSureWillNeverOccur", "word1");

Notez que cela ne fonctionnera pas correctement si "StringYouAreSureWillNeverOccur"cela se produit.

Envisagez d'utiliser StringBuilder

Ensuite, stockez l'index à l'endroit où chaque chaîne doit commencer. Si vous utilisez un caractère d'espace réservé à chaque position, supprimez-le et insérez la chaîne d'utilisateurs. Vous pouvez ensuite mapper la position de fin en ajoutant la longueur de chaîne à la position de départ.

String firstString = "???";
String secondString  = "???"

StringBuilder story = new StringBuilder("One upon a time, there was a " 
    + firstString
    + " and a "
    + secondString);

int  firstWord = 30;
int  secondWord = firstWord + firstString.length() + 7;

story.replace(firstWord, firstWord + firstString.length(), userStringOne);
story.replace(secondWord, secondWord + secondString.length(), userStringTwo);

firstString = userStringOne;
secondString = userStringTwo;

return story;

Ce que je ne peux partager, c'est ma propre méthode.

Vous pouvez utiliser un temporaire String temp = "<?>";ouString.Format();

Ceci est mon exemple de code créé dans l'application console via c # - "Idée seulement, pas de réponse exacte" .

static void Main(string[] args)
    {
        String[] word1 = {"foo", "Once"};
        String[] word2 = {"bar", "time"};
        String story = "Once upon a time, there was a foo and a bar.";

        story = Switcher(story,word1,word2);
        Console.WriteLine(story);
        Console.Read();
    }
    // Using a temporary string.
    static string Switcher(string text, string[] target, string[] value)
    {
        string temp = "<?>";
        if (target.Length == value.Length)
        {
            for (int i = 0; i < target.Length; i++)
            {
                text = text.Replace(target[i], temp);
                text = text.Replace(value[i], target[i]);
                text = text.Replace(temp, value[i]);
            }
        }
        return text;
    }

Ou vous pouvez également utiliser le String.Format();

static string Switcher(string text, string[] target, string[] value)
        {
            if (target.Length == value.Length)
            {
                for (int i = 0; i < target.Length; i++)
                {
                    text = text.Replace(target[i], "{0}").Replace(value[i], "{1}");
                    text = String.Format(text, value[i], target[i]);
                }
            }
            return text;
        }

Production: time upon a Once, there was a bar and a foo.

Voici ma version, qui est basée sur des mots:

class TextReplace
{

    public static void replaceAll (String text, String [] lookup,
                                   String [] replacement, String delimiter)
    {

        String [] words = text.split(delimiter);

        for (int i = 0; i < words.length; i++)
        {

            int j = find(lookup, words[i]);

            if (j >= 0) words[i] = replacement[j];

        }

        text = StringUtils.join(words, delimiter);

    }

    public static  int find (String [] array, String key)
    {

        for (int i = 0; i < array.length; i++)
            if (array[i].equals(key))
                return i;

        return (-1);

    }

}

String word1 = "bar";
String word2 = "foo";
String story = "Once upon a time, there was a foo and a bar."

Petite manière délicate mais vous devez faire quelques vérifications supplémentaires.

1. convertir la chaîne en tableau de caractères

   String temp[] = story.split(" ");//assume there is only spaces.

2. bouclez sur temp et remplacez foopar baret barpar foocar il n'y a aucune chance d'obtenir à nouveau une chaîne remplaçable.

Eh bien, la réponse la plus courte est ...

String word1 = "bar";
String word2 = "foo";
String story = "Once upon a time, there was a foo and a bar.";
story = story.replace("foo", "@"+ word1).replace("bar", word2).replace("@" + word2, word1);
System.out.println(story);

En utilisant la réponse trouvée ici, vous pouvez trouver toutes les occurrences des chaînes que vous souhaitez remplacer.

Ainsi, par exemple, vous exécutez le code dans la réponse SO ci-dessus. Créez deux tables d'index (disons que bar et foo n'apparaissent pas une seule fois dans votre chaîne) et vous pouvez travailler avec ces tables pour les remplacer dans votre chaîne.

Maintenant, pour remplacer sur des emplacements d'index spécifiques, vous pouvez utiliser:

public static String replaceStringAt(String s, int pos, String c) {
   return s.substring(0,pos) + c + s.substring(pos+1);
}

Alors que posc'est l'index où vos chaînes commencent (à partir des tables d'index que j'ai citées ci-dessus). Disons que vous avez créé deux tables d'index pour chacun. Appelons-les indexBaret indexFoo.

Maintenant, en les remplaçant, vous pouvez simplement exécuter deux boucles, une pour chaque remplacement que vous souhaitez effectuer.

for(int i=0;i<indexBar.Count();i++)
replaceStringAt(originalString,indexBar[i],newString);

De même une autre boucle pour indexFoo.

Cela n'est peut-être pas aussi efficace que d'autres réponses ici, mais c'est plus simple à comprendre que Maps ou d'autres choses.

Cela vous donnerait toujours le résultat souhaité et pour plusieurs occurrences possibles de chaque chaîne. Tant que vous stockez l'index de chaque occurrence.

De plus, cette réponse ne nécessite aucune récursivité ni aucune dépendance externe. En ce qui concerne la complexité, elle est probablement O (n au carré), alors que n est la somme des occurrences des deux mots.

J'ai développé ce code résoudra le problème:

public static String change(String s,String s1, String s2) {
   int length = s.length();
   int x1 = s1.length();
   int x2 = s2.length();
   int x12 = s.indexOf(s1);
   int x22 = s.indexOf(s2);
   String s3=s.substring(0, x12);
   String s4 =s.substring(x12+3, x22);
   s=s3+s2+s4+s1;
   return s;
}

Dans l'utilisation principale change(story,word2,word1).

String word1 = "bar";
String word2 = "foo";

String story = "Once upon a time, there was a foo and a bar."

story = story.replace("foo", "<foo />");
story = story.replace("bar", "<bar />");

story = story.replace("<foo />", word1);
story = story.replace("<bar />", word2);