Normalisation dans l'analyse DOM avec java - comment ça marche?

J'ai vu la ligne ci-dessous dans le code d'un analyseur DOM lors de ce tutoriel .

doc.getDocumentElement().normalize();

Pourquoi faisons-nous cette normalisation?
J'ai lu les documents mais je n'ai pas pu comprendre un mot.

Place tous les nœuds de texte dans toute la profondeur de la sous-arborescence sous ce nœud

D'accord, alors quelqu'un peut-il me montrer (de préférence avec une photo) à quoi ressemble cet arbre?

Quelqu'un peut-il m'expliquer pourquoi une normalisation est nécessaire?
Que se passe-t-il si nous ne normalisons pas?

Le reste de la phrase est:

où seule la structure (par exemple, éléments, commentaires, instructions de traitement, sections CDATA et références d'entité) sépare les nœuds de texte, c'est-à-dire qu'il n'y a ni nœuds de texte adjacents ni nœuds de texte vides.

Cela signifie essentiellement que l'élément XML suivant

<foo>hello 
wor
ld</foo>

pourrait être représenté comme ceci dans un nœud dénormalisé:

Element foo
    Text node: ""
    Text node: "Hello "
    Text node: "wor"
    Text node: "ld"

Une fois normalisé, le nœud ressemblera à ceci

Element foo
    Text node: "Hello world"

Et il en va de même pour les attributs <foo bar="Hello world"/>:, commentaires, etc.

En termes simples, la normalisation est la réduction des redondances.
Exemples de redondances:
a) espaces blancs en dehors des balises racine / document ( ... <document> </document> ... )
b) espaces blancs dans la balise de début (< ... >) et la balise de fin (</ ... >)
c) les espaces blancs entre les attributs et leurs valeurs (c'est-à-dire les espaces entre le nom de la clé et = " )
d) les déclarations d'espace de noms superflues
e) les sauts de ligne / les espaces blancs dans les textes des attributs et des balises
f) les commentaires etc ...

En tant qu'extension de la réponse de @ JBNizet pour les utilisateurs plus techniques, voici à quoi ressemble la mise en œuvre de l' org.w3c.dom.Nodeinterface com.sun.org.apache.xerces.internal.dom.ParentNode, vous donne une idée de son fonctionnement réel .

public void normalize() {
    // No need to normalize if already normalized.
    if (isNormalized()) {
        return;
    }
    if (needsSyncChildren()) {
        synchronizeChildren();
    }
    ChildNode kid;
    for (kid = firstChild; kid != null; kid = kid.nextSibling) {
         kid.normalize();
    }
    isNormalized(true);
}

Il parcourt tous les nœuds récursivement et appelle kid.normalize()
Ce mécanisme est surchargé dansorg.apache.xerces.dom.ElementImpl

public void normalize() {
     // No need to normalize if already normalized.
     if (isNormalized()) {
         return;
     }
     if (needsSyncChildren()) {
         synchronizeChildren();
     }
     ChildNode kid, next;
     for (kid = firstChild; kid != null; kid = next) {
         next = kid.nextSibling;

         // If kid is a text node, we need to check for one of two
         // conditions:
         //   1) There is an adjacent text node
         //   2) There is no adjacent text node, but kid is
         //      an empty text node.
         if ( kid.getNodeType() == Node.TEXT_NODE )
         {
             // If an adjacent text node, merge it with kid
             if ( next!=null && next.getNodeType() == Node.TEXT_NODE )
             {
                 ((Text)kid).appendData(next.getNodeValue());
                 removeChild( next );
                 next = kid; // Don't advance; there might be another.
             }
             else
             {
                 // If kid is empty, remove it
                 if ( kid.getNodeValue() == null || kid.getNodeValue().length() == 0 ) {
                     removeChild( kid );
                 }
             }
         }

         // Otherwise it might be an Element, which is handled recursively
         else if (kid.getNodeType() == Node.ELEMENT_NODE) {
             kid.normalize();
         }
     }

     // We must also normalize all of the attributes
     if ( attributes!=null )
     {
         for( int i=0; i<attributes.getLength(); ++i )
         {
             Node attr = attributes.item(i);
             attr.normalize();
         }
     }

    // changed() will have occurred when the removeChild() was done,
    // so does not have to be reissued.

     isNormalized(true);
 } 

J'espère que cela vous fera gagner du temps.