Java Utililty Methods XML Child Node Get

Collection<Node> list = new LinkedList<Node>();
NodeList nl = node.getChildNodes();
for (int i = 0; i < nl.getLength(); i++)
    if (nl.item(i).getNodeType() == Node.ELEMENT_NODE)
        list.add(nl.item(i));
return list;

NodeList children = node.getChildNodes();
if (children == null) {
    return new Node[0];
int n = children.getLength();
List<Node> elnodelist = new ArrayList<Node>(n);
for (int i = 0; i < n; ++i) {
    Node childnode = children.item(i);
...

ArrayList<Node> results = new ArrayList<Node>();
NodeList nodeList = node.getChildNodes();
for (int i = 0; i < nodeList.getLength(); i++) {
    Node temp = nodeList.item(i);
    if (temp.getNodeType() != Node.ELEMENT_NODE)
        continue;
    if (name.equals(temp.getLocalName()) || name.equals(temp.getNodeName())) {
        results.add(temp);
...

final List<Element> result = new ArrayList<Element>();
final NodeList nodes = parent.getChildNodes();
final int len = nodes.getLength();
for (int i = 0; i < len; i++) {
    final Node n = nodes.item(i);
    if (!isElementNode(n)) {
        continue;
    if (n.getNodeName().equals(childName)) {
        result.add((Element) n);
return result;

ArrayList<Node> childNodesArray = new ArrayList<Node>();
if (null != parentNode) {
    NodeList childNodes = parentNode.getChildNodes();
    if (null != childNodes && childNodes.getLength() > 0) {
        for (int i = 0; i < childNodes.getLength(); i++) {
            Node child = childNodes.item(i);
            if (null != child) {
                childNodesArray.add(child);
...

Set retVal = new HashSet();
NodeList children = parentNode.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
    Node node = children.item(i);
    if (node.getNodeName().equalsIgnoreCase(childName)) {
        retVal.add(node);
return (retVal);

Vector children = new Vector();
NodeList nodes = parentNode.getChildNodes();
for (int i = 0; i < nodes.getLength(); i++) {
    Node n = nodes.item(i);
    if (n.getNodeType() == Node.TEXT_NODE || n.getNodeType() == Node.COMMENT_NODE)
        continue;
    if (childNodeName == null || n.getNodeName().equals(childNodeName))
        children.add(n);
...

List<Node> nodes = new ArrayList<Node>();
NodeList nodeList = rootNode.getChildNodes();
for (int nodeIndex = 0, nodeSize = nodeList.getLength(); nodeIndex < nodeSize; nodeIndex++) {
    Node childNode = nodeList.item(nodeIndex);
    if (childNode.getNodeName().equals(childName)) {
        nodes.add(childNode);
return nodes.toArray(new Node[nodes.size()]);

List<Node> nodeList = new ArrayList<Node>();
NodeList childNodes = parent.getChildNodes();
int length = childNodes.getLength();
for (int i = 0; i < length; i++) {
    Node current = childNodes.item(i);
    if (current.getNodeName().equals(name))
        nodeList.add(current);
Node[] nodes = new Node[nodeList.size()];
nodeList.toArray(nodes);
return nodes;

ArrayList<Node> nodes = new ArrayList<Node>();
NodeList list = element.getChildNodes();
for (int i = 0; i < list.getLength(); i++) {
    Node node = list.item(i);
    if (caseSensitive) {
        if (node.getNodeName().equals(name))
            nodes.add(node);
    } else {
...