When is JDOM XPATH faster than element hunting with getChildren?

Question

Using: Java 1.5 / JDom 1.1.3 / Jaxen 1.1.1

The test I've written was to confirm the belief that using precompiled XPATH in JDOM was faster than iterating through child elements. Instead, what I've found is that XPATH is between 4 and 5 times slower than iterating through lists of children, performing string comparisons, and hunting for what I want.

For context, my XPath is something like:

/root/quote/vehicle[@id = 'some vehicle']/coverage[@id = 'some coverage']/code";

And the actual evaluation being timed (in a try/catch block):

String element = path.valueOf(doc).getText();

And the alternative search is:

List<Element> vehicleList = doc.getRootElement()
                                        .getChild("quote")
                                        .getChildren("vehicle");

for(Element vehElement : vehicleList)
    if(vehElement.getAttributeValue("id").equals("some vehicle")){
        List<Element> coverageList = ele.getChildren("coverage");
        for(Element covElement : coverageList){
            if(covElement.getAttributeValue("id").equals("some coverage")){
                element = covElement.getChild("CoverageType").getText();
                break;
            }
        }
    }

Curiously, while the runtime of the method using XPATH is much slower, it is most consistent over 1000 iterations.

The first example completes around .29 ms +- 0.01ms.

The second example completes anywhere between .013ms and .002ms.

Both approach very short running times given a long enough test.

The XPath is, for me, easier to write, however the getChild route seems more flexible but a little verbose. Still that's a trade I don't mind making for speed. It is also true that even 100 iterations is incredibly fast, so this may be academic...

Ultimately I'd like to know:

Is there a scenario where JDOM Xpath is faster than the alternative style shown ?

What benefits does JDom XPath (in any version of Java/JDOM) bring ?

I was hoping for comments from an authority on the subject :) I'm relatively new to JDOM. — JHarnach, May 14 '12 at 18:16

rolfl · Accepted Answer · 2012-05-14T18:46:00.353

3

There are a few things to note in here.... I have done (I'm a JDOM maintainer) extensive work on JDOM 2.0.1 especially in regards to performance of XPath evaluation. Here are some numbers:

http://hunterhacker.github.com/jdom/jdom2/performance.html

Read it from the bottom up.

Here are some other interesting numbers (compares different JDOM versions with different Java VM's)

http://hunterhacker.github.com/jdom/jdom2/performanceJDK.html

The 'bottom line'....

JDOM 2.x introduces faster iterators. Jaxen is very Iterator intensive, and the performance improvements in JDOM 2.x are significant in this regard....
Java 7 is much faster than previous versions in regard to iterator performance too.
There is no benefit to 'compiling' Jaxen XPaths....
even in the best of times though, the 'native' method of searching will be faster than the XPath version.

Your biggest performance boost will come from running with Java7, then upgrading to JDOM 2.x

Although the 'custom' search, if written efficiently, will always be faster than XPath.

Edit: Also, JDOM 2.x introduces a new API for running XPath queries that you may find easier to work with (although the old API still works too): https://github.com/hunterhacker/jdom/wiki/JDOM2-Feature-XPath-Upgrade

edited May 14 '12 at 18:46

answered May 14 '12 at 18:34

rolfl

17,539
7
42
76

Excellent points. More and more this project of mine begs to be taken off of outdated software, I'll definitely uses these resources here to make my case. Thanks! – JHarnach May 14 '12 at 18:56
rolfl- I noticed a performance issue with jdom1 XPath when using a simple/plain query. (example: /root/child1/sub2/blah, where there is only 1 node in the doc that is /root/child1/sub2, and lots of 'blah' children of that node) Looking in the jdom code, I found that in DefaultLocationPath.evaluate(...) it is sorting the results of the query before returning. This sort is what is occupying the majority of the execution time. Can you advise me what I might do to avoid the sorting that happens there? – Trevor Harrison May 31 '12 at 20:05
Hi Trevor. The right people to ask is the Jaxen folk, not JDOM. On the other hand, the sorting relies a great deal on creating iterators on the 'siblings' (blah's). JDOM 2.x has a faster iterator concept, so it is faster than JDOM 1.x. If you want to discuss this detail more you should probably sign up to the jdom-interest mailing list, or the jaxen malining list. Those are the correct forums.... – rolfl May 31 '12 at 23:26

When is JDOM XPATH faster than element hunting with getChildren?

1 Answers1