Qual é a diferença entre SAX e DOM?

Li alguns artigos sobre os analisadores XML e me deparei com SAX e DOM .

O SAX é baseado em eventos e o DOM é um modelo de árvore - não entendo as diferenças entre esses conceitos.

Pelo que entendi, com base em evento significa que algum tipo de evento acontece no nó. Como quando alguém clica em um nó específico, ele fornece todos os subnós, em vez de carregar todos os nós ao mesmo tempo. Mas, no caso da análise do DOM, ele carregará todos os nós e criará o modelo em árvore.

Meu entendimento está correto?

Corrija-me Se estiver errado ou explique-me o modelo de árvore e baseado em eventos de uma maneira mais simples.

Bem, você está perto.

No SAX, os eventos são acionados quando o XML está sendo analisado . Quando o analisador está analisando o XML e encontra uma tag iniciada (por exemplo <something>), ele dispara o tagStartedevento (o nome real do evento pode ser diferente). Da mesma forma, quando o fim da tag é atingido durante a análise ( </something>), ele é acionado tagEnded. O uso de um analisador SAX implica que você precisa manipular esses eventos e entender os dados retornados com cada evento.

No DOM, não há eventos disparados durante a análise. O XML inteiro é analisado e uma árvore DOM (dos nós no XML) é gerada e retornada. Uma vez analisado, o usuário pode navegar na árvore para acessar os vários dados anteriormente incorporados nos vários nós no XML.

Em geral, o DOM é mais fácil de usar, mas possui uma sobrecarga de analisar todo o XML antes que você possa começar a usá-lo.

Em poucas palavras ...

SAX ( S exe Um PI para X ML): é um processador baseado em fluxo. Você tem apenas uma pequena parte da memória a qualquer momento e "fareja" o fluxo XML implementando código de retorno de chamada para eventos como tagStarted()etc. Ele quase não usa memória, mas você não pode fazer coisas "DOM", como usar xpath ou atravessar árvores

DOM ( D ocument O bject M odelo): Você carrega a coisa toda na memória - é um devorador de memória maciça. Você pode gastar memória com documentos de tamanho médio. Mas você pode usar o xpath e atravessar a árvore etc.

Aqui em palavras mais simples:

DOM

• Analisador de modelo de árvore (baseado em objeto) (árvore de nós).

• O DOM carrega o arquivo na memória e, em seguida, analisa o arquivo.

• Possui restrições de memória, pois carrega o arquivo XML inteiro antes de analisar.

• O DOM é de leitura e gravação (pode inserir ou excluir nós).

• Se o conteúdo XML for pequeno, prefira o analisador DOM.

• A pesquisa para trás e para a frente é possível para pesquisar as tags e avaliar as informações dentro das tags. Portanto, isso facilita a navegação.

• Mais lento em tempo de execução.

SAXOFONE

• Analisador baseado em eventos (Sequência de eventos).

• O SAX analisa o arquivo enquanto o lê, ou seja, analisa nó por nó.

• Sem restrições de memória, pois não armazena o conteúdo XML na memória.

• O SAX é somente leitura, ou seja, não pode inserir ou excluir o nó.

• Use o analisador SAX quando o conteúdo da memória for grande.

• O SAX lê o arquivo XML de cima para baixo e a navegação para trás não é possível.

• Mais rápido em tempo de execução.

Você está correto em sua compreensão do modelo baseado em DOM. O arquivo XML será carregado como um todo e todo o seu conteúdo será construído como uma representação na memória da árvore que o documento representa. Isso pode consumir tempo e memória, dependendo do tamanho do arquivo de entrada. O benefício dessa abordagem é que você pode consultar facilmente qualquer parte do documento e manipular livremente todos os nós da árvore.

A abordagem DOM normalmente é usada para estruturas XML pequenas (onde pequenas dependem da quantidade de potência e memória que sua plataforma possui) que talvez precisem ser modificadas e consultadas de maneiras diferentes depois de carregadas.

