在后续迭代中不影响替换文本的多个字符串替换

Question

我之前已经发布过关于信件的文章，但这是另一个主题，我有一个包含两个对象的json响应，from和to，from是要更改的内容，to是要更改的对象。

我的代码是：

// for example, the EnteredText is "ab b test a b" .
EnteredString = EnteredText.getText().toString();
for (int i = 0; i < m_jArry.length(); i++) {
    JSONObject jo_inside = m_jArry.getJSONObject(i);

    String Original = jo_inside.getString("from");
    String To = jo_inside.getString("to");

    if(isMethodConvertingIn){
        EnteredString = EnteredString.replace(" ","_");
        EnteredString = EnteredString.replace(Original,To + " ");
    } else {
        EnteredString = EnteredString.replace("_"," ");
        EnteredString = EnteredString.replace(To + " ", Original);
    }
}

LoadingProgress.setVisibility(View.GONE);
SetResultText(EnteredString);
ShowResultCardView();

例如，json响应是：

{
    "Response":[
        {"from":"a","to":"bhduh"},{"from":"b","to":"eieja"},{"from":"tes","to":"neesj"}
    ]
}

String.replace()方法在这里不能工作，因为它首先将a替换为bhduh，然后将b替换为eieja，但问题是，它将把bhduh中的b转换为eieja，我不想这样做。

我想完全转换字母和字符串中的“单词”按照Json，但这是我的失败。

新法典：

if(m_jArry.length() > 0){
    HashMap<String, String> m_li;

    EnteredString = EnteredText.getText().toString();

    Log.i("TestAf_","Before Converting: "  + EnteredString);

    HashMap<String,String> replacements = new HashMap<String,String>();
    for (int i = 0; i < m_jArry.length(); i++) {
        JSONObject jo_inside = m_jArry.getJSONObject(i);

        String Original = jo_inside.getString("from");
        String To = jo_inside.getString("to");

        if(isMethodConvertingIn){

            //EnteredString = EnteredString.replace(" ","_");

            replacements.put(Original,To);
            Log.i("TestAf_","From: " + Original + " - To: " + To + " - Loop: " + i);
            //EnteredString = EnteredString.replace(" ","_");
            //EnteredString = EnteredString.replace(Original,To + " ");

        } else {

            EnteredString = EnteredString.replace("_"," ");
            EnteredString = EnteredString.replace("'" + To + "'", Original);
        }

    }
    Log.i("TestAf_","After Converting: " + replaceTokens(EnteredString,replacements));

    // Replace Logic Here
    // When Finish, Do :
    LoadingProgress.setVisibility(View.GONE);
    SetResultText(replaceTokens(EnteredString,replacements));
    ShowResultCardView();

产出：

10-10 19:51:19.757 12113-12113/? I/TestAf_: Before Converting: ab a ba
10-10 19:51:19.757 12113-12113/? I/TestAf_: From: a - To: bhduh - Loop: 0
10-10 19:51:19.757 12113-12113/? I/TestAf_: From: b - To: eieja - Loop: 1
10-10 19:51:19.757 12113-12113/? I/TestAf_: From: o - To: neesj - Loop: 2
10-10 19:51:19.758 12113-12113/? I/TestAf_: After Converting: ab a ba

Answer 1

以下是一种严格意义上的Java方法。在这里，我试图不使用任何Java 8方法。

public static String translate(final String str, List<String> from, List<String> to, int index) {
    StringBuilder components = new StringBuilder();
    String token, replace;
    int p;

    if (index < from.size()) {
        token = from.get(index);
        replace = to.get(index);
        p = 0;

        for (int i = str.indexOf(token, p); i != -1; i = str.indexOf(token, p)) {
            if (i != p) {
                components.append(translate(str.substring(p, i), from, to, index + 1));
            }
            components.append(replace);
            p = i + token.length();
        }
        return components.append(translate(str.substring(p), from, to, index + 1)).toString();
    }

    return str;
}

public static String translate(final String str, List<String> from, List<String> to) {
    if (null == str) {
        return null;
    }
    return translate(str, from, to, 0);
}

样本测试程序

public static void main(String []args) {
    String EnteredString = "aa  hjkyu  batesh  a";
    List<String> from = new ArrayList<>(Arrays.asList("a", "b", "tes"));
    List<String> to = new ArrayList<>(Arrays.asList("bhduh", "eieja", "neesj"));

    System.out.println(translate(EnteredString, from, to));
}

输出：

bhduhbhduh  hjkyu  eiejabhduhneesjh  bhduh

解释

该算法是递归的，它只执行以下操作

• 如果在字符串中找到的模式与from列表中的模式匹配
  • 如果在该模式之前有任何字符串，请将算法应用于该字符串。
  • 用to列表中的对应模式替换已找到的模式
  • 将替换追加到新字符串
  • 放弃from列表中的模式，并对字符串的其余部分重复算法

​

• 否则，将其余的字符串追加到新字符串中。

Answer 2

如果您给出了该函数的预期输出，您的问题就会更清楚。

假设是：ab b test a b >>>> bhduheieja eieja neesjt bhduh eieja

然后看到以下内容，Javadoc中的关键点是“这不会重复”

[http://commons.apache.org/proper/commons-lang/javadocs/api-release/org/apache/commons/lang3/StringUtils.html#replaceEach(java.lang.String,%20java.lang.String[],%20java.lang.String[])](http://commons.apache.org/proper/commons-lang/javadocs/api-release/org/apache/commons/lang3/StringUtils.html#replaceEach(java.lang.String,%20java.lang.String[],%20java.lang.String[]%29)

替换其他字符串中出现的所有字符串。传递给此方法的空引用是no，或者如果任何“搜索字符串”或“要替换的字符串”为null，则该替换将被忽略。这将不会重复。用于重复替换，调用重载的方法。

示例1

import org.apache.commons.lang3.StringUtils;

public class StringReplacer {

    public static void main(String[] args) {

        String input = "ab b test a b";
        String output = StringUtils.replaceEach(input, new String[] { "a", "b", "tes" },
                new String[] { "bhduh", "eieja", "neesj" });

        System.out.println(input + " >>>> " + output);
    }
}

示例2

import org.apache.commons.lang3.StringUtils;

public class StringReplacer {

    public static void main(String[] args) {

        String input = "this is a test string with foo";
        String output = StringUtils.replaceEach(input, new String[] { "a", "foo" },
                new String[] { "foo", "bar"});

        System.out.println(input + " >>>> " + output);
    }
}

Answer 3

尝试以下几个方面：

解决方案1:逐个遍历String字符并将新的String移动到新的StringBuffer或StringBuilder，然后调用toString()以获得结果。这将需要您实现字符串匹配算法。

解决方案2(使用Regex):为此，您必须知道您的字符串的域。例如，它是[a-zA-Z]，那么其他任意字符(不是域的一部分)可以用于中间步骤。首先将实际字符替换为任意字符，然后将任意字符替换为目标。在下面的示例中，[!@#]是任意字符。这些值也可以是任意的随机\uxxxx值。

String input = "a-b-c";
String output = input.replaceAll("[a]", "!").replaceAll("[b]", "@").replaceAll("[c]", "#");
output = output.replaceAll("[!]", "bcd").replaceAll("[@]", "cde").replaceAll("[#]", "def");
System.out.println("input: " + input);
System.out.println("Expected: bcd-cde-def");
System.out.println("Actual: " + output);