Normalizzazione nell'analisi DOM con java: come funziona?

Ho visto la riga seguente nel codice per un parser DOM in questo tutorial .

doc.getDocumentElement().normalize();

Perché facciamo questa normalizzazione?
Ho letto i documenti ma non sono riuscito a capire una parola.

Mette tutti i nodi di testo in tutta la profondità dell'albero secondario sotto questo nodo

Okay, allora qualcuno può mostrarmi (preferibilmente con una foto) come appare questo albero?

Qualcuno può spiegarmi perché è necessaria la normalizzazione?
Cosa succede se non ci normalizziamo?

Il resto della frase è:

dove solo la struttura (ad es. elementi, commenti, istruzioni di elaborazione, sezioni CDATA e riferimenti di entità) separa i nodi di testo, ovvero non ci sono nodi di testo adiacenti né nodi di testo vuoti.

Ciò significa sostanzialmente che il seguente elemento XML

<foo>hello 
wor
ld</foo>

potrebbe essere rappresentato in questo modo in un nodo denormalizzato:

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

Quando normalizzato, il nodo sarà simile a questo

Element foo
    Text node: "Hello world"

E lo stesso vale per gli attributi: <foo bar="Hello world"/>commenti, ecc.

In parole povere, la normalizzazione è la riduzione dei licenziamenti.
Esempi di ridondanze:
a) spazi bianchi all'esterno dei tag radice / documento ( ... <document> </document> ... )
b) spazi bianchi all'interno del tag iniziale (< ... >) e del tag finale (</ ... >)
c) spazi bianchi tra gli attributi e i loro valori (es. spazi tra nome chiave e = " )
d) dichiarazioni di spazio dei nomi superflue
e) interruzioni di riga / spazi bianchi nei testi di attributi e tag
f) commenti ecc ...

Come estensione alla risposta di @ JBNizet per più utenti tecnici ecco come appare l' implementazione org.w3c.dom.Nodedell'interfaccia com.sun.org.apache.xerces.internal.dom.ParentNode, ti dà l'idea di come funziona effettivamente.

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);
}

Attraversa tutti i nodi in modo ricorsivo e chiama kid.normalize()
Questo meccanismo viene sostituitoorg.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);
 } 

Spero che questo ti faccia risparmiare un po 'di tempo.