primer - eliminar un elemento de un arreglo en java

¿Por qué no puedo eliminar un elemento secundario que acabo de encontrar? NOT_FOUND_ERR

Question

Estoy creando una secuencia de comandos que tiene que parchear archivos XML, incluida la sustitución de una lista de elementos con otra. La siguiente función aplica un parche (que implica una lista de elementos posiblemente vacía con el mismo nombre) en la lista de elementos del Elemento principal con el mismo nombre (posiblemente también una lista vacía). (Esto es solo una pequeña parte de la lógica de parcheo).

¿Por qué, cuando ejecuto el código, obtengo el siguiente error?

org.w3c.dom.DOMException: NOT_FOUND_ERR: An attempt is made to reference a node in a context where it does not exist.
    at com.sun.org.apache.xerces.internal.dom.ParentNode.internalRemoveChild(ParentNode.java:503)
    at com.sun.org.apache.xerces.internal.dom.ParentNode.removeChild(ParentNode.java:484)
    at CombineSweeps$PTReplaceNodeList.apply(CombineSweeps.java:514)

(La línea 514 está etiquetada a continuación). Por lo que yo entiendo, acabo de verificar que el elemento existe (porque NodeList está activo, su primera entrada siempre será la siguiente coincidencia o nula). Curiosamente, esto no siempre es un problema.

private static class PTReplaceNodeList extends PTBase {
    private final String name;
    private final String nextElement;
    private final List<Node> childList;

    ...

    int apply(Document document, Node parent, Node node_unused) {
        NodeList nodes;
        // A marker for where to insert our nodes.
        // We make a guess using nextElement (if null, means at end).
        Node refNode = null;
        if (parent instanceof Document) {   // root element
            Document parDoc = (Document) parent;
            nodes = parDoc.getElementsByTagName(name);
            if (nextElement != null) {
                refNode = parDoc.getElementsByTagName(nextElement).item(0);
            }
        } else {
            Element parElt = (Element) parent;
            nodes = parElt.getElementsByTagName(name);
            if (nextElement != null) {
                refNode = parElt.getElementsByTagName(nextElement).item(0);
            }
        }

        while (true) {
            // iterate through the list of nodes
            Node node = nodes.item(0);
            if (node == null) {
                break;
            }

            // Reliable guess: insert before node following last in list
            refNode = node.getNextSibling();

            parent.removeChild(node);  // line 514
        }

        for (Node child : childList) {
            Node imported = document.importNode(child, true);
            parent.insertBefore(imported, refNode);
        }
        return childList.size();
    }
}

Edición: usé la siguiente función como reemplazo de getElementsByTagName() (ver respuesta aceptada).

/** Returns all direct children of node with name name.
 *
 * Note: not the same as getElementsByTagName(), which finds all descendants. */
static List<Node> getChildNodes( Node node, String name ){
    ArrayList<Node> r = new ArrayList<Node>();
    NodeList children = node.getChildNodes();
    int l = children.getLength();
    for( int i = 0; i < l; ++i ){
        if( name.equals( children.item(i).getNodeName() ) )
            r.add( children.item(i) );
    }
    return r;
}

Answer 1

Esto se debe a que cuando estás haciendo parent.removeChild (node), parent no es necesariamente el padre del nodo porque getElementsByTagName () está haciendo una búsqueda recursiva.

Answer 2

Sobre la base del diagnóstico realizado por @Maurice y @fahd ...

¿No puedes poner una condición antes?

parent.removeChild(node);

como

if (parent.isSameNode(node.getParentNode()))

Entonces solo eliminaría un hijo directo del padre dado.

Answer 3

qué tal si

nodeToBeRemoved.getParentNode().removeChild(nodeToBeRemoved);

Answer 4

parent.removeChild(node) está lanzando un NOT_FOUND_ERR porque node no es un elemento secundario de parent . Veo que el node proviene de getElementsByTagName que podría no ser un hijo inmediato del parent . Podría estar en cualquier lugar debajo de los parent .