Normalización en el análisis DOM con Java: ¿cómo funciona?

Vi la siguiente línea en el código para un analizador DOM en este tutorial .

doc.getDocumentElement().normalize();

¿Por qué hacemos esta normalización?
Leí los documentos pero no pude entender una palabra.

Pone todos los nodos de texto en toda la profundidad del subárbol debajo de este nodo

Bien, entonces, ¿alguien puede mostrarme (preferiblemente con una foto) cómo se ve este árbol?

¿Alguien puede explicarme por qué se necesita la normalización?
¿Qué pasa si no nos normalizamos?

El resto de la oración es:

donde solo la estructura (p. ej., elementos, comentarios, instrucciones de procesamiento, secciones CDATA y referencias de entidades) separa los nodos de texto, es decir, no hay nodos de texto adyacentes ni nodos de texto vacíos.

Esto básicamente significa que el siguiente elemento XML

<foo>hello 
wor
ld</foo>

podría representarse así en un nodo desnormalizado:

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

Cuando se normaliza, el nodo se verá así

Element foo
    Text node: "Hello world"

Y lo mismo ocurre con los atributos: <foo bar="Hello world"/>comentarios, etc.

En simple, la normalización es la reducción de redundancias.
Ejemplos de redundancias:
a) espacios en blanco fuera de las etiquetas raíz / documento ( ... <documento> </documento> ... )
b) espacios en blanco dentro de la etiqueta de inicio (< ... >) y la etiqueta de finalización (</ ... >)
c) espacios en blanco entre los atributos y sus valores (es decir, espacios entre el nombre clave y = " )
d) declaraciones de espacio de nombres superfluas
e) saltos de línea / espacios en blanco en textos de atributos y etiquetas
f) comentarios, etc.

Como extensión de la respuesta de @ JBNizet para usuarios más técnicos , así es como se ve la implementación de la org.w3c.dom.Nodeinterfaz com.sun.org.apache.xerces.internal.dom.ParentNode, le da la idea de cómo funciona realmente.

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

Atraviesa todos los nodos de forma recursiva y llama a kid.normalize()
este mecanismo.org.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);
 } 

Espero que esto te ahorre algo de tiempo.