В чем разница между SAX и DOM?

Ответ 1

Хорошо, вы близки.

В SAX события запускаются, когда XML анализируется. Когда синтаксический анализатор анализирует XML и встречает запуск тега (например, <something>), он запускает событие tagStarted (фактическое название события может отличаться). Аналогично, когда конец тега встречается во время разбора (</something>), он запускает tagEnded. Использование анализатора SAX подразумевает, что вам необходимо обрабатывать эти события и понимать данные, возвращаемые с каждым событием.

В DOM во время разбора нет событий, инициированных. Весь XML анализируется и генерируется и возвращается дерево DOM (узлов в XML). После анализа пользователь может перемещаться по дереву для доступа к различным данным, ранее внедренным в различные узлы в XML.

В общем, DOM проще в использовании, но имеет накладные расходы на разбор всего XML, прежде чем вы сможете начать использовать его.

Ответ 2

Всего несколько слов...

SAX ( S imple A PI для X ML): Является потоковым процессором. У вас есть только небольшая часть в памяти в любое время, и вы "обнюхиваете" поток XML, реализуя код обратного вызова для таких событий, как tagStarted() и т.д. Он почти не использует память, но вы не можете делать вещи "DOM", например, использовать xpath или траверсы.

DOM ( D ocument O bject M odel): Вы загружаете все это в память - это массивный всплеск памяти. Вы можете взорвать память даже документами среднего размера. Но вы можете использовать xpath и перемещаться по дереву и т.д.

Ответ 3

Здесь в более простых словах:

DOM

• Парсер дерева моделей (на основе объекта) (Дерево узлов).

• DOM загружает файл в память и затем анализирует файл.

• Имеет ограничения памяти, так как он загружает весь XML файл перед разбором.

• DOM считывается и записывается (может вставлять или удалять узлы).

• Если содержимое XML невелико, то предпочитайте парсер DOM.

• Поиск назад и вперед возможен для поиска тегов и оценки информацию внутри тегов. Таким образом, это упрощает навигацию.

• Медленнее во время выполнения.

SAX

• Парсер, основанный на событиях (последовательность событий).

• SAX анализирует файл по мере его чтения, т.е. анализирует node на node.

• Нет ограничений памяти, так как он не хранит содержимое XML в памяти.

• SAX доступен только для чтения, т.е. не может вставить или удалить node.

• Используйте синтаксический анализатор SAX, когда объем содержимого большой.

• SAX читает XML файл сверху вниз, а обратная навигация невозможна.

• Быстрее во время выполнения.

Ответ 4

Вы правильно понимаете модель DOM. XML файл будет загружен как целое, и все его содержимое будет построено как представление в виде дерева в представлении документа. Это зависит от времени и памяти, в зависимости от размера входного файла. Преимущество этого подхода заключается в том, что вы можете легко запросить любую часть документа и свободно манипулировать всеми узлами в дереве.

Подход DOM обычно используется для небольших структур XML (где мало зависит от того, сколько лошадиных сил и памяти у вашей платформы), которые, возможно, потребуется изменить и запросить по-разному после их загрузки.

SAX, с другой стороны, предназначен для обработки XML-данных практически любого размера. Вместо того, чтобы XML-инфраструктура делает для вас трудную работу по выяснению структуры документа и подготовке потенциально большого количества объектов для всех узлов, атрибутов и т.д., SAX полностью оставляет это для вас.

В основном это означает чтение ввода сверху и вызов методов обратного вызова, которые вы предоставляете при возникновении определенных "событий". Событие может попасть в открывающий тег, атрибут в теге, найти текст внутри элемента или встретить конечный тег.

SAX упрямо читает ввод и сообщает вам, что он видит таким образом. Вы должны поддерживать всю необходимую информацию штата. Обычно это означает, что вы создадите какую-то государственную машину.

Хотя этот подход к обработке XML намного более утомительный, он может быть очень сильным. Представьте, что вы хотите просто извлечь заголовки новостей из фида блога. Если вы прочитаете этот XML, используя DOM, он загрузит все содержимое статьи, все изображения и т.д., Которые содержатся в XML в память, даже если вас это даже не интересует.

