android多国语言字符串翻译处理技巧

问题描述:

    假设要对android中的字符中进行翻译, 可以选择导出英文字符串资源, 然后对照翻译, 如果字符串中包含特殊字符& < > " ',

    如： <string>  i have &amp; a apple</string>

    翻译人员会觉得很奇怪, 所以可以将这些特殊字符转换成对应的字符后导出，如& < > 等, 最后翻译好后, 再将那些字符转换回去,不转换会编译报错

解题思路:

     1.利用正则表达式,  以<>为模版, 将已经翻译好的字符串分离成2个列表,   一个放正常的tag，如<string>,  另一个放其他的字符串

     2.将需要转换的字符转换回去

     3.合并2个列表

具体代码如下:

    private String convert(String value) {
        String result = value;
        System.out.println("origin: " + value);
        Pattern pattern = Pattern.compile("\\<[\\s\\S]*?\\>");
        Matcher matcher = pattern.matcher(result);
        boolean match = false;
        ArrayList<Integer> indexList = new ArrayList<Integer>();
        ArrayList<String> strList = new ArrayList<String>();
        ArrayList<String> tagList = new ArrayList<String>();
        ArrayList<String> notagList = new ArrayList<String>();

        while (matcher.find()) {
            match = true;
            indexList.add(matcher.start());
            indexList.add(matcher.end());
            tagList.add(value.substring(matcher.start(), matcher.end()));
        }

        if (match) {
            strList.add(value.substring(0, indexList.get(0)));
            for (int i = 0; i < indexList.size(); i++) {
                if (i + 1 < indexList.size()) {
                    strList.add(value.substring(indexList.get(i),
                            indexList.get(i + 1)));
                }
            }
            strList.add(value.substring(indexList.get(indexList.size() - 1)));

            for (int i = 0; i < strList.size(); i++) {

                if (i % 2 == 0 || i == strList.size() - 1) {
                    notagList.add(strList.get(i));
                }
            }

            System.out.println("strList: " + strList.toString());

            System.out.println("before nottagList: " + notagList.toString());
            processNoTagList(notagList);
            System.out.println("after nottagList: " + notagList.toString());

            System.out.println("before tagList: " + tagList.toString());

            ArrayList<String> processedTagList = new ArrayList<String>();

            if(tagList.size() > 2) {
                ArrayList<Integer> spliteIndexList = splitTagList(tagList);
                System.out.println("tagList: " + tagList.toString());

                for(int i = 0; i < spliteIndexList.size(); i = i + 2) {
                    int firstIndex = spliteIndexList.get(i);
                    int secondIndex = spliteIndexList.get(i + 1);
                    ArrayList<String> subTagList = new ArrayList<String>();
                    for(int j = firstIndex; j <= secondIndex; j++ ) {
                        subTagList.add(tagList.get(j));
                    }
                    System.out.println("i: " + i);
                    System.out.println("before subTagList: " + subTagList.toString());
                    processedTagList.addAll(processTagList(subTagList));
                }
            } else {
                processedTagList = processTagList(tagList);
            }

            //System.out.println("allTagList: " + allTagList.toString());

            if (strList.size() != processedTagList.size() + notagList.size()
                    && notagList.size() - processedTagList.size() != 1) {
                System.out
                        .println("error: "
                                + "strList size not equals processedTagList size plus notagList size");
            }

            System.out.println("begin mergerList: " + strList.toString());
            result = mergerList(processedTagList, notagList);

        } else {
            strList.add(value);
            processNoTagList(strList);
            result = strList.get(0);
        }

        System.out.println("result: " + result);
        System.out.println("------------------------------------------------------------------------------");

        return result;
    }

    private ArrayList<Integer> splitTagList(ArrayList<String> tagList) {
        ArrayList<Integer> spliteIndexList = new ArrayList<Integer> ();
        String firstTag = "";
        int theSameTag = 0;
        boolean updateFirstTag = true;

        for(int i = 0; i < tagList.size(); i++) {
            if(updateFirstTag) {
                firstTag = tagList.get(i).substring(0,tagList.get(i).replace(">", " ").indexOf(" ")) + ">";
                spliteIndexList.add(i);
            }

            if(i != 0 &&
                    updateFirstTag == false &&
                    (tagList.get(i).substring(0,tagList.get(i).replace(">", " ").indexOf(" ")) + ">")
                            .equals(firstTag)) {
                theSameTag++;

            }

            updateFirstTag = false;

            if(tagList.get(i).startsWith("</")
                    && ("<" +tagList.get(i).substring(2,tagList.get(i).length() -1) + ">").equals(firstTag)
                    && theSameTag == 0) {

                spliteIndexList.add(i);
                updateFirstTag = true;
            } else if(i != 0 &&
                    tagList.get(i).startsWith("</") &&
                    ("<" +tagList.get(i).substring(2,tagList.get(i).length() -1) + ">").equals(firstTag) &&
                    tagList.get(i).substring(2,tagList.get(i).length() -1)
                            .equals(tagList.get(i - 1).substring(1,tagList.get(i - 1).replace(">", " ").indexOf(" ")))) {
                theSameTag--;

            } else if(tagList.get(i).endsWith("/>") &&
                    (tagList.get(i).substring(0,tagList.get(i).replace(">", " ").indexOf(" ")) + ">").equals(firstTag)) {
                spliteIndexList.add(i);
                updateFirstTag = true;
            } else {
                continue;
            }
        }


        if(spliteIndexList.size() % 2 != 0) {
            spliteIndexList.add(tagList.size() - 1);
        }
        System.out.println("spliteIndexList: " + spliteIndexList);
        return spliteIndexList;
    }

    private String mergerList(ArrayList<String> tagList,
                                     ArrayList<String> notagList) {
        int index = 0;
        StringBuilder build = new StringBuilder();
        while (index < tagList.size()) {
            build.append(notagList.get(index) + tagList.get(index));
            index++;
        }
        build.append(notagList.get(index));

        return build.toString();
    }



    private ArrayList<String> processTagList(ArrayList<String> tagList) {
        ArrayList<String> pairTagList = new ArrayList<String>();
        ArrayList<Integer> pairTagListIndexInTaglist = new ArrayList<Integer>();
        ArrayList<String> nestedTagList = new ArrayList<String>();
        ArrayList<Integer> nestedTagListIndexInTaglist = new ArrayList<Integer>();
        ArrayList<String> mergerTagList = new ArrayList<String>();

        for(int i = 0; i < tagList.size(); i++) {
            String hopeTag = "", nextTag;
            if(pairTagListIndexInTaglist.contains(i)) {
                continue;
            }

            if(nestedTagList.size() > 0 && tagList.get(i).startsWith("</")) {
                hopeTag = "<" + tagList.get(i).substring(2,tagList.get(i).length() - 1);
                if(nestedTagList.get(nestedTagList.size() -1).startsWith(hopeTag)) {
                    pairTagList.add(nestedTagList.remove(nestedTagList.size() -1));
                    pairTagList.add(tagList.get(i));
                    pairTagListIndexInTaglist.add(nestedTagListIndexInTaglist.remove(nestedTagListIndexInTaglist.size() -1));
                    pairTagListIndexInTaglist.add(i);
                    continue;
                }
            }

            hopeTag = "</"+ tagList.get(i).substring(1,tagList.get(i).replace(">", " ").indexOf(" ")) + ">";


            if(i + 1 < tagList.size()) {
                nextTag = tagList.get(i+ 1);
            } else {
                nextTag = null;
            }

            if(nextTag != null && nextTag.equals(hopeTag)) {
                if(!pairTagListIndexInTaglist.contains(i)) {
                    pairTagList.add(tagList.get(i));
                    pairTagList.add(tagList.get(i + 1));
                    pairTagListIndexInTaglist.add(i);
                    pairTagListIndexInTaglist.add(i + 1);
                    i++;
                }

            } else if(tagList.get(i).endsWith("/>")) {
                if(!pairTagListIndexInTaglist.contains(i)) {
                    pairTagList.add(tagList.get(i));
                pairTagListIndexInTaglist.add(i);
            }
            } else {
                nestedTagList.add(tagList.get(i));
                nestedTagListIndexInTaglist.add(i);
            }

        }

        System.out.println("----pairTagList: " + pairTagList);
        System.out.println("----pairTagListIndexInTaglist: " + pairTagListIndexInTaglist);
        System.out.println("----nestedTagList: " + nestedTagList);
        System.out.println("----nestedTagListIndexInTaglist: " + nestedTagListIndexInTaglist);


        if(nestedTagList.size() > 0) {
            int halfTag = nestedTagList.size() % 2 == 0 ? nestedTagList.size() / 2 : (nestedTagList
                    .size() / 2) + 1;
            System.out.println("----halfTag: " + halfTag);
            for (int i = 0; i < nestedTagList.size(); i++) {
                String hopeTag, hopeTagPrefix;
                String realTag;


                if (i < halfTag) {
                    hopeTag = "</"
                            + nestedTagList.get(i).substring(1,
                            nestedTagList.get(i).replace(">", " ").indexOf(" ")).trim()
                            + ">";
                    realTag = nestedTagList.get(nestedTagList.size() - i - 1);
                    if (!hopeTag.equals(realTag)) {
                        System.out.println("----error tagIndex: " + i + " hopeTag: "
                                + hopeTag + " realTag: " + realTag);
                        nestedTagList.set(i, "&lt;" + nestedTagList.get(i).substring(1));
                    }
                } else {
                    hopeTag = "<" + nestedTagList.get(i).substring(2);
                    hopeTagPrefix = hopeTag.substring(0, hopeTag.length() - 1);
                    realTag = nestedTagList.get(nestedTagList.size() - i - 1);
                    if (!realTag.startsWith(hopeTagPrefix)) {
                        System.out.println("----error tagIndex: " + i
                                + " hopeTagPrefix: " + hopeTagPrefix + " realTag: "
                                + realTag);
                        if(!realTag.contains(hopeTagPrefix))
                            nestedTagList.set(i, "&lt;" + nestedTagList.get(i).substring(1));
                    }

                }
            }
        }


        for(int i = 0; i < tagList.size(); i ++) {
            if(pairTagListIndexInTaglist.contains(i)) {
                mergerTagList.add(pairTagList.get(pairTagListIndexInTaglist.indexOf(i)));
            } else if(nestedTagListIndexInTaglist.contains(i)) {
                mergerTagList.add(nestedTagList.get(nestedTagListIndexInTaglist.indexOf(i)));
            }
        }
        System.out.println("----mergerTagList: " + mergerTagList);
        return mergerTagList;

    }

    private ArrayList<String> processNoTagList(
            ArrayList<String> notagList) {
        for (int i = 0; i < notagList.size(); i++) {
            if (notagList.get(i).equals(" ")) {
                continue;
            }
            // do not adjust the order of contains("&")
            if (notagList.get(i).contains("&")) {
                notagList.set(i, notagList.get(i).replace("&", "&amp;"));
            }

            if (notagList.get(i).contains("<")) {
                notagList.set(i, notagList.get(i).replace("<", "&lt;"));
            }

            if (notagList.get(i).contains(">")) {
                notagList.set(i, notagList.get(i).replace(">", "&gt;"));
            }

            if (notagList.get(i).contains("\"")) {
                if(notagList.get(i).startsWith("\"") && notagList.get(i).endsWith("\"")
                        && !notagList.get(i).equals("\"")
                        && !notagList.get(i).equals("\"\"")) {
                    notagList.set(i,
                            notagList.get(i).substring(0,1) +
                                    notagList.get(i).substring(1,notagList.get(i).length() - 1).replace("\"", "&quot") +
                                    notagList.get(i).substring(notagList.get(i).length() - 1));
                } else {
                    notagList.set(i, notagList.get(i).replace("\"", "&quot;"));
                }

            }

            if (notagList.get(i).contains("'")) {
                if(notagList.get(i).indexOf("'") != 0 &&
                        !notagList.get(i).substring(notagList.get(i).indexOf("'") - 1, notagList.get(i).indexOf("'")).equals("\\")) {
                notagList.set(i, notagList.get(i).replace("'", "\\&apos;"));
            }
        }

        }
        return notagList;
    }