Describe the process of parsing an XML document using JAXP with an example in Java.

Parsing an XML document in Java can be efficiently accomplished using the Java API for XML Processing (JAXP). JAXP provides a standardized way to parse XML documents through various parsers, such as DOM and SAX. Here, I will describe the process using both the DOM (Document Object Model) and SAX (Simple API for XML) parsers, including a code example for each.

### 1. Parsing Using DOM Parser

The DOM parser reads the entire XML document into memory as a tree structure, allowing for easy navigation and manipulation.

**Example XML File (example.xml):**
```xml
<bookstore>
    <book>
        <title lang="en">Learning XML</title>
        <author>John Doe</author>
        <price>39.95</price>
    </book>
    <book>
        <title lang="es">Aprendiendo XML</title>
        <author>Jane Doe</author>
        <price>29.95</price>
    </book>
</bookstore>
```

**Java Code to Parse XML Using DOM:**
```java
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Element;
import java.io.File;

public class DOMParserExample {
    public static void main(String[] args) {
        try {
            // Create a DocumentBuilderFactory and DocumentBuilder
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();

            // Parse the XML file and create a Document object
            Document doc = builder.parse(new File("example.xml"));

            // Normalize the XML structure
            doc.getDocumentElement().normalize();

            // Get all book elements
            NodeList bookList = doc.getElementsByTagName("book");

            // Loop through the book elements and print details
            for (int i = 0; i < bookList.getLength(); i++) {
                Element book = (Element) bookList.item(i);
                System.out.println("Title: " + book.getElementsByTagName("title").item(0).getTextContent());
                System.out.println("Author: " + book.getElementsByTagName("author").item(0).getTextContent());
                System.out.println("Price: " + book.getElementsByTagName("price").item(0).getTextContent());
                System.out.println("---");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
```

### 2. Parsing Using SAX Parser

The SAX parser reads the XML document sequentially and triggers events for different parts of the document (start element, end element, characters, etc.). It does not load the entire document into memory, making it more memory efficient.

**Java Code to Parse XML Using SAX:**
```java
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import java.io.File;

public class SAXParserExample {
    public static void main(String[] args) {
        try {
            // Create a SAXParserFactory and SAXParser
            SAXParserFactory factory = SAXParserFactory.newInstance();
            SAXParser saxParser = factory.newSAXParser();

            // Define a handler for SAX parsing
            DefaultHandler handler = new DefaultHandler() {
                boolean bTitle = false;
                boolean bAuthor = false;
                boolean bPrice = false;

                @Override
                public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
                    if (qName.equalsIgnoreCase("title")) {
                        bTitle = true;
                    }
                    if (qName.equalsIgnoreCase("author")) {
                        bAuthor = true;
                    }
                    if (qName.equalsIgnoreCase("price")) {
                        bPrice = true;
                    }
                }

                @Override
                public void characters(char[] ch, int start, int length) throws SAXException {
                    if (bTitle) {
                        System.out.println("Title: " + new String(ch, start, length));
                        bTitle = false;
                    }
                    if (bAuthor) {
                        System.out.println("Author: " + new String(ch, start, length));
                        bAuthor = false;
                    }
                    if (bPrice) {
                        System.out.println("Price: " + new String(ch, start, length));
                        bPrice = false;
                    }
                }

                @Override
                public void endElement(String uri, String localName, String qName) {
                    // Not needed for this example
                }
            };

            // Parse the XML file
            saxParser.parse(new File("example.xml"), handler);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
```

### Summary

In summary, the DOM parser is useful for smaller XML files where random access is needed, while the SAX parser is more efficient for larger files where memory consumption is a concern. Each parser has its advantages, and the choice primarily depends on the use case. Both examples above demonstrate how to parse an XML document using these two methods in Java.