blocks|key|462546|text|Java中有两种不同类型的XML处理器(实际上有3种，但有一种很奇怪)。您拥有的是一个SAX解析器，而您想要的是一个DOM解析器。有关如何使用DOM解析器的信息，请参阅http://www.mkyong.com/java/how-to-read-xml-file-in-java-dom-parser/。DOM将创建一个树，您可以很容易地导航。SAX最适合大型文档，但是DOM要简单得多，如果速度慢，内存消耗大得多。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|462547|entityMap|0|LINK|mutability|MUTABLE|url|http://www.mkyong.com/java/how-to-read-xml-file-in-java-dom-parser^0|2C|1U|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

There are two different types of processors for XML in Java (3 actually, but one is weird). What you have is a SAX parser and what you want is a DOM parser. Take a look at <a href="http://www.mkyong.com/java/how-to-read-xml-file-in-java-dom-parser" rel="noreferrer">http://www.mkyong.com/java/how-to-read-xml-file-in-java-dom-parser</a>/ for how to use the DOM parser. DOM will create a tree which you can navigate pretty easily. SAX is best for large documents but DOM is much easier if slower and much more memory intensive.

blocks|key|497979|text|从Java5开始，SDK中有一个XPath库。有关它的介绍，请参阅this+tutorial。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|497980|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ibm.com/developerworks/library/x-javaxpathapi.html^0|X|D|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Starting w/ Java 5, there is an XPath library in the SDK. See <a href="http://www.ibm.com/developerworks/library/x-javaxpathapi.html" rel="nofollow noreferrer">this tutorial</a> for an introduction to it.

blocks|key|498006|text|解析XML并不是一件容易的事情。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|498007|它的基本结构是一棵树，树中的任何节点都可以容纳一个由更多树组成的数组组成的容器。|498008|树中的每个节点都包含一个标记和一个值，但除此之外，还可以包含任意数量的命名属性，以及任意数量的子节点或容器。|498009|XML解析任务往往分为三类。|498010|可以用"regex“完成的事情。例如，您希望找到第一个"MailTo“标记的值，但对任何其他标记的内容不感兴趣。|498011|你可以自己解析的东西。xml结构总是非常简单的，例如，一个根节点和十个具有简单值的众所周知的标记。|498012|剩下的都是！尽管xml消息格式看起来很简单，但是自制的解析器很容易被额外的属性、CDATA和意外的子元素搞混。成熟的XML解析器可以处理所有这些情况。这里的基本选择是流或DOM解析器。如果您打算按顺序使用大多数实体/属性，那么DOM解析器是理想的选择。如果你只对几个属性感兴趣，并打算按照它们的显示顺序使用它们，如果你有性能限制，或者如果xml文件很大(>+500MB+)，那么流解析器是一种方法；回调机制需要一些“摸索”，但是一旦你掌握了它，编程实际上是相当简单的。|498013|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|S|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|U|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|V|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|O|$]]

Well parsing XML is not an easy task.

Its basic structure is a tree with any node in tree capable of holding a container which consists of an array of more trees.

Each node in a tree contains a tag and a value but in addtion can contain an arbitary number of named attributes, and, an arbitary number of children or containers.

XML parsing tasks tend to fall in to three catagories.

Things that can be done with "regex". E.g. you want to find the value of the first "MailTo" tag and are not interested in the contents of any other tags.

Things you can parse yourself. The xml structure is always very simple e.g a root node and ten well known tags with simple values.

All the rest! Even though an xml message format can look deceptively simple home made parsers are easily confused by extra attributes, CDATA and unexpected children. Full blown XML parsers can handle all of these situations. Here the basic choice is between a stream or a DOM parser. If you intend to use most of the entities/attributes given in the order you want to use them then a DOM parser is ideal. If you are only interested in a few attributes and intend to use them in the order they are presented, if you have performance constraints, or, if the xml files are large ( > 500MB ) than a stream parser is the way to go; the callback mechanism takes a bit of "groking" but its actually quite simple to program once you get the hang of it.