O SAX, por outro lado, foi projetado para lidar com a entrada XML de praticamente qualquer tamanho. Em vez de a estrutura XML fazer o trabalho duro para você descobrir a estrutura do documento e preparar potencialmente muitos objetos para todos os nós, atributos etc., o SAX deixa isso completamente para você.

O que basicamente faz é ler a entrada da parte superior e chamar os métodos de retorno de chamada que você fornece quando certos "eventos" ocorrem. Um evento pode estar atingindo uma tag de abertura, um atributo na tag, localizando texto dentro de um elemento ou encontrando uma tag final.

O SAX lê teimosamente a entrada e informa o que vê dessa maneira. Cabe a você manter todas as informações de estado necessárias. Normalmente, isso significa que você criará algum tipo de máquina de estado.

Embora essa abordagem do processamento XML seja muito mais entediante, também pode ser muito poderosa. Imagine que você deseja apenas extrair os títulos dos artigos de notícias de um feed de blog. Se você ler esse XML usando o DOM, ele carregará todo o conteúdo do artigo, todas as imagens etc. contidas no XML na memória, mesmo que você nem esteja interessado nele.

Com o SAX, você pode apenas verificar se o nome do elemento é (por exemplo) "title" sempre que seu método de evento "startTag" é chamado. Nesse caso, você sabe que precisa adicionar o que o próximo evento "elementText" oferecer. Ao receber a chamada de evento "endTag", verifique novamente se esse é o elemento de fechamento do "título". Depois disso, você simplesmente ignora todos os outros elementos, até que a entrada termine ou outro "startTag" com o nome "title" apareça. E assim por diante...

Você pode ler megabytes e megabytes de XML dessa maneira, apenas extraindo a pequena quantidade de dados necessária.

O lado negativo dessa abordagem é, obviamente, que você precisa fazer muito mais contabilidade, dependendo de quais dados você precisa extrair e de quão complicada é a estrutura XML. Além disso, você naturalmente não pode modificar a estrutura da árvore XML, porque você nunca a tem em mãos como um todo.

Portanto, em geral, o SAX é adequado para vasculhar quantidades potencialmente grandes de dados que você recebe com uma "consulta" específica em mente, mas não precisa modificar, enquanto o DOM é mais voltado para oferecer flexibilidade total na alteração de estrutura e conteúdo, às custas maior demanda de recursos.

Você está comparando maçãs e peras. SAX é um analisador que analisa estruturas DOM serializadas. Existem muitos analisadores diferentes e "baseado em evento" refere-se ao método de análise.

Talvez uma pequena recapitulação esteja em ordem:

• O DOM ( Document Object Model ) é um modelo de dados abstrato que descreve uma estrutura hierárquica de documentos baseada em árvore; uma árvore de documentos consiste em nós , nomeadamente nós de elemento, atributo e texto (e alguns outros). Os nós têm pais, irmãos e filhos e podem ser percorridos, etc., tudo o que você está acostumado a fazer no JavaScript (que aliás não tem nada a ver com o DOM).

• Uma estrutura DOM pode ser serializada , ou seja, gravada em um arquivo, usando uma linguagem de marcação como HTML ou XML. Um arquivo HTML ou XML, portanto, contém uma versão "gravada" ou "achatada" de uma árvore de documento abstrata.

• Para um computador manipular ou até exibir uma árvore DOM de um arquivo, ele precisa desserializar ou analisar o arquivo e reconstruir a árvore abstrata na memória. É aqui que entra a análise.

Agora chegamos à natureza dos analisadores. Uma maneira de analisar seria ler o documento inteiro e criar recursivamente uma estrutura de árvore na memória e, finalmente, expor o resultado inteiro ao usuário. (Suponho que você possa chamar esses analisadores de "analisadores DOM".) Isso seria muito útil para o usuário (acho que é o que o analisador XML do PHP faz), mas sofre de problemas de escalabilidade e se torna muito caro para documentos grandes.