С помощью SAX вы можете просто проверить, называется ли имя элемента (например, "title" ) при вызове метода "startTag". Если это так, вы знаете, что вам нужно добавить все, что предлагает следующее событие "elementText". Когда вы получаете вызов события "endTag", вы снова проверяете, является ли это закрывающим элементом "title" . После этого вы просто игнорируете все остальные элементы, пока не закончится вход или не появится другой "startTag" с названием "title" . И так далее...

Вы можете читать через мегабайты и мегабайты XML таким образом, просто извлекая крошечный объем данных, который вам нужен.

Отрицательная сторона этого подхода, конечно же, вам нужно делать гораздо больше бухгалтерского учета, в зависимости от того, какие данные вам нужно извлечь и насколько сложна структура XML. Кроме того, вы, естественно, не можете изменить структуру дерева XML, потому что вы никогда не имеете ее в руке в целом.

Таким образом, SAX подходит для расчёта через потенциально большие объемы данных, которые вы получаете с определенным "запросом", но не нуждается в модификации, в то время как DOM больше нацелен на то, чтобы предоставить вам полную гибкость в изменении структуры и содержимого, за счет более высокой потребности в ресурсах.

Ответ 5

Вы сравниваете яблоки и груши. SAX - синтаксический анализатор, который анализирует сериализованные структуры DOM. Существует много разных парсеров, а "event-based" относится к методу синтаксического анализа.

Может быть, небольшая подсказка в порядке:

• Объектная модель документа (DOM) представляет собой абстрактную модель данных, которая описывает иерархическую структуру данных на основе дерева; дерево документов состоит из узлов, а именно элементов, атрибутов и текстовых узлов (и некоторых других). Узлы имеют родителей, братьев и сестер и детей и могут быть пройдены и т.д., Весь материал, из которого вы привыкли делать JavaScript (что, кстати, не имеет ничего общего с DOM).

• Структура DOM может быть сериализована, то есть записана в файл, используя язык разметки, такой как HTML или XML. Таким образом, HTML или XML файл содержит "выписанную" или "сплющенную" версию абстрактного дерева документов.

• Чтобы компьютер мог обрабатывать или даже отображать дерево DOM из файла, он должен десериализовать или проанализировать файл и восстановить абстрактное дерево в памяти. Здесь происходит синтаксический анализ.

Теперь мы приходим к природе парсеров. Один из способов анализа состоит в том, чтобы прочитать весь документ и рекурсивно создать древовидную структуру в памяти и, наконец, разоблачить весь результат для пользователя. (Я полагаю, вы могли бы назвать эти парсеры "DOM parsers".) Это было бы очень удобно для пользователя (я думаю, что делает PHP-парсер PHP), но он страдает от проблем с масштабируемостью и становится очень дорогостоящим для больших документов.

С другой стороны, синтаксический анализ, основанный на событиях, как это делает SAX, смотрит на файл линейно и просто выполняет обратные вызовы пользователю всякий раз, когда он сталкивается с структурной частью данных, например "этот элемент запущен", "тот элемент закончился", "текст здесь" и т.д. Это имеет то преимущество, что оно может продолжаться вечно без учета размера входного файла, но оно намного более низкоуровневое, поскольку оно требует от пользователя выполнения всех фактических операций обработки (путем предоставления обратных вызовов). Чтобы вернуться к исходному вопросу, термин "основанный на событиях" относится к тем событиям синтаксического анализа, которые синтаксический анализатор поднимает при прохождении XML файла.

Статья Википедии содержит много подробностей о этапах анализа SAX.

Ответ 6

Я предоставлю общий Q & A-ориентированный ответ для этого вопроса:

Ответ на вопросы

Зачем нужен XML-парсер?

