जावा: org.w3c.dom.Document में सभी तत्वों को फिर से चलाने के लिए सबसे प्रभावी तरीका?

Question

जावा में सभी DOM तत्वों के माध्यम से पुन: प्रयास करने का सबसे प्रभावी तरीका क्या है?

कुछ ऐसा है लेकिन वर्तमान org.w3c.dom.Document पर प्रत्येक एकल डीओएम तत्वों के लिए?

for(Node childNode = node.getFirstChild(); childNode!=null;){ 
    Node nextChild = childNode.getNextSibling(); 
    // Do something with childNode, including move or delete... 
    childNode = nextChild; 
} 

Answer 1

मूल रूप से आप दो सभी तत्वों से अधिक पुनरावृत्ति करने के लिए तरीके हैं:

1. प्रत्यावर्तन का उपयोग करना (सबसे आम तरीका मुझे लगता है कि):

public static void main(String[] args) throws SAXException, IOException, 
     ParserConfigurationException, TransformerException { 

    DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory 
     .newInstance(); 
    DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder(); 
    Document document = docBuilder.parse(new File("document.xml")); 
    doSomething(document.getDocumentElement()); 
} 

public static void doSomething(Node node) { 
    // do something with the current node instead of System.out 
    System.out.println(node.getNodeName()); 

    NodeList nodeList = node.getChildNodes(); 
    for (int i = 0; i < nodeList.getLength(); i++) { 
     Node currentNode = nodeList.item(i); 
     if (currentNode.getNodeType() == Node.ELEMENT_NODE) { 
      //calls this method for all the children which is Element 
      doSomething(currentNode); 
     } 
    } 
} 

2. प्रत्यावर्तन से बचना getElementsByTagName() विधि * के साथ पैरामीटर के रूप में उपयोग:

public static void main(String[] args) throws SAXException, IOException, 
     ParserConfigurationException, TransformerException { 

    DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory 
      .newInstance(); 
    DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder(); 
    Document document = docBuilder.parse(new File("document.xml")); 

    NodeList nodeList = document.getElementsByTagName("*"); 
    for (int i = 0; i < nodeList.getLength(); i++) { 
     Node node = nodeList.item(i); 
     if (node.getNodeType() == Node.ELEMENT_NODE) { 
      // do something with the current element 
      System.out.println(node.getNodeName()); 
     } 
    } 
} 

मुझे लगता है कि ये तरीके दोनों कुशल हैं।
उम्मीद है कि यह मदद करता है।

Answer 2

for (int i = 0; i < nodeList.getLength(); i++)

परिवर्तन

को

for (int i = 0, len = nodeList.getLength(); i < len; i++)

अधिक कुशल होने का। दूसरा तरीका सबसे अच्छा हो सकता है क्योंकि यह एक चापलूसी, अनुमानित स्मृति मॉडल का उपयोग करता है।

Answer 3

मैंने हाल ही में इस समस्या पर भी ठोकर खाई। मेरा समाधान यहाँ है। मैं रिकर्सन से बचना चाहता था, इसलिए मैंने थोड़ी देर लूप का इस्तेमाल किया।

सूची में मनमाने ढंग से स्थानों में जोड़े और हटाए जाने के कारण, मैं LinkedList कार्यान्वयन के साथ गया।

/* traverses tree starting with given node */ 
    private static List<Node> traverse(Node n) 
    { 
    return traverse(Arrays.asList(n)); 
    } 

    /* traverses tree starting with given nodes */ 
    private static List<Node> traverse(List<Node> nodes) 
    { 
    List<Node> open = new LinkedList<Node>(nodes); 
    List<Node> visited = new LinkedList<Node>(); 

    ListIterator<Node> it = open.listIterator(); 
    while (it.hasNext() || it.hasPrevious()) 
    { 
     Node unvisited; 
     if (it.hasNext()) 
     unvisited = it.next(); 
     else 
     unvisited = it.previous(); 

     it.remove(); 

     List<Node> children = getChildren(unvisited); 
     for (Node child : children) 
     it.add(child); 

     visited.add(unvisited); 
    } 

    return visited; 
    } 

    private static List<Node> getChildren(Node n) 
    { 
    List<Node> children = asList(n.getChildNodes()); 
    Iterator<Node> it = children.iterator(); 
    while (it.hasNext()) 
     if (it.next().getNodeType() != Node.ELEMENT_NODE) 
     it.remove(); 
    return children; 
    } 

    private static List<Node> asList(NodeList nodes) 
    { 
    List<Node> list = new ArrayList<Node>(nodes.getLength()); 
    for (int i = 0, l = nodes.getLength(); i < l; i++) 
     list.add(nodes.item(i)); 
    return list; 
    }