Por outro lado, a análise baseada em eventos , como feita pelo SAX, analisa o arquivo linearmente e simplesmente faz retornos de chamada para o usuário sempre que ele encontra um dado estrutural, como "esse elemento iniciado", "esse elemento encerrado" , "algum texto aqui" etc. etc. Isso tem o benefício de poder continuar para sempre sem se preocupar com o tamanho do arquivo de entrada, mas é muito mais baixo porque requer que o usuário faça todo o trabalho de processamento real (fornecendo retornos de chamada). Para retornar à sua pergunta original, o termo "baseado em evento" refere-se aos eventos de análise que o analisador gera ao atravessar o arquivo XML.

O artigo da Wikipedia tem muitos detalhes sobre os estágios da análise do SAX.

Fornecerei uma resposta geral orientada para perguntas e respostas para esta pergunta:

Resposta a perguntas

Por que precisamos do analisador XML?

Precisamos do analisador XML, porque não queremos fazer tudo em nosso aplicativo do zero e precisamos de alguns programas ou bibliotecas "auxiliares" para fazer algo de nível muito baixo, mas muito necessário para nós. Essas coisas de baixo nível, mas necessárias, incluem verificar a boa formação, validar o documento com relação ao seu DTD ou esquema (apenas para validar analisadores), resolver a referência de caracteres, entender as seções CDATA e assim por diante. Os analisadores XML são exatamente esses programas "auxiliares" e farão todos esses trabalhos. Com o analisador XML, somos protegidos de muitas dessas complexidades e podemos nos concentrar em apenas programar em alto nível através das APIs implementadas pelos analisadores e, assim, obter eficiência na programação.

Qual é o melhor, SAX ou DOM?

O analisador SAX e DOM têm suas vantagens e desvantagens. Qual é o melhor deve depender das características do seu aplicativo (consulte algumas perguntas abaixo).

Qual analisador pode obter melhor velocidade, analisadores DOM ou SAX?

O analisador SAX pode obter melhor velocidade.

Qual é a diferença entre API baseada em árvore e API baseada em eventos?

Uma API baseada em árvore é centralizada em uma estrutura de árvore e, portanto, fornece interfaces nos componentes de uma árvore (que é um documento DOM), como interface de documento, interface de nó, interface de NodeList, interface de elemento, interface de atributo e assim por diante. Por outro lado, no entanto, uma API baseada em eventos fornece interfaces nos manipuladores. Existem quatro interfaces de manipulador, interface ContentHandler, interface DTDHandler, interface EntityResolver e interface ErrorHandler.

Qual é a diferença entre um analisador DOM e um analisador SAX?

Analisadores DOM e SAX funcionam de diferentes maneiras:

• Um analisador DOM cria uma estrutura em árvore na memória a partir do documento de entrada e aguarda solicitações do cliente. Mas um analisador SAX não cria nenhuma estrutura interna. Em vez disso, considera as ocorrências dos componentes de um documento de entrada como eventos e informa ao cliente o que ele lê ao ler o documento de entrada. UMA

• O analisador DOM sempre atende ao aplicativo cliente com o documento inteiro, independentemente do quanto seja realmente necessário ao cliente. Mas um analisador SAX atende ao aplicativo cliente sempre apenas com partes do documento a qualquer momento.

• Com o analisador DOM, as chamadas de método no aplicativo cliente precisam ser explícitas e formar um tipo de cadeia. Porém, com o SAX, alguns métodos (geralmente substituídos pelo cientista) serão invocados automaticamente (implicitamente) de uma maneira que é chamada de "retorno de chamada" quando ocorrem certos eventos. Esses métodos não precisam ser chamados explicitamente pelo cliente, embora possamos chamá-los explicitamente.

Como decidimos qual analisador é bom?