Нам нужен XML-парсер, потому что мы не хотим делать все в нашем приложении с нуля, и нам нужны некоторые "вспомогательные" программы или библиотеки, чтобы сделать что-то очень низкоуровневое, но очень необходимое для нас. Эти низкоуровневые, но необходимые вещи включают проверку корректности, проверку документа против его DTD или схемы (только для проверки парсеров), разрешение ссылки на символы, понимание разделов CDATA и т.д. Парсеры XML - это просто такие "вспомогательные" программы, и они будут выполнять все эти задания. С синтаксическим анализатором XML мы защищены от множества этих сложностей, и мы можем сосредоточиться только на программировании на высоком уровне через API, реализованный анализаторами, и, таким образом, повысить эффективность программирования.

Какой из них лучше, SAX или DOM?

Оба анализатора SAX и DOM имеют свои преимущества и недостатки. Какой из них лучше должен зависеть от характеристик вашего приложения (см. Некоторые вопросы ниже).

Какой парсер может получить лучшую скорость, DOM или SAX-парсеры?

Анализатор SAX может получить более высокую скорость.

В чем разница между API на основе дерева и API на основе событий?

API на основе дерева сосредоточен вокруг древовидной структуры и, следовательно, предоставляет интерфейсы для компонентов дерева (который является документом DOM), таких как интерфейс документа, интерфейс Node, интерфейс NodeList, интерфейс Element, интерфейс Attr и т.д. на. Напротив, однако, API на основе событий предоставляет интерфейсы для обработчиков. Существует четыре интерфейса обработчика, интерфейс ContentHandler, интерфейс DTDHandler, интерфейс EntityResolver и интерфейс ErrorHandler.

В чем разница между DOM Parser и SAX Parser?

Анализаторы DOM и анализаторы SAX работают по-разному:

• Парсер DOM создает древовидную структуру в памяти из ввода документа, а затем ждет запросов от клиента. Но анализатор SAX не создает никакой внутренней структуры. Вместо этого требуется вхождения компонентов входного документа в качестве событий и сообщает клиент, что он читает, когда он читает входной документ. А

• Парсер DOM всегда обслуживает клиентское приложение со всем независимо от того, сколько на самом деле требуется клиенту. Но Парсер SAX обслуживает клиентское приложение всегда только с кусками документ в любой момент времени.

• С парсером DOM вызовы методов клиентское приложение должно быть явным и формировать своего рода цепочку. Но с SAX, некоторые определенные методы (обычно усредненные cient) будут вызывается автоматически (неявно) способом, который вызывается "обратный вызов", когда происходят определенные события. Эти методы не имеют которые будут называться клиентом явно, хотя мы могли бы назвать их в явном виде.

Как мы решаем, какой парсер хорош?

В идеале хороший парсер должен быть быстрым (эффективный по времени), экономичным по площади, богатым функциональностью и простым в использовании. Но на самом деле ни один из основных парсеров не обладает всеми этими функциями одновременно. Например, DOM Parser обладает богатой функциональностью (поскольку он создает дерево DOM в памяти и позволяет вам неоднократно обращаться к любой части документа и позволяет изменять дерево DOM), но это пространство неэффективно, когда документ огромен, и требуется немного времени, чтобы научиться работать с ним. Тем не менее, SAX Parser гораздо эффективнее пространства в случае большого входного документа (поскольку он не создает внутренней структуры). Что еще, он работает быстрее и легче учится, чем DOM Parser, потому что его API очень прост. Но с точки зрения функциональности она предоставляет меньше функций, что означает, что сами пользователи должны позаботиться о большем количестве, например, о создании собственных структур данных. Кстати, что такое хороший парсер? Я думаю, что ответ действительно зависит от характеристик вашего приложения.

Что такое приложения реального мира, где используется синтаксический анализатор SAX? выгоднее, чем использовать парсер DOM и наоборот? Каковы обычные приложение для анализатора DOM и анализатор SAX?

В следующих случаях использование анализатора SAX выгодно, чем использование парсера DOM.

