Java 如何使用字符串的索引将字符替换为字符串

嗨，用字符串替换字符的最佳方法是什么：例如：

在我的例子中，我有一个包含拉丁字符和符号的字符串，我用intermec打印机打印它 说明：

 instruction CHR$(<dec. ascii value>)

我写道：

if (!isValid(str)) {
    Map charsAsciiCode = new HashMap();
    for (int i = 0; i < str.length(); i++) {
        String c = String.valueOf(str.charAt(i));
        if (specialCharsMap.containsKey(c)) {
            String decimalString = (String) specialCharsMap.get(c);
            charsAsciiCode.put(new Integer(i), " \";CHR$(" + decimalString + ");\"");
        }
    }

    Iterator iter = charsAsciiCode.entrySet().iterator();

    while (iter.hasNext()) {
        Map.Entry mapEntry = (Map.Entry) iter.next();
        int charIndex = (int) mapEntry.getKey();
        String charAscii = (String) mapEntry.getValue();

        // Here i want to replace every char with the correspondant Ascii value
    }
}

static boolean isValid(String input) {
    Matcher m = p.matcher(input);
    return m.matches();
}

final static Pattern p = Pattern.compile("\\p{Alpha}+");
private static Map specialCharsMap = new HashMap();

static {
    specialCharsMap.put("é", "123");
    specialCharsMap.put("è", "125");
    specialCharsMap.put("à", "64");
    specialCharsMap.put("ç", "92");
    specialCharsMap.put("^", "94");
    specialCharsMap.put("'", "39");
}

如果（！isValid（str））{
Map charsascicode=new HashMap（）；
对于（int i=0；i

至少有两种简单的方法：

迭代每个字符，并通过追加原始字符或转换后的字符来构建新字符串

迭代每个映射，并对字符串调用

replaceAll

这两个实现：

String replaceCharsByRebuilding(String str, Map<Character, String> mapping) {
    StringBuilder builder = new StringBuilder();
    for (int i = 0; i < str.length(); ++i) {
        char c = str.charAt(i);
        String replacement = mapping.get(c);
        builder.append(replacement == null ? c : replacement);
    }
    return builder.toString();
}

String replaceCharsByReplaceAll(String str, Map<Character, String> mapping) {
    for (Map.Entry<Character, String> entry : mapping.entrySet()) {
        str = str.replaceAll(entry.getKey().toString(), entry.getValue());
    }
    return str;
}

String replaceCharsByRebuilding（String str，映射）{
StringBuilder=新的StringBuilder（）；
对于（int i=0；i

---

两种方法都应该得到相同的结果，但我认为第一种方法应该更好。

至少有两种简单的方法：

迭代每个字符，并通过追加原始字符或转换后的字符来构建新字符串

迭代每个映射，并对字符串调用

replaceAll

这两个实现：

String replaceCharsByRebuilding(String str, Map<Character, String> mapping) {
    StringBuilder builder = new StringBuilder();
    for (int i = 0; i < str.length(); ++i) {
        char c = str.charAt(i);
        String replacement = mapping.get(c);
        builder.append(replacement == null ? c : replacement);
    }
    return builder.toString();
}

String replaceCharsByReplaceAll(String str, Map<Character, String> mapping) {
    for (Map.Entry<Character, String> entry : mapping.entrySet()) {
        str = str.replaceAll(entry.getKey().toString(), entry.getValue());
    }
    return str;
}

String replaceCharsByRebuilding（String str，映射）{
StringBuilder=新的StringBuilder（）；
对于（int i=0；i

---

两种方法都应该得到相同的结果，但我认为第一种方法应该更好。

至少有两种简单的方法：

迭代每个字符，并通过追加原始字符或转换后的字符来构建新字符串

迭代每个映射，并对字符串调用

replaceAll

这两个实现：

String replaceCharsByRebuilding(String str, Map<Character, String> mapping) {
    StringBuilder builder = new StringBuilder();
    for (int i = 0; i < str.length(); ++i) {
        char c = str.charAt(i);
        String replacement = mapping.get(c);
        builder.append(replacement == null ? c : replacement);
    }
    return builder.toString();
}

String replaceCharsByReplaceAll(String str, Map<Character, String> mapping) {
    for (Map.Entry<Character, String> entry : mapping.entrySet()) {
        str = str.replaceAll(entry.getKey().toString(), entry.getValue());
    }
    return str;
}

String replaceCharsByRebuilding（String str，映射）{
StringBuilder=新的StringBuilder（）；
对于（int i=0；i

---

两种方法都应该得到相同的结果，但我认为第一种方法应该更好。

至少有两种简单的方法：

迭代每个字符，并通过追加原始字符或转换后的字符来构建新字符串

迭代每个映射，并对字符串调用

replaceAll

这两个实现：

String replaceCharsByRebuilding(String str, Map<Character, String> mapping) {
    StringBuilder builder = new StringBuilder();
    for (int i = 0; i < str.length(); ++i) {
        char c = str.charAt(i);
        String replacement = mapping.get(c);
        builder.append(replacement == null ? c : replacement);
    }
    return builder.toString();
}

String replaceCharsByReplaceAll(String str, Map<Character, String> mapping) {
    for (Map.Entry<Character, String> entry : mapping.entrySet()) {
        str = str.replaceAll(entry.getKey().toString(), entry.getValue());
    }
    return str;
}

String replaceCharsByRebuilding（String str，映射）{
StringBuilder=新的StringBuilder（）；
对于（int i=0；i

---

两种方法都应该得到相同的结果，但我认为第一种方法应该更好。

您不需要

地图，因为您可以这样做：

StringBuilder sb = new StringBuilder();

for (int i = 0; i < str.length(); i = i+1) {
    char ch = str.charAt(i);
    if (ch > 127) {
        // TODO: generate all the \\""+; crap around CHR$()
        sb.append(String.format("CHR$(%d)", (int)ch));
    }
    else 
        sb.append ch;
}

StringBuilder sb=新建StringBuilder（）；
对于（int i=0；i127）{
//TODO:生成CHR$（）
sb.append（String.format（“CHR$（%d）”，（int）ch））；
}
其他的
某人；
}
您不需要
地图，因为您可以这样做：

StringBuilder sb = new StringBuilder();

for (int i = 0; i < str.length(); i = i+1) {
    char ch = str.charAt(i);
    if (ch > 127) {
        // TODO: generate all the \\""+; crap around CHR$()
        sb.append(String.format("CHR$(%d)", (int)ch));
    }
    else 
        sb.append ch;
}

StringBuilder sb=新建StringBuilder（）；
对于（int i=0；i127）{
//TODO:生成CHR$（）
sb.append（String.format（“CHR$（%d）”，（int）ch））；
}
其他的
某人；
}
您不需要
地图，因为您可以这样做：

StringBuilder sb = new StringBuilder();

for (int i = 0; i < str.length(); i = i+1) {
    char ch = str.charAt(i);
    if (ch > 127) {
        // TODO: generate all the \\""+; crap around CHR$()
        sb.append(String.format("CHR$(%d)", (int)ch));
    }
    else 
        sb.append ch;
}

StringBuilder sb=新建StringBuilder（）；
为了