Idealmente, um bom analisador deve ser rápido (econômico em termos de tempo), econômico em espaço, rico em funcionalidades e fácil de usar. Mas, na realidade, nenhum dos principais analisadores possui todos esses recursos ao mesmo tempo. Por exemplo, um Analisador DOM é rico em funcionalidade (porque cria uma árvore DOM na memória e permite acessar qualquer parte do documento repetidamente e permite modificar a árvore DOM), mas é ineficiente em termos de espaço quando o documento é enorme , e leva um pouco de tempo para aprender a trabalhar com ele. Um analisador SAX, no entanto, é muito mais eficiente em termos de espaço no caso de grandes documentos de entrada (porque não cria estrutura interna). Além disso, ele roda mais rápido e é mais fácil de aprender do que o Analisador DOM, porque sua API é realmente simples. Mas do ponto de vista da funcionalidade, fornece menos funções, o que significa que os próprios usuários precisam cuidar de mais, como criar suas próprias estruturas de dados. A propósito, o que é um bom analisador? Eu acho que a resposta realmente depende das características do seu aplicativo.

Quais são alguns aplicativos do mundo real em que o uso do analisador SAX é vantajoso do que o uso do analisador DOM e vice-versa? Qual é o aplicativo usual para um analisador DOM e para um analisador SAX?

Nos seguintes casos, usar o analisador SAX é vantajoso do que usar o analisador DOM.

• O documento de entrada é muito grande para a memória disponível (na verdade, neste caso, o SAX é sua única opção)
• Você pode processar o documento em pequenos pedaços contíguos de entrada. Você não precisa de todo o documento antes de poder realizar um trabalho útil
• Você só deseja usar o analisador para extrair as informações de seu interesse e todo o seu cálculo será completamente baseado nas estruturas de dados criadas por você. Na verdade, na maioria dos aplicativos, criamos estruturas de dados próprias, que geralmente não são tão complicadas quanto a árvore DOM. Nesse sentido, acho, a chance de usar um analisador DOM é menor do que a de usar um analisador SAX.

Nos seguintes casos, usar o analisador DOM é vantajoso do que usar o analisador SAX.

• Seu aplicativo precisa acessar partes do documento amplamente separadamente ao mesmo tempo.
• Seu aplicativo provavelmente pode usar uma estrutura de dados interna quase tão complicada quanto o próprio documento.
• Seu aplicativo precisa modificar o documento repetidamente.
• Seu aplicativo precisa armazenar o documento por um período significativo de tempo por meio de várias chamadas de método.

Exemplo (Use um analisador DOM ou SAX?):

