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

最新推荐文章于 2025-10-11 16:25:49 发布
原创 最新推荐文章于 2025-10-11 16:25:49 发布 · 3.6k 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文介绍了在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;
    }


Translator:android string.xml 翻译器，集成百度，google，有道
05-12
Android string.xml 翻译工具 这个老版的工具将不再维护。最新版已发布，基于插件的形式，你可以轻松的开发插件来选择你要使用的翻译平台， 你也可以发开自己的文档解析插件，然后将文档解析插件和翻译平台插件任意组合更加灵活。项目地址在这里： Android strings.xml translate tools This project will not support. The new version of Translator now released, it is plugin based, you can simply develop you own plugins to access translate platform and parse typed text document. You will fall in love with this new project.
android字串导出工具
10-19
导出android代码内的字串到excel，便于翻译。 导出后的格式是： key 英文 待翻译的语言 导出时，会自动忽略不必要的字串。比如注释里带not translate,或者属性里有translate="false"的字串。 ------------ ./string_exporter -h (show help) 下面的例子导出frameworks中的所有字串。但是忽略路径中含sample或者test的xml字串档案 ./string_exporter -f config.xml -d frameworks/ -i "sample|test"
Android string.xml多语言翻译工具
热门推荐
Android开源技术交流
10-31 1万+
Android string.xml 翻译工具源码你可以在Github上看到：https://github.com/onlynight/Translator概述最近要把公司的app往国外推广，无奈只做了中文版，好在所有的字符串都是写在string.xml文件中的，为了快速推出海外版本，决定有机器翻译先做一个简单的版本。说到这里问题就来啦，这么多文本难道一句一句的复制粘贴呀，当然写个小工具翻译既省时又
Android的strings.xml多语言翻译
weixin_38596553的博客
04-28 3451
使用js实现Android中strings.xml的多语言翻译
Android中谷歌翻译接口使用（使用谷歌翻译接口，App做文本翻译）
NewActivity的博客
10-15 6467
原文章：https://blog.csdn.net/pifutan/article/details/78554691。结合原文按照自己需求，实现功能。效果如下： 功能实现： 使用Android自带Spinner <LinearLayout android:id="@+id/ll_top_translate" android:layout_width="wr...
android手动快速使用机器翻译文本方法
lbs_android的博客
05-24 917
android原生项目使用android studio进行国际化多国语言翻译
Android手动实现多国语言切换完整解决方案
最新发布
weixin_34392511的博客
10-11 810
你有 %d 条未读消息
Python android 多国翻译提取整合工具
AAA啊哈
11-12 608
Python android 多国翻译提取整合工具前提功能 1功能 2代码实现 前提 使用了 BeautifulSoup, 我很懒 功能 1 提取 string.xml 资源文件的内容 &lt;string name="app_name"&gt;App Name&lt;/string&gt; -&gt; App Name 功能 2 整合 翻译文件到源文件, 翻译文件每行代表一个翻译，不能有空行...
安卓Android studio国际化方法插件安装---快速翻译工具
郭风朴(guofengpu)的Android影音专栏
09-30 6583
internationalization （国际化）简称 i18n,因为在i和n之间还有18个字符，localization（本地化 ），简称L10n。 一般用语言_地区的形式表示一种语言，如 zh_CN, zh_TW. 各国语言缩写 http://www.loc.gov/standards/iso639-2/php/code_list.php 国家和地区简写 http:
Android翻译多国语言字符串注意事项
paul的专栏
03-06 1261
有些字符串的值是作为中间变量来传递的,并不在UI上显示.这些就不用翻译啦. 大概有这么几类: 1.标明了translatable="false"的,比如 name="pref_camera_video_flashmode_default" translatable="false">off 2.注释中有说明的,比如 name="pref_camera_histo
基于Android Studio的内部翻译插件和生成多语言string文件插件
yunianshu的博客
03-18 7459
因为学生的时候没有好好学习英语，现在看到一堆的英文手足无措，悔不当初，严重影响技术的学习和进阶。今天刚好学习一个国外开源项目，编译后的apk有我需要的功能，吾深感欣慰。但是有一点，apk中都是英文，作为英语的渣渣，这非常影响效率，所以想到了国际化，又想到了如果有一个插件可以直接生成多语言就好了。所以本着解决问题的角度，搜索了一下google，还真发现了有插件可以生成。前人栽树后人乘凉，感谢各位大佬。不废话，下面是具体的实现过程: 一.内部翻译插件translation 二.多语言翻译插件An...
Android Resource Translator:将android字符串资源翻译成其他语言。-开源
05-27
请参阅Wiki页面以获取信息，源代码可在github git@github.com：khayamgondal / Android-Resource-Translator.git上找到。
Android--strings.xml翻译快捷方式一
Black_Cat_33的博客
11-04 2246
利用Office的Excel（试过WPS的，不行），这个方法的前提是有人帮忙事先整理好翻译在Excel表上，且String的顺序一一对应好就此能比较快的复制。
Android Studio国际化多语言String文件一键翻译插件
tian2342的专栏
04-03 5399
需求 之前产品也提过这方面的需求，说每次翻译都要手动一次次的复制，然后翻译再复制回来，不仅容易出错，还麻烦。 找现成的 之前也搜索过相关文章，但是一方面很多都是不更新了，另一方面之前也没弄过插件开发，虽然比较感兴趣，但是bug太多一直没空。 今天好不容易有点时间了，就顺便把这个弄一弄。 1. 百度搜一下 作为cv工程师，肯定不会自己从头写的，能用现成的就用现成的。 发现了一篇文章，AndroidL...
Android String.xml语言翻译脚本
An_light的博客
03-25 1140
自动翻译string.xml
Android资源翻译工具教程
u010345983的博客
09-30 1814
1.打开String Translation Tool (STT)，点击界面上的“Select Android Project”按钮2.在弹出的文件选择对话框中，浏览并选中您希望进行翻译的Android项目路径3.等待工具扫描项目资源文件，这可能需要一些时间，具体取决于文件大小。扫描完成后，选择您希望翻译的资源文件，并点击“Start Export”按钮。工具将在指定目录下生成一个名为“strings.xlsx”的Excel文件，该文件包含了所有待翻译的字符串。
Android中处理特殊字符
土匪头子的专栏
07-29 1962
如果XML或Android中的字符串包含有特殊用法的字符，则必须转义这些字符。您可以使用前导反斜杠转义某些字符，但其他字符需使用XML转义。转义带格式文本的字符串中任何可能存在的HTML字符。例如，如果您打算对包含“......
android &字符报错,Android字符串进阶之一（特殊字符的输入）
weixin_42644410的博客
05-26 766
本文按照遇到问题的思路展开：html(一)在Res下String.xml向字符串中插入“&”符号报错java以下图所示：api 翻译：在对实体的引用中，实体名必须紧跟在“&”后。app查找知道：这设计到HTML语言的字符集知识：ide在网页中除了可显示常见的ASCII字符和汉字外，HTML还有许多特殊字符，它们一块儿构成了HTML字符集。有2种状况须要使用特殊字符，一是网页中有其特...
Android字符串进阶之一（特殊字符的输入）
weixin_34405925的博客
05-14 490
本文按照遇到问题的思路展开： (一) 在Res下String.xml向字符串中插入“&”符号报错 如下图所示： 翻译：在对实体的引用中，实体名必须紧跟在“&”后。 查找知道：这设计到HTML语言的字符集知识： 在网页中除了可显示常见的ASCII字符和汉字外，HTML还有许多特殊字符，它们一起构成了HTML字符集。有2种情况需要使用特殊字符，一是网...
AndroidStudio 开发中字符串国际化string.xml与Excel表格的互相导入
xk7298的博客
07-15 4145
在Android 的开发中有时需要适配国际化，需要将string.xml中的字符串导出翻译，然后再将翻译后的字符串导入至AndroidStudio中相应的string.xml中，关于国际化的实现，可参考Android适配国际化的三种方式（应用和系统），本文主要讲解如何快速的实现xml与excel中内容的互相导入，关键效果如下所示。 1.String.xml导出至excel中 按照以下步骤操作： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值