Normalisierung beim Parsen von DOM mit Java - wie funktioniert das?

In diesem Tutorial habe ich die folgende Zeile im Code für einen DOM-Parser gesehen .

doc.getDocumentElement().normalize();

Warum machen wir diese Normalisierung?
Ich habe die Dokumente gelesen, aber ich konnte kein Wort verstehen.

Setzt alle Textknoten in der vollen Tiefe des Unterbaums unter diesen Knoten

Okay, kann mir dann jemand (vorzugsweise mit einem Bild) zeigen, wie dieser Baum aussieht?

Kann mir jemand erklären, warum eine Normalisierung erforderlich ist?
Was passiert, wenn wir uns nicht normalisieren?

Der Rest des Satzes lautet:

wobei nur die Struktur (z. B. Elemente, Kommentare, Verarbeitungsanweisungen, CDATA-Abschnitte und Entitätsreferenzen) Textknoten trennt, dh es gibt weder benachbarte Textknoten noch leere Textknoten.

Dies bedeutet im Grunde, dass das folgende XML-Element

<foo>hello 
wor
ld</foo>

könnte so in einem denormalisierten Knoten dargestellt werden:

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

Bei Normalisierung sieht der Knoten folgendermaßen aus

Element foo
    Text node: "Hello world"

Gleiches gilt für Attribute : <foo bar="Hello world"/>, Kommentare usw.

Normalisierung ist einfach eine Reduzierung von Redundanzen.
Beispiele für Redundanzen:
a) Leerzeichen außerhalb der Stamm- / Dokument-Tags ( ... <Dokument> </ Dokument> ... )
b) Leerzeichen innerhalb des Start-Tags (< ... >) und des End-Tags (</ ... >)
c) Leerzeichen zwischen Attributen und ihren Werten (dh Leerzeichen zwischen Schlüsselname und = " )
d) überflüssige Namespace-Deklarationen
e) Zeilenumbrüche / Leerzeichen in Texten von Attributen und Tags
f) Kommentare usw. ...

Als Erweiterung der Antwort von @ JBNizet für technisch versierte Benutzer erhalten Sie hier eine Vorstellung davon, wie die Implementierung der org.w3c.dom.NodeSchnittstelle in com.sun.org.apache.xerces.internal.dom.ParentNodeaussieht.

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

Es durchläuft alle Knoten rekursiv und ruft kid.normalize()
diesen Mechanismus auforg.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);
 } 

Hoffe das spart dir etwas Zeit.