Suponha que um instrutor tenha um documento XML que contenha todas as informações pessoais dos alunos, bem como os pontos que seus alunos fizeram em sua classe, e agora ele está atribuindo notas finais para os alunos usando um aplicativo. O que ele quer produzir é uma lista com o SSN e as notas. Também assumimos que, em sua aplicação, o instrutor não usa estrutura de dados, como matrizes, para armazenar as informações pessoais e os pontos do aluno. Se o instrutor decidir dar A's para aqueles que obtiveram a média da aula ou mais, e dar Bs para os outros, é melhor usar um analisador DOM em seu aplicativo. O motivo é que ele não tem como saber quanto é a média da turma antes que todo o documento seja processado. O que ele provavelmente precisa fazer em sua inscrição é o primeiro a analisar todos os pontos e calcule a média e, em seguida, examine o documento novamente e atribua a nota final a cada aluno comparando os pontos que ele ganhou com a média da turma. Se, no entanto, o instrutor adotar uma política de classificação que permita que os alunos com 90 pontos ou mais recebam A e os outros com B, provavelmente é melhor usar um analisador SAX. O motivo é que, para atribuir uma nota final a cada aluno, ele não precisa esperar que todo o documento seja processado. Ele pode atribuir uma nota imediatamente a um aluno assim que o analisador SAX ler a nota desse aluno. Na análise acima, assumimos que o instrutor não criou sua própria estrutura de dados. E se ele criar sua própria estrutura de dados, como uma matriz de cadeias para armazenar o SSN e uma matriz de números inteiros para armazenar os pontos? Nesse caso, Eu acho que o SAX é uma escolha melhor, antes que isso economizasse memória e tempo, além de fazer o trabalho. Bem, mais uma consideração neste exemplo. E se o que o instrutor deseja fazer não for imprimir uma lista, mas salvar o documento original de volta com a nota de cada aluno atualizada? Nesse caso, um analisador DOM deve ser uma escolha melhor, independentemente da política de classificação que ele esteja adotando. Ele não precisa criar nenhuma estrutura de dados própria. O que ele precisa fazer é primeiro modificar a árvore do DOM (ou seja, definir o valor para o nó 'grade') e depois salvar a árvore inteira modificada. Se ele optar por usar um analisador SAX em vez de um analisador DOM, nesse caso, ele precisará criar uma estrutura de dados quase tão complicada quanto uma árvore DOM antes que ele possa fazer o trabalho. ainda assim, faça o trabalho. Bem, mais uma consideração neste exemplo. E se o que o instrutor deseja fazer não for imprimir uma lista, mas salvar o documento original de volta com a nota de cada aluno atualizada? Nesse caso, um analisador DOM deve ser uma escolha melhor, independentemente da política de classificação que ele esteja adotando. Ele não precisa criar nenhuma estrutura de dados própria. O que ele precisa fazer é primeiro modificar a árvore do DOM (ou seja, definir o valor para o nó 'grade') e depois salvar a árvore inteira modificada. Se ele optar por usar um analisador SAX em vez de um analisador DOM, nesse caso, ele precisará criar uma estrutura de dados quase tão complicada quanto uma árvore DOM antes que ele possa fazer o trabalho. ainda assim, faça o trabalho. Bem, mais uma consideração neste exemplo. E se o que o instrutor deseja fazer não for imprimir uma lista, mas salvar o documento original de volta com a nota de cada aluno atualizada? Nesse caso, um analisador DOM deve ser uma escolha melhor, independentemente da política de classificação que ele esteja adotando. Ele não precisa criar nenhuma estrutura de dados própria. O que ele precisa fazer é primeiro modificar a árvore do DOM (ou seja, definir o valor para o nó 'grade') e depois salvar a árvore inteira modificada. Se ele optar por usar um analisador SAX em vez de um analisador DOM, nesse caso, ele precisará criar uma estrutura de dados quase tão complicada quanto uma árvore DOM antes que ele possa fazer o trabalho. mas para salvar o documento original de volta com a nota de cada aluno atualizada? Nesse caso, um analisador DOM deve ser uma escolha melhor, independentemente da política de classificação que ele esteja adotando. Ele não precisa criar nenhuma estrutura de dados própria. O que ele precisa fazer é primeiro modificar a árvore do DOM (ou seja, definir o valor para o nó 'grade') e depois salvar a árvore inteira modificada. Se ele optar por usar um analisador SAX em vez de um analisador DOM, nesse caso, ele precisará criar uma estrutura de dados quase tão complicada quanto uma árvore DOM antes que ele possa fazer o trabalho. mas para salvar o documento original de volta com a nota de cada aluno atualizada? Nesse caso, um analisador DOM deve ser uma escolha melhor, independentemente da política de classificação que ele esteja adotando. Ele não precisa criar nenhuma estrutura de dados própria. O que ele precisa fazer é primeiro modificar a árvore do DOM (ou seja, definir o valor para o nó 'grade') e depois salvar a árvore inteira modificada. Se ele optar por usar um analisador SAX em vez de um analisador DOM, nesse caso, ele precisará criar uma estrutura de dados quase tão complicada quanto uma árvore DOM antes que ele possa fazer o trabalho. nó) e salve a árvore inteira modificada. Se ele optar por usar um analisador SAX em vez de um analisador DOM, nesse caso, ele precisará criar uma estrutura de dados quase tão complicada quanto uma árvore DOM antes que ele possa fazer o trabalho. nó) e salve a árvore inteira modificada. Se ele optar por usar um analisador SAX em vez de um analisador DOM, nesse caso, ele precisará criar uma estrutura de dados quase tão complicada quanto uma árvore DOM antes que ele possa fazer o trabalho.