blocks|key|1797128|text|在我看来，您应该使用SAX解析器，因为：-快速-您可以控制XML文档中的所有内容|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1797129|您将花费更多的时间进行编码，但这只是一次，因为您将创建代码模板来解析XML|1797130|在第二种情况下，您只能编辑更改的内容。|1797131|祝好运!|1797132|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Acording to me, you should use SAX parser because:
- Fast
- you can control everything in XML document

You will pay more time to coding, but it's once because you will create code template to parse XML

From second case, you only edit content of changes.

Good luck!

blocks|key|1797145|text|您还可以使用Castor将XML映射到Java。我以前用过它，它的效果很好。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1797146|entityMap|0|LINK|mutability|MUTABLE|url|http://www.castor.org/^0|6|6|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

You could also use <a href="http://www.castor.org/" rel="nofollow noreferrer">Castor</a> to map the XML to Java beans. I have used it before and it works like a charm.

blocks|key|1869708|text|编写SAX+handler是最好的方式。一旦你这样做了，你就再也回不到别的地方去了。它是快速的，简单的，它在运行的过程中会被压缩掉，不会吸收大量的部分，或者上帝会禁止整个DOM进入内存。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1869709|entityMap^0|2|B|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Writing <code>SAX handler</code> is the best way to go. And once you do that you will never go back to anything else. It's fast, simple and it crunches away as it goes, no sucking large parts or god forbid a whole DOM into memory.

blocks|key|1797187|text|试试http://simple.sourceforge.net，它是一个从XML到Java的序列化和绑定框架，它与Android完全兼容，非常轻量级，270K并且没有依赖。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1797188|entityMap|0|LINK|mutability|MUTABLE|url|http://simple.sourceforge.net/^0|2|T|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Try <a href="http://simple.sourceforge.net" rel="noreferrer">http://simple.sourceforge.net</a>, its an XML to Java serialization and binding framework, its fully compatible with Android and is very lightweight, 270K and no dependencies.

blocks|key|1869784|text|几周前，我开发了一个小型库(一个围绕javax.xml.stream.XMLEventReader的包装器)，它允许以类似于手工编写的递归下降解析器的方式解析XML。源码是available+on+github，下面是一个简单的使用示例。不幸的是，安卓不支持这个接口，但它非常类似于支持的XmlPullParser接口，并且移植不会太耗时。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1869785|accept("tilesets");
++++while+(atTag("tileset"))+{
++++++++String+filename+=+attrib("file");
++++++++File+tilesetFile+=+new+File(filename);
++++++++if+(!tilesetFile.isAbsolute())+{
++++++++++++tilesetFile+=+new+File(FilenameUtils.concat(file.getParent(),+filename));
++++++++}
++++++++int+tilesize+=+Integer.valueOf(attrib("tilesize"));
++++++++Tileset+t+=+new+Tileset(tilesetFile,+tilesize);
++++++++t.setID(attrib("id"));
++++++++tilesets.add(t);

++++++++accept();
++++++++close();
++++}
close();

expect("map");

int+width+++++++=+Integer.valueOf(attrib("width"));
int+height++++++=+Integer.valueOf(attrib("height"));
int+tilesize++++=+Integer.valueOf(attrib("tilesize"));|code-block|syntax|javascript|1869786|entityMap|0|LINK|mutability|MUTABLE|url|http://github.com/jaz303/sane-xml^0|I|V|40|D|2E|J|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|H|7|10|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

A couple of weeks ago I battered out a small library (a wrapper around <code>javax.xml.stream.XMLEventReader</code>) allowing one to parse XML in a similar fashion to a hand-written recursive descent parser. The source is <a href="http://github.com/jaz303/sane-xml" rel="nofollow noreferrer">available on github</a>, and a simple usage example is below. Unfortunately Android doesn't support this API but it is very similar to the <code>XmlPullParser</code> API, which is supported, and porting wouldn't be too time-consuming.

