Shows up fine here. If you're using GoogleGroups, try using the "raw"
view to see what other usenet users actually see.

   "Best" way is probably to define a DTD or Schema explicitly stating
the format of your XML format, and in what locations is whitespace not
significant, and places where it IS significant. For example, in your
<song> tag, whitespace IS significant. The elements <song>some file
name.mp3</song> and <song>some    file    name.mp3</song> point to two
different files on the file system.

   Failing that, you can always write a hack:

<SSCCE>
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;
import org.xml.sax.SAXException;

public class XMLTest {
 public static void main(final String[] args) throws Exception {
   final Document document = inputXML();
   doProcessing(document);
   stripWhitespace(document.getDocumentElement());
   outputXML(document);
 }

 private static Document inputXML() throws ParserConfigurationException,
SAXException, IOException {
   final DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
   final DocumentBuilder builder = factory.newDocumentBuilder();
   final Document document = builder.parse(new File("songs.xml"));
   return document;
 }

 private static void doProcessing(final Document document) {
   final NodeList songNodes = document.getElementsByTagName("song");
   while (songNodes.getLength() > 0) {
     final Node songNode = songNodes.item(0);
     songNode.getParentNode().removeChild(songNode);
   }
 }

 private static void outputXML(final Document document) throws
TransformerFactoryConfigurationError, TransformerConfigurationException,
TransformerException {
   final TransformerFactory tFactory = TransformerFactory.newInstance();
   final Transformer transformer = tFactory.newTransformer();
   final DOMSource source = new DOMSource(document);
   final StreamResult result = new StreamResult(System.out);
   transformer.transform(source, result);
 }

 private static void stripWhitespace(Node e) {
   NodeList children = e.getChildNodes();
   List<Node> childrenToRemove = new ArrayList<Node>();
   for (int i = 0; i < children.getLength(); i++) {
     final Node currElement = children.item(i);
     if (currElement.getNodeType() == Node.TEXT_NODE) {
       Text t = (Text) currElement;
       if (t.getData().trim().length() == 0) {
         childrenToRemove.add(t);
       }
     }
   }
   for (Node n: childrenToRemove) {
     e.removeChild(n);
   }
   for (int i = 0; i < children.getLength(); i++) {
     stripWhitespace(children.item(i));
   }
 }
}
</SSCCE>

   This program expects your data to be in the song.xml file, and outputs
the results to standard out.

   Notice I also provide two alternative tricks for removing elements
without resorting to "i--;" which I think will be bug prone.

   You'll probably want to modify stripWhitespace() to do something a bit
more intelligent than just obliterating any text elements which contain
only whitespace.

   - Oliver