Um exemplo

Declaração do problema : escreva um programa Java para extrair todas as informações sobre círculos que são elementos em um determinado documento XML. Supomos que cada elemento do círculo tenha três elementos filhos (ou seja, x, ye raio), além de um atributo de cor. Um documento de amostra é fornecido abaixo:

<?xml version="1.0"?> 
<!DOCTYPE shapes [
<!ELEMENT shapes (circle)*>
<!ELEMENT circle (x,y,radius)>
<!ELEMENT x (#PCDATA)>
<!ELEMENT y (#PCDATA)>
<!ELEMENT radius (#PCDATA)>
<!ATTLIST circle color CDATA #IMPLIED>
]>

<shapes> 
          <circle color="BLUE"> 
                <x>20</x>
                <y>20</y>
                <radius>20</radius> 
          </circle>
          <circle color="RED" >
                <x>40</x>
                <y>40</y>
                <radius>20</radius> 
          </circle>
</shapes> 

Programa com DOMparser

import java.io.*;
import org.w3c.dom.*;
import org.apache.xerces.parsers.DOMParser;


public class shapes_DOM {
   static int numberOfCircles = 0;   // total number of circles seen
   static int x[] = new int[1000];   // X-coordinates of the centers
   static int y[] = new int[1000];   // Y-coordinates of the centers  
   static int r[] = new int[1000];   // radius of the circle
   static String color[] = new String[1000];  // colors of the circles 

   public static void main(String[] args) {   

      try{
         // create a DOMParser
         DOMParser parser=new DOMParser();
         parser.parse(args[0]);

         // get the DOM Document object
         Document doc=parser.getDocument();

         // get all the circle nodes
         NodeList nodelist = doc.getElementsByTagName("circle");
         numberOfCircles =  nodelist.getLength();

         // retrieve all info about the circles
         for(int i=0; i<nodelist.getLength(); i++) {

            // get one circle node
            Node node = nodelist.item(i);

            // get the color attribute 
            NamedNodeMap attrs = node.getAttributes();
            if(attrs.getLength() > 0)
               color[i]=(String)attrs.getNamedItem("color").getNodeValue();

            // get the child nodes of a circle node 
            NodeList childnodelist = node.getChildNodes();

            // get the x and y value 
            for(int j=0; j<childnodelist.getLength(); j++) {
               Node childnode = childnodelist.item(j);
               Node textnode = childnode.getFirstChild();//the only text node
               String childnodename=childnode.getNodeName(); 
               if(childnodename.equals("x")) 
                  x[i]= Integer.parseInt(textnode.getNodeValue().trim());
               else if(childnodename.equals("y")) 
                  y[i]= Integer.parseInt(textnode.getNodeValue().trim());
               else if(childnodename.equals("radius")) 
                  r[i]= Integer.parseInt(textnode.getNodeValue().trim());
            }

         }

         // print the result
         System.out.println("circles="+numberOfCircles);
         for(int i=0;i<numberOfCircles;i++) {
             String line="";
             line=line+"(x="+x[i]+",y="+y[i]+",r="+r[i]+",color="+color[i]+")";
             System.out.println(line);
         }

      }  catch (Exception e) {e.printStackTrace(System.err);}

    }

}

Programa com SAXparser

import java.io.*;
import org.xml.sax.*;
import org.xml.sax.helpers.DefaultHandler;
import org.apache.xerces.parsers.SAXParser;


public class shapes_SAX extends DefaultHandler {

   static int numberOfCircles = 0;   // total number of circles seen
   static int x[] = new int[1000];   // X-coordinates of the centers
   static int y[] = new int[1000];   // Y-coordinates of the centers
   static int r[] = new int[1000];   // radius of the circle
   static String color[] = new String[1000];  // colors of the circles

   static int flagX=0;    //to remember what element has occurred
   static int flagY=0;    //to remember what element has occurred
   static int flagR=0;    //to remember what element has occurred

   // main method 
   public static void main(String[] args) {   
      try{
         shapes_SAX SAXHandler = new shapes_SAX (); // an instance of this class
         SAXParser parser=new SAXParser();          // create a SAXParser object 
         parser.setContentHandler(SAXHandler);      // register with the ContentHandler 
         parser.parse(args[0]);
      }  catch (Exception e) {e.printStackTrace(System.err);}  // catch exeptions
   }

   // override the startElement() method
   public void startElement(String uri, String localName, 
                       String rawName, Attributes attributes) {
         if(rawName.equals("circle"))                      // if a circle element is seen
            color[numberOfCircles]=attributes.getValue("color");  // get the color attribute 

         else if(rawName.equals("x"))      // if a x element is seen set the flag as 1 
            flagX=1;
         else if(rawName.equals("y"))      // if a y element is seen set the flag as 2
            flagY=1;
         else if(rawName.equals("radius")) // if a radius element is seen set the flag as 3 
            flagR=1;
   }

   // override the endElement() method
   public void endElement(String uri, String localName, String rawName) {
         // in this example we do not need to do anything else here
         if(rawName.equals("circle"))                       // if a circle element is ended 
            numberOfCircles +=  1;                          // increment the counter 
   }

   // override the characters() method
   public void characters(char characters[], int start, int length) {
         String characterData = 
             (new String(characters,start,length)).trim(); // get the text

         if(flagX==1) {        // indicate this text is for <x> element 
             x[numberOfCircles] = Integer.parseInt(characterData);
             flagX=0;
         }
         else if(flagY==1) {  // indicate this text is for <y> element 
             y[numberOfCircles] = Integer.parseInt(characterData);
             flagY=0;
         }
         else if(flagR==1) {  // indicate this text is for <radius> element 
             r[numberOfCircles] = Integer.parseInt(characterData);
             flagR=0;
         }
   }

   // override the endDocument() method
   public void endDocument() {
         // when the end of document is seen, just print the circle info 
         System.out.println("circles="+numberOfCircles);
         for(int i=0;i<numberOfCircles;i++) {
             String line="";
             line=line+"(x="+x[i]+",y="+y[i]+",r="+r[i]+",color="+color[i]+")";
             System.out.println(line);
         }
   }


}

Na prática: book.xml

<bookstore>
  <book category="cooking">
    <title lang="en">Everyday Italian</title>
    <author>Giada De Laurentiis</author>
    <year>2005</year>
    <price>30.00</price>
  </book>
</bookstore>

• O DOM apresenta o documento xml como a seguinte estrutura em árvore na memória.
• DOM é o padrão W3C.
• O analisador DOM funciona no modelo de objeto de documento.
• O DOM ocupa mais memória, preferível para pequenos documentos XML
• O DOM é fácil de navegar para frente ou para trás.

• SAX apresenta o documento XML como evento base como start element:abc, end element:abc.
• O SAX não é o padrão W3C, foi desenvolvido por um grupo de desenvolvedores.
• O SAX não usa memória, preferível para documentos XML grandes.
• A navegação para trás não é possível, pois processa os documentos sequencialmente.
• O evento acontece com um nó / elemento e fornece todos os subnós (nodus latino, 'nó').

Este documento XML, quando passado por um analisador SAX, gerará uma sequência de eventos como o seguinte :

start element: bookstore
start element: book with an attribute category equal to cooking
start element: title with an attribute lang equal to en
Text node, with data equal to Everyday Italian
....
end element: title
.....
end element: book
end element: bookstore

DOM Representa o Modelo de Objeto de Documento e representa um Documento XML no formato de árvore, em que cada elemento representa ramificações de árvore. O Analisador DOM cria uma representação da árvore Na Memória do arquivo XML e o analisa, portanto, requer mais memória e é aconselhável ter um tamanho de heap aumentado para o analisador DOM, a fim de evitar Java.lang.OutOfMemoryError: espaço de heap java. A análise de arquivo XML usando o analisador DOM é bastante rápida se o arquivo XML for pequeno, mas se você tentar ler um arquivo XML grande usando o analisador DOM, haverá mais chances de demorar muito ou até não conseguir carregá-lo completamente, simplesmente porque requer muita memória para criar XML Dom Tree. Java fornece suporte à análise DOM e você pode analisar arquivos XML em Java usando o analisador DOM. As classes DOM estão no pacote w3c.dom enquanto o Analisador DOM para Java está no pacote JAXP (Java API for XML Parsing).

Analisador XML SAX em Java

SAX significa API simples para análise de XML. É uma análise XML baseada em eventos e analisa arquivo XML passo a passo, muito adequado para arquivos XML grandes. O analisador XML do SAX aciona um evento quando ele encontra a tag, elemento ou atributo de abertura e a análise funciona de acordo. É recomendável usar o analisador XML SAX para analisar arquivos xml grandes em Java, porque não requer o carregamento de arquivos XML inteiros em Java e pode ler um arquivo XML grande em pequenas partes. O Java fornece suporte para o analisador SAX e você pode analisar qualquer arquivo xml em Java usando o SAX Parser. Cobri um exemplo de leitura de arquivo xml usando o SAX Parser aqui. Uma desvantagem do uso do SAX Parser em java é que a leitura do arquivo XML em Java usando o SAX Parser requer mais código em comparação com o DOM Parser.

Diferença entre DOM e SAX XML Parser

Aqui estão algumas diferenças de alto nível entre o analisador DOM e o analisador SAX em Java:

1) O analisador DOM carrega todo o documento xml na memória, enquanto o SAX carrega apenas uma pequena parte do arquivo XML na memória.

2) O analisador DOM é mais rápido que o SAX, pois acessa todo o documento XML na memória.

3) O analisador SAX em Java é mais adequado para arquivos XML grandes do que o DOM Parser, porque não requer muita memória.