<pre><code>accept("tilesets");
 while (atTag("tileset")) {
 String filename = attrib("file");
 File tilesetFile = new File(filename);
 if (!tilesetFile.isAbsolute()) {
 tilesetFile = new File(FilenameUtils.concat(file.getParent(), filename));
 }
 int tilesize = Integer.valueOf(attrib("tilesize"));
 Tileset t = new Tileset(tilesetFile, tilesize);
 t.setID(attrib("id"));
 tilesets.add(t);

 accept();
 close();
 }
close();

expect("map");

int width = Integer.valueOf(attrib("width"));
int height = Integer.valueOf(attrib("height"));
int tilesize = Integer.valueOf(attrib("tilesize"));
</code></pre>

blocks|key|462939|text|在我看来，使用XPath+for+parsing+XML可能是最简单的编码方法。您可以在单个表达式中实现从XML文档中提取节点的逻辑，而不必编写代码来遍历文档的对象图。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|462940|我注意到another+posted+answer+to+this+question已经建议使用XPath。但对你的Android项目来说还不是。到目前为止，任何Android版本的都不支持+XPath解析类(尽管javax.xml命名空间是在Dalvik+JVM中定义的，这可能会欺骗您，就像它最初对我所做的那样)。|style|BOLD|462941|在Android中包含XPath类是一个后期的工作项目。(在我写这篇文章的时候，Google正在对它进行测试和调试)。您可以在此处：http://code.google.com/p/android/issues/detail?id=515跟踪将XPath添加到Davlik的状态|462942|(令人恼火的是，您不能假设Android+Dalvik+VM中还包含大多数Java+VM中支持的内容。)|462943|另一个选择，在等待谷歌官方支持的同时，是JDOM，它目前声称Dalvik+VM兼容性和XPath支持(测试版)。(我并没有检查这一点；我只是在他们的网站上重复当前的声明。)|462944|entityMap|0|LINK|mutability|MUTABLE|url|http://www.w3schools.com/Xpath/|1|https://stackoverflow.com/questions/1719261/is-there-an-easier-way-to-parse-xml-in-java/1719291#1719291|2|http://code.google.com/p/android/issues/detail?id=515|3|http://www.jdom.org/^0|7|L|0|0|2N|1S|4|12|1|0|0|1T|1U|1H|2|0|0|K|4|3|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@$A|12|B|13|1|14]]|C|$]]|$1|D|3|E|5|6|7|15|8|@$A|16|B|17|F|G]]|9|@$A|18|B|19|1|1A]]|C|$]]|$1|H|3|I|5|6|7|1B|8|@$A|1C|B|1D|F|G]]|9|@$A|1E|B|1F|1|1G]]|C|$]]|$1|J|3|K|5|6|7|1H|8|@]|9|@]|C|$]]|$1|L|3|M|5|6|7|1I|8|@]|9|@$A|1J|B|1K|1|1L]]|C|$]]|$1|N|3|-4|5|6|7|1M|8|@]|9|@]|C|$]]]|O|$P|$5|Q|R|S|C|$T|U]]|V|$5|Q|R|S|C|$T|W]]|X|$5|Q|R|S|C|$T|Y]]|Z|$5|Q|R|S|C|$T|10]]]]

In my opinion, using <a href="http://www.w3schools.com/Xpath/" rel="nofollow noreferrer">XPath for parsing XML</a> may be your easiest coding approach. You can embody the logic for pulling out nodes from an XML document in a single expression, rather than having to write the code to traverse the document's object graph. 

I note that <a href="https://stackoverflow.com/questions/1719261/is-there-an-easier-way-to-parse-xml-in-java/1719291#1719291">another posted answer to this question</a> already suggested using XPath. But not yet for your Android project. As of right now, the XPath parsing class is not yet supported in any Android release (even though the javax.xml namespace is defined in the Dalvik JVM, which could fool you, as it did me at first).

Inclusion of XPath class in Android is a current work item in late phase. (It is being tested and debugged by Google as I write this). You can track the status of adding XPath to Davlik here: <a href="http://code.google.com/p/android/issues/detail?id=515" rel="nofollow noreferrer">http://code.google.com/p/android/issues/detail?id=515</a>

