Develop Reference

which is more efficient parsing xml or json in android app

I would like to know which is more efficient to get the data from the server by the xml or json.
Another question:
does XmlPullParser related to parsing xml data that come from the web service? so if I am using json I don't need XmlPullParser ! or there is other uses !
thank you very much

What I've found extremely useful for parsing JSON is Google's gson library. For xml, you can use gson underneath to do the same thing with gson-xml. With a single line of code you can map your JSON/XML to your objects without having to write a single line of parsing code.
If you find performance to be an issue (I'm making this suggestion because these libs make you super productive), there are mechanisms in both to allow you finer grained control. I doubt you'll have problems with performance though.

For a very thoroughly researched answer to the headline question (though focussed on browsers, not android apps), see David Lee's Balisage 2013 paper:
http://www.balisage.net/Proceedings/vol10/html/Lee01/BalisageVol10-Lee01.html
His conclusion, in one line, is that the choice between XML and JSON makes very little difference in itself - though the details of how you do XML or how you do JSON can make a big difference.

In android is doing XPath evaluate or Pull parser faster?

There is a remote xml file and I need to get set of xml nodes from it and show in an activity. One way is to download it completely and then do an xpath evaluate and get node set as follows
// using node I can drill further down to collect my relevant info
NodeList names = (NodeList) xPath.evaluate("/library/artists/name", new InputSource(new FileReader(getDowloadedXMLFileLocation())), XPathConstants.NODESET);
The other way is to use a pull parser which would be a bit more code I guess to do a simple job to extract a nodeset . I am wondering which method performs better in memory and speed ?

Customized code versus a generic solution, equates to high performance versus ease of use.
XPath (and XLST, and JDOM etc) will construct a DOM like model, and iterate it. This will take more RAM and CPU. XPath is easy, but can be really slow for large files. Also it requires you to have the complete file at hand. Use this for small files.
PullParser on other hand is like reading a file only at places you are interested, skipping the rest. Also, only one node is loaded in RAM at a time. There are no limits on how large the input file is, or is it fully available or being streamed over a medium. Use this for large or streamed files.

An excellent answer I found at Best practices for parsing XML
You can also use XmlPullParser to parse xml. But I suggest if possible, use json instead of XML, which decrease your memory and Google provide its wrapper mechanism in GSON which is best at all.
Links.
1) http://vtd-xml.sourceforge.net/

What should I be using for an XML parser in my Android App?

I want to create an App that uses a potentially large xml file. It will also modify and ideally be able to traverse in reverse.
I know there is SAX, DOM, and the XML pull parser. The pull parser is out, unless I spend memory on creating my own tree of objects which does not seem feasible.
That leaves SAX and DOM unless there is another parser out there that can do what I want. Highly improbable, I know.
Yes, I saw this answer: https://stackoverflow.com/questions/7498616/which-xml-parser-should-i-use-for-android
Thoughts on having tree like usability without having to use DOM?

There are a lot of options when it comes to parsing XML. But it depends on your own requirements that which parser you can use when. For that you need to know the basic differences between the parser. Here is some basic information i have provided.
SAX parser is one where your code is notified as the parser walks through the XML tree,
and you are responsible for keeping track of state and constructing any objects you might want to keep track of the data as the parser marches through.
DOM parser reads the entire document and builds up an in-memory representation that you can query for different elements. Often, you can even construct XPath queries to pull out particular pieces.
And as you said you are having large file and also if you want faster performance i suggest that you should use StAX parser. Here is link for that.
Hope this will help you...
Also refer this link.

DOM is better for most of the cases where it will load all the XML at a time. But If the XML size is very big then we should go for SAX parser where it will read for the tag from the start of the XML every time.
If the XML is really big then it is better to filter from the server end by sending the requirements in the request or else we can go for pagination which is suggestible.

Best practices for parsing XML

My application shall parse XML received via HTTP. As far as I understand there are three major ways of parsing XML:
SAX
DOM
XmlPullParser
It is said that SAX is the fastest of these while DOM is not optimal for larger XML documents. But what is a large XML document in terms of parsing? What would be a recommended parser for the following?
XML document size between 1-5 kB
Easy traversing through the document, i.e. I need to know not only the current element but also the parent elements.

As far as I understand there are three major ways of parsing XML:
- SAX
- DOM
- XmlPullParser
Wrong! Neither of those is the best way. What you really want is annotation based parsing using the Simple XML Framework. To see why follow this logic:
Java works with objects.
XML can be represented using Java objects. (see JAXB)
Annotations could be used to map that XML to your Java objects and vice versa.
The Simple XML Framework uses Annotations to allow you to map your Java and XML together.
Simple XML is capable of running on Android (unlike JAXB).
You should use Simple XML for all of your XML needs on Android.
And to help you do exactly that I will point you to my own blog post that explains exactly how to use the Simple library on Android.
Unless you have a 100MB XML file then Simple will be more than fast enough for you. It is for me, I use it on all of my Android XML projects.
N.B. I should point out that if you require the user to download XML files that are more than 1MB on Android then you may want to rethink your strategy. You might be doing it wrong.

I'm afraid this is a case of, it depends ...
As a rule of thumb, using Java to build a DOM tree from an XML document will consume between 4 and 10 times that document's native size (assuming Western text and UTF-8 encoding), depending on the underlying implementation. So if speed and memory-use are not critical it will not be a problem for the small documents you mention.
DOM is generally regarded as quite an unpleasant way to work with XML. For background you might want to look at Elliotte Rusty Harold's presentation: What's Wrong with XML APIs (and how to fix them).
However, using SAX can be even more tedious as the document is processed one item at a time. SAX however is fast and consumes very little memory. If you can find a pull parser you like then by all means try that.
Another approach (not super-efficient, but clean and maintainable) is to build an in-memory tree of your XML (using DOM, say) and then use XPath expressions to select the information you are interested in.

Android rss parse - what method to use?

What would be the easiest way to parse an rss feed? Are there any already done easy(fast to implement) methods out there?
All the posts I could find on the topic were many years old. Any new technologies out there that are worthy of attention? Or should I just make my own parser?
Edit: please link to a usage method/tutorial too :)

For bigger XML i would recomend a serial XML parser like SAX - it's build in: http://developer.android.com/reference/android/sax/package-summary.html
For examples just search in Google - there are milions out there: http://www.google.at/search?q=sax+android+tutorial

For just reading it out, you can use DOM parser, which is very simple to use and to understand.
And: It is part of the android API

You can take the source code from Android XML Parser Performance as an example. I stick to SAXParser though XmlPullParser is good as well.
DOM is not the best option for a memory-constrained device (unless you want to manipulate the tree which you don't).