• Входной документ слишком большой для доступной памяти (фактически в этом случае SAX - ваш единственный выбор)
• Вы можете обрабатывать документ в небольших смежных фрагментах ввода. Перед тем, как сделать полезную работу, вам не нужен весь документ.
• Вы просто хотите использовать парсер для извлечения интересующей информации, и все ваши вычисления будут полностью основаны на созданных вами структурах данных. Фактически в большинстве наших приложений мы создаем собственные структуры данных, которые обычно не так сложны, как дерево DOM. Из этого смысла, я думаю, вероятность использования парсера DOM меньше, чем использование синтаксического анализатора SAX.

В следующих случаях использование анализатора DOM выгодно, чем использование анализатора SAX.

• Ваше приложение должно одновременно получать доступ к отдельным частям документа.
• Возможно, ваше приложение может использовать внутреннюю структуру данных, которая почти так же сложна, как и сам документ.
• Ваше приложение должно несколько раз изменять документ.
• Ваше приложение должно хранить документ в течение значительного времени через многие вызовы методов.

Пример (используйте парсер DOM или парсер SAX?):

Предположим, что у инструктора есть XML-документ, содержащий всю личную информацию студентов, а также точки, которые его ученики сделали в своем классе, и теперь он назначает окончательные оценки для студентов, использующих приложение. То, что он хочет произвести, - это список с SSN и оценками. Также мы предполагаем, что в своем приложении инструктор не использует структуру данных, такую ​​как массивы для хранения личной информации ученика и точек. Если инструктор решает дать А тем, кто получил средний класс или выше, и дать B другим, тогда ему лучше использовать парсер DOM в своем заявлении. Причина в том, что он не имеет никакого способа узнать, насколько средний класс до обработки всего документа. То, что он, вероятно, должен делать в своем приложении, сначала просматривает все точки учеников и вычисляет среднее значение, а затем снова просматривает документ и присваивает окончательный класс каждому ученику, сравнивая полученные очки с средним классом, Если, однако, инструктор принимает такую ​​политику классификации, что ученикам, получившим 90 баллов или более, назначаются A, а другим назначаются B, то, вероятно, лучше использовать SAX-парсер. Причина заключается в том, чтобы присвоить каждому учащемуся окончательный класс, ему не нужно ждать, пока весь документ будет обработан. Он сразу же может назначить оценку для ученика, когда парсер SAX будет читать оценку этого ученика. В приведенном выше анализе мы предположили, что инструктор не создал собственную структуру данных. Что делать, если он создает свою собственную структуру данных, такую ​​как массив строк для хранения SSN и массив целых чисел для проверки точек? В этом случае, я думаю, SAX - лучший выбор, прежде чем это могло бы сэкономить как память, так и время, но выполнить свою работу. Ну, еще одно соображение на этом примере. Что делать, если инструктор хочет сделать это, а не распечатать список, но сохранить исходный документ с оценкой каждого ученика? В этом случае анализатор DOM должен быть лучшим выбором независимо от того, какую политику классификации он принимает. Ему не нужно создавать какую-либо структуру данных. Ему нужно сначала изменить дерево DOM (т.е. Установить значение в "класс" node), а затем сохранить все модифицированное дерево. Если он предпочитает использовать синтаксический анализатор SAX вместо DOM-анализатора, тогда в этом случае он должен создать структуру данных, которая почти такая же сложная, как дерево DOM, прежде чем он сможет выполнить свою работу.

Пример

Описание проблемы: напишите программу Java, чтобы извлечь все информация о кругах, которые являются элементами в данном XML-документе. Мы предполагаем, что каждый элемент окружности имеет три дочерних элемента (т.е. Х, у и радиус), а также атрибут цвета. Образец документа дается ниже:

<?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> 

Программа с 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);}

    }

}

Программа с 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);
         }
   }


}

Ответ 7

Практически: 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>

• DOM представляет XML-документ в виде следующей древовидной структуры в памяти.
• DOM - стандарт W3C.
• DOM-парсер работает с Document Object Model.
• DOM занимает больше памяти, предпочитается для небольших документов XML
• DOM легко перемещаться вперед или назад.