(It's an annoyance that you cannot assume things supported in most Java VMs are included yet in the Android Dalvik VM.)

Another option, while waiting for official Google support, is <a href="http://www.jdom.org/" rel="nofollow noreferrer">JDOM</a>, which presently claims Dalvik VM compatibility and also XPath support (in beta). (I have not checked this out; I'm just repeating current claims from their web site.)

blocks|key|462988|text|我已经创建了一个非常简单的API来解决这个问题。它只是一个可以包含在代码库中的类，它非常简洁，可以轻松地解析任何XML。你可以在这里找到它：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|462989|http://argonrain.wordpress.com/2009/10/27/000/|offset|length|462990|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1A|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@$D|O|E|P|1|Q]]|A|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|C]]]]

I've created a really simple API to solve precisely this problem. It's just a single class that you can include in your code base and it's really clean and easy to parse any XML. You can find it here:

<a href="http://argonrain.wordpress.com/2009/10/27/000/" rel="nofollow">http://argonrain.wordpress.com/2009/10/27/000/</a>

blocks|key|463056|text|凯尔|type|unstyled|depth|inlineStyleRanges|entityRanges|data|463057|(请原谅这篇文章的自我推销性质...我已经在这个库上工作了几个月了，它都是开源的/Apache2，所以不是自私自利，只是想提供帮助)。|463058|我刚刚发布了一个名为SJXP或"Simple+Java+XML+Parser“http://www.thebuzzmedia.com/software/simple-java-xml-parser-sjxp/的库|offset|length|463059|它是一个非常小/紧密(4个类)的抽象层，位于任何符合规范的XML+Pull+Parser之上。|463060|在Android和非Android+Java平台上，拉解析可能是性能最好的解析方法之一(在速度和内存开销方面都是如此)。不幸的是，直接针对拉式解析器进行编码最终看起来与任何其他XML解析器代码(例如SAX)非常相似--您有异常处理程序、维护解析器状态、错误检查、事件处理、值解析等。|463061|SJXP所做的是允许您在文档中定义类似于XPath的“路径”，其中包含您想要从中获取值的元素或属性，例如：|463062|463063|+/rss/频道/标题|blockquote|463064|463065|463066|当该规则匹配时，它将使用该值调用您的回调。这个API非常简单，可以直观地支持名称空间限定的元素，如果您想要解析的话。|463067|标准解析器的代码如下所示(解析RSS2提要标题的示例)：|463068|IRule+titleRule+=+new+DefaultRule(Type.CHARACTER,+"/rss/channel/title")+{
@Override
public+void+handleParsedCharacters(XMLParser+parser,+String+text)+{
++++//+Store+the+title+in+a+DB+or+something+fancy
}}|code-block|syntax|javascript|463069|然后，您只需创建一个XMLParser实例，并为其提供您希望它关心的所有规则：|463070|XMLParser+parser+=+new+XMLParser(titleRule);
parser.parse(xmlStream);|463071|就是这样，每当规则匹配时，解析器都会调用处理程序方法。如果需要，可以随时通过调用parser.stop()来停止解析。|463072|此外(这是这个库的真正优势)匹配名称空间限定的元素和属性非常简单，只需将它们的名称空间URI添加到路径中元素名称前缀的括号中即可。|463073|例如，假设您想要退出RSS+feed的元素，这样您就可以知道它使用的是哪种语言(参见：http://web.resource.org/rss/1.0/modules/dc/)。您只需对带有'dc‘前缀的'language’元素使用唯一的名称空间URI，规则路径将如下所示：|463074|463075|+/rss/channel/http://purl.org/dc/elements/1.1/language|463076|463077|463078|名称空间限定的属性也是如此。|463079|如此简单，您添加到解析过程的唯一开销是在XML文档的每个位置进行O(1)散列查找，以及用于解析器的内部位置状态的几百个字节(可能是1k+)。|463080|这个库可以在安卓上工作，不需要额外的依赖(因为平台已经提供了一个Java+)，并且可以通过添加XPP3依赖在任何其他org.xmlpull运行时中工作。|463081|这个库是几个月来为每种语言的每种提要XML编写自定义拉出解析器的结果，并且(随着时间的推移)认识到大约90%25的解析可以提炼成这个真正的基本范式。|463082|我希望你会发现它很方便。|463083|entityMap|0|LINK|mutability|MUTABLE|url|http://www.thebuzzmedia.com/software/simple-java-xml-parser-sjxp/|1|http://web.resource.org/rss/1.0/modules/dc/^0|0|0|13|1T|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|17|17|1|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|21|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|22|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|23|8|@]|9|@$F|24|G|25|1|26]]|A|$]]|$1|H|3|I|5|6|7|27|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|28|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|29|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|2A|8|@]|9|@]|A|$]]|$1|O|3|P|5|Q|7|2B|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|2C|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|2D|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|2E|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|2F|8|@]|9|@]|A|$]]|$1|X|3|Y|5|Z|7|2G|8|@]|9|@]|A|$10|11]]|$1|12|3|13|5|6|7|2H|8|@]|9|@]|A|$]]|$1|14|3|15|5|Z|7|2I|8|@]|9|@]|A|$10|11]]|$1|16|3|17|5|6|7|2J|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|2K|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|2L|8|@]|9|@$F|2M|G|2N|1|2O]]|A|$]]|$1|1C|3|-4|5|6|7|2P|8|@]|9|@]|A|$]]|$1|1D|3|1E|5|Q|7|2Q|8|@]|9|@]|A|$]]|$1|1F|3|-4|5|6|7|2R|8|@]|9|@]|A|$]]|$1|1G|3|-4|5|6|7|2S|8|@]|9|@]|A|$]]|$1|1H|3|1I|5|6|7|2T|8|@]|9|@]|A|$]]|$1|1J|3|1K|5|6|7|2U|8|@]|9|@]|A|$]]|$1|1L|3|1M|5|6|7|2V|8|@]|9|@]|A|$]]|$1|1N|3|1O|5|6|7|2W|8|@]|9|@]|A|$]]|$1|1P|3|1Q|5|6|7|2X|8|@]|9|@]|A|$]]|$1|1R|3|-4|5|6|7|2Y|8|@]|9|@]|A|$]]]|1S|$1T|$5|1U|1V|1W|A|$1X|1Y]]|1Z|$5|1U|1V|1W|A|$1X|20]]]]

Kyle,

(Please excuse the self-promotey nature of this post... I've been working on this library for months and it's all open source/Apache 2, so not that self-serving, just trying to help).

I just released a library I'm calling SJXP or "Simple Java XML Parser"
<a href="http://www.thebuzzmedia.com/software/simple-java-xml-parser-sjxp/" rel="nofollow">http://www.thebuzzmedia.com/software/simple-java-xml-parser-sjxp/</a>

It is a very small/tight (4 classes) abstraction layer that sits on top of any spec-compliant XML Pull Parser.

On Android and non-Android Java platforms, pull parsing is probably one of the most performant (both in speed and low memory overhead) methods of parsing. Unfortunately coding directly against a pull-parser ends up looking a lot like any other XML parsing code (e.g. SAX) -- you have exception handlers, maintaining parser state, error checking, event handling, value parsing, etc.

What SJXP does is allows you to define XPath-like "paths" in a document of the elements or attributes you want the values from, like:

<blockquote>
 /rss/channel/title
</blockquote>

and it will invoke your callback, with the value, when that rule matches. The API is really straight forward and has intuitive support for namespace-qualified elements if that is what you are trying to parse.

The code for a standard parser would look something like this (an example that parses an RSS2 feed title):

<pre><code>IRule titleRule = new DefaultRule(Type.CHARACTER, "/rss/channel/title") {
@Override
public void handleParsedCharacters(XMLParser parser, String text) {
 // Store the title in a DB or something fancy
}}
</code></pre>

then you just create an XMLParser instance and give it all the rules you want it to care about:

<pre><code>XMLParser parser = new XMLParser(titleRule);
parser.parse(xmlStream);
</code></pre>

And that's it, the parser will invoke the handler method every time the rule matches. You can stop parsing at any time by calling parser.stop() if you want.

Additionally (and this is the real win of this library) matching namespace qualified elements and attributes is dead easy, you just add their namespace URI inside of brackets prefixing the name of the element in your path.

An example, say you want out of the element for an RSS feed so you can tell what language it is in (ref: <a href="http://web.resource.org/rss/1.0/modules/dc/" rel="nofollow">http://web.resource.org/rss/1.0/modules/dc/</a>). You just use the unique namespace URI for that 'language' element with the 'dc' prefix, and the rule path ends up looking like this:

<blockquote>
 /rss/channel/[http://purl.org/dc/elements/1.1/]language
</blockquote>

The same goes for namespace-qualified attributes as well.

With all that ease, the only overhead you add to the parsing process is an O(1) hash lookup at each location of the XML document and a few-hundred bytes, maybe 1k, for the internal location state of the parser.

The library works on Android with no additional dependencies (because the platform provides an org.xmlpull impl already) and in any other Java runtime by adding the XPP3 dependency.

This library is the result of many months of writing custom pull parsers for every kind of feed XML out there in every language and realizing (over time) that about 90% of parsing can be distilled down into this really basic paradigm.

I hope you find it handy.

blocks|key|1870010|text|对于任何类型的XmlPullParser，都有一个非常好的示例。它也可以解析为通用的方式，你不需要改变任何东西，只需获得类并放入你的android项目中即可。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1870011|Generic+XmlPullParser|offset|length|1870012|entityMap|0|LINK|mutability|MUTABLE|url|http://www.gyanportal.com/article/generic-xmlpullparser-for-android/25^0|0|0|L|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

There is a very good example shows for XmlPullParser for any type of xml. It could also parse as a generic way, you do not need to change any thing for that just get that class and put into your android project.

<a href="http://www.gyanportal.com/article/generic-xmlpullparser-for-android/25" rel="nofollow">Generic XmlPullParser</a>

blocks|key|1799327|text|你可以试试这个|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1799328|http://xml.jcabi.com/|offset|length|1799329|它是DOM之上的一个附加层，允许对XML文档和节点进行简单的解析、打印和转换|1799330|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|L|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@$D|Q|E|R|1|S]]|A|$]]|$1|F|3|G|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|C]]]]

You can try this 
<a href="http://xml.jcabi.com/" rel="nofollow">http://xml.jcabi.com/</a> 
It is is an extra layer on top of DOM that allows simple parsing, printing, and transforming of XML documents and nodes

I'm trying to figure out how to parse some XML (for an Android app), and it seems pretty ridiculous how difficult it is to do in Java. It seems like it requires creating an XML handler which has various callbacks (startElement, endElement, and so on), and you have to then take care of changing all this data into objects. Something like <a href="http://www.anddev.org/parsing_xml_from_the_net_-_using_the_saxparser-t353.html" rel="noreferrer">this tutorial</a>.

All I really need is to change an XML document into a multidimensional array, and even better would be to have some sort of <a href="http://wiki.github.com/hpricot/hpricot" rel="noreferrer">Hpricot</a> processor. Is there any way to do this, or do I really have to write all the extra code in the example above?

Is there an easier way to parse XML in Java?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我正在试图弄清楚如何解析一些XML (对于Android应用程序)，在Java中做这件事有多么困难似乎是相当可笑的。这似乎需要创建一个具有各种回调(startElement、endElement等)的XML处理程序，然后您必须注意将所有这些数据转换为对象。就像一样。我真正需要的就是将一个XML文档转换成一个多维数组，如...

问有没有更简单的方法来解析Java中的XML？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问有没有更简单的方法来解析Java中的XML？EN