SAX è un parser procedurale, si può usare per file molto grandi (genere un gigabyte) ma penso che DOM sia più comprensibile in quanto dichiara l'esistenza di nodi, elementi e attributi che hanno un'immediata corrispondenza con la struttura di un documento XML.
Quanto alla differenza C#, Java, le due lingue sono praticamente identiche, probabilmente è una questione di librerie.
Potresti provare a guardare se la fondazione Apache ha le librerie XML DOM per C#: sono le stesse usate da Java.
Comunque, il grosso della lettura di un documento XML in Java con DOM sta nell'ottenere l'oggetto Document. Bisogna passare per un po' di intermediari. Supponiamo che il file si chiami "documento.xml". La lettura di questo documento si farebbe con:
DocumentBuilderFactory factory;
DocumentBuilder builder;
Document document;
try {
factory = DocumentBuilderFactory.newInstance();
builder = factory.newDocumentBuilder();
document = builder.parse(new java.io.File("documento.xml"));
gestioneDocumento(document); //un metodo definito a parte
} catch(Exception ex) {
ex.printStackTrace();
//varie
}
Una volta che hai il Document (org.w3c.Document) "lavori" con Element, Node, NodeList, AttributeSet e String.
Ad esempio, per quel documento, il nodo "libri", radice del documento, è:
Element radice = document.getDocumentElement();
Puoi recuperare direttamente i nodi "libro" con il metodo getElementsByTagName(string) di Document:
NodeList elencoLibri = document.getElementsByTagName("libro");
Il NodeList è una lista che ha nodeList.getLength() elementi ognuno dei quali accessibile con lista.item(indice).
Per prelevare il testo contenuto in un nodo puoi usare il metodo getTextContent().
Ad esempio per il nodo:
<autore>Pippo</autore>
il metodo getTextContent restituisce Pippo.
I nodi come autore, costo, libro, libri, titolo, sono degli elementi. E' utile saperlo perche gli elementi (Element) hanno dei metodi in più rispetto ai nodi (Node), in particolare ti permettono di ottenere una lista di tutti i figli di nome N.
Scrivo un esempio di lettura del documento xml che hai incollato.
import org.w3c.dom.*;
import javax.xml.parsers.*;
public class Main {
public static void main(String[] args) {
DocumentBuilderFactory factory;
DocumentBuilder parser;
Document document;
try {
factory = DocumentBuilderFactory.newInstance();
parser = factory.newDocumentBuilder();
document = parser.parse(new java.io.File("documento.xml"));
handleDocument(document);
} catch(Exception ex) {
System.out.println("Errore.");
ex.printStackTrace();
}
}
private static void handleDocument(Document document) {
/* Tutti i nodi contenuti in document che si chiamano "libro" */
NodeList libri = document.getElementsByTagName("libro");
for(int i = 0; i < libri.getLength(); i++) {
Element libro = (Element)libri.item(i);
String autore = libro.getElementsByTagName("autore").item(0).getTextContent();
String titolo = libro.getElementsByTagName("titolo").item(0).getTextContent();
String prezzo = libro.getElementsByTagName("costo").item(0).getTextContent();
System.out.println("Autore: " + autore);
System.out.println("Titolo: " + titolo);
System.out.println("Prezzo: " + prezzo);
}
}
}
Le linee:
libro.getElementsByTagName(X).item(0).getTextContent() sono la concatenazione di:
NodeList figli = libro.getElementsByTagName(X);
Node x = figli.item(0);
String testo = x.getTextContent();
Cioè dato il nodo libro, che sarebbe:
<libro>
<autore>pippo</autore>
<titolo>primo titolo</titolo>
<costo>11</costo>
</libro>
getElementsByTagName("autore") restituisce, in forma di NodeList, tutti i figli di libro che si chiamano "autore". Uno solo, quindi item(0) su quel NodeList restituisce il primo (e unico) nodo che si chiama "autore" in libro. Lo stesso vale per gli altri due. Uso questo getElementsByTagName perchè libro potrebbe avere più figli di quanti appaiano. In particolare se lo schema del documento non "scarta" gli spazi vuoti allora libro ha dei figli di tipo Text che contengono i caratteri vuoti. In questo caso dire:
libro.getChildNodes().item(0);
non corrisponderebbe ad ottenere il nodo "autore" ma uno strambo nodo che c'è ma non si vede. Cercando i figli per nome sei certo di andare a pescare dove dovresti.