4) O analisador DOM funciona no Document Object Model, enquanto o SAX é um analisador xml baseado em eventos.

Leia mais: http://javarevisited.blogspot.com/2011/12/difference-between-dom-and-sax-parsers.html#ixzz2uz1bJQqZ

SAX e DOM são usados ​​para analisar o documento XML. Ambos têm vantagens e desvantagens e podem ser usados ​​em nossa programação, dependendo da situação

SAXOFONE:

1. Analisa nó por nó

2. Não armazena o XML na memória

3. Não podemos inserir ou excluir um nó

4. Travessia de cima para baixo

DOM

1. Armazena o documento XML inteiro na memória antes de processar

2. Ocupa mais memória

3. Podemos inserir ou excluir nós

4. Atravesse em qualquer direção.

Se precisarmos encontrar um nó e não precisarmos inserir ou excluir, podemos usar o próprio SAX, caso contrário, o DOM, desde que tenhamos mais memória.

1) O analisador DOM carrega todo o documento XML na memória enquanto o SAX carrega apenas uma pequena parte do arquivo XML na memória.

2) O analisador DOM é mais rápido que o SAX, pois acessa todo o documento XML na memória.

3) O analisador SAX em Java é mais adequado para arquivos XML grandes do que o DOM Parser, porque não requer muita memória.

4) O analisador DOM funciona no Document Object Model, enquanto o SAX é um analisador XML baseado em eventos.

Leia mais: http://javarevisited.blogspot.com/2011/12/difference-between-dom-and-sax-parsers.html#ixzz498y3vPFR