• SAX представляет XML-документ как основанное на событиях.
• SAX не является стандартом W3C, он был разработан группой разработчиков.
• SAX не использует память, предпочитаемую для больших XML-документов.
• Обратная обработка невозможна, поскольку она последовательно обрабатывает документы.

Этот XML-документ, переданный через синтаксический анализатор SAX, генерирует последовательность событий, подобных следующим:

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

Ответ 8

DOM Stands для Document Object Model и представляет собой XML-документ в виде дерева, каждый элемент которого представляет ветки дерева. DOM Parser создает древовидное представление XML файла в XML файле, а затем анализирует его, поэтому требуется больше памяти и желательно увеличить размер кучи для DOM-анализатора, чтобы избежать Java.lang.OutOfMemoryError: java heap space. Анализ XML файла с использованием DOM-парсера довольно быстр, если XML файл мал, но если вы попытаетесь прочитать большой XML файл, используя парсер DOM, есть еще много шансов, что это займет много времени или даже может быть не в состоянии загрузить его полностью, потому что для создания XML Dom Tree требуется много памяти. Java обеспечивает поддержку DOM Parsing, и вы можете анализировать XML файлы на Java с помощью DOM-парсера. Классы DOM находятся в пакете w3c.dom, а DOM Parser для Java - в пакете JAXP (Java API for XML Parsing).

SAX XML Parser в Java

SAX поддерживает простой API для анализа XML. Это XML-анализ, основанный на событиях, и он последовательно анализирует XML файл, который подходит для больших файлов XML. SAX XML Parser запускает событие, когда он сталкивается с открывающим тегом, элементом или атрибутом, и работает синтаксический анализ. Рекомендуется использовать парсер SAX XML для синтаксического анализа больших xml файлов на Java, потому что не требуется загружать весь XML файл в Java и он может читать большой XML файл небольшими частями. Java обеспечивает поддержку анализатора SAX, и вы можете анализировать любой XML файл на Java с помощью SAX Parser, я рассмотрел пример чтения xml файла с помощью SAX Parser. Одним из недостатков использования SAX Parser в java является то, что чтение XML файла на Java с использованием SAX Parser требует большего количества кода для сравнения DOM Parser.

Разница между DOM и XML XML Parser

Вот несколько отличий высокого уровня между парсером DOM и SAX Parser в Java:

1) Парсер DOM загружает весь XML-документ в память, в то время как SAX загружает небольшую часть файла XML в память.

2) Парсер DOM быстрее SAX, потому что он обращается ко всему XML-документу в памяти.

3) SAX-парсер в Java лучше подходит для большого XML файла, чем DOM Parser, потому что он не требует большой памяти.

4) Парсер DOM работает с Document Object Model, в то время как SAX - это XML-парсер, основанный на событиях.

Подробнее: http://javarevisited.blogspot.com/2011/12/difference-between-dom-and-sax-parsers.html#ixzz2uz1bJQqZ

Ответ 9

Оба SAX и DOM используются для анализа XML-документа. Оба имеют преимущества и недостатки и могут использоваться в нашем программировании в зависимости от ситуации.

SAX:

• Парсы node by node

• Не хранит XML в памяти

• Мы не можем вставлять или удалять node

• Перемещение сверху вниз

DOM

• Хранит весь XML-документ в памяти перед обработкой

• Занимает больше памяти

• Мы можем вставлять или удалять узлы

• Пройдите в любом направлении.

Если нам нужно найти node и не нужно вставлять или удалять, мы можем пойти с SAX, иначе DOM при условии, что у нас больше памяти.

Ответ 10

1) Парсер DOM загружает весь XML-документ в память, в то время как SAX загружает небольшую часть файла XML в память.

2) Парсер DOM быстрее SAX, потому что он обращается ко всему XML-документу в памяти.

3) SAX-парсер в Java лучше подходит для большого XML файла, чем DOM Parser, потому что он не требует большой памяти.

4) DOM-парсер работает с Document Object Model, в то время как SAX - это XML-парсер, основанный на событиях.

Подробнее: http://javarevisited.blogspot.com/2011/12/difference-between-dom-and-sax-parsers.html#ixzz498y3vPFR