Como ler e escrever arquivos xml?

A resposta acima só lidar com Dom parser (que normalmente lê o arquivo inteiro na memória e analisá-lo, o que para um arquivo grande é um problema), você poderia usar um analisador SAX que usa menos memória e é mais rápido (de qualquer forma, isso depende do seu código).

O analisador SAX responde a algumas funções quando encontra um início de elemento, fim de elemento, atributo, texto entre elementos, etc, para que possa processar o documento e ao mesmo tempo você vai buscar o que precisas.

Algum exemplo código:

Http://www.mkyong.com/java/how-to-read-xml-file-in-java-sax-parser/

A escrever XML usando o JAXB (Arquitectura Java para a ligação XML):

Http://www.mkyong.com/java/jaxb-hello-world-example/

package com.mkyong.core;

import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
public class Customer {

    String name;
    int age;
    int id;

    public String getName() {
        return name;
    }

    @XmlElement
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    @XmlElement
    public void setAge(int age) {
        this.age = age;
    }

    public int getId() {
        return id;
    }

    @XmlAttribute
    public void setId(int id) {
        this.id = id;
    }

} 

package com.mkyong.core;

import java.io.File;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;

public class JAXBExample {
    public static void main(String[] args) {

      Customer customer = new Customer();
      customer.setId(100);
      customer.setName("mkyong");
      customer.setAge(29);

      try {

        File file = new File("C:\\file.xml");
        JAXBContext jaxbContext = JAXBContext.newInstance(Customer.class);
        Marshaller jaxbMarshaller = jaxbContext.createMarshaller();

        // output pretty printed
        jaxbMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

        jaxbMarshaller.marshal(customer, file);
        jaxbMarshaller.marshal(customer, System.out);

          } catch (JAXBException e) {
        e.printStackTrace();
          }

    }
}

As respostas só cobrem DOM / SAX e uma implementação de pasta de cópia de um exemplo JAXB.

No entanto, falta uma grande área de quando está a usar o XML. Em muitos projetos / programas há uma necessidade de armazenar / recuperar algumas estruturas básicas de dados. O seu programa já tem classes para os seus objectos de Negócio / estruturas de dados bonitos e brilhantes, só quer uma forma confortável de converter estes dados para uma estrutura XML para que possa fazer mais magia sobre eles (armazenar, carregar, enviar, manipular com XSLT).

Internamente o XStream usa a reflexão, o readObject e os métodos de readresolve da serialização padrão de objetos Java.

Para dar uma breve visão geral de como funciona, eu também fornecer algum código de exemplo que marshalls e unmarshalls uma estrutura de dados. A marshalling / desmarshalling acontece tudo no método main, o resto é apenas código para gerar alguns objetos de teste e preencher alguns dados para eles. É super simples de configurar a instância xStream e marshalling / unmarshalling é feito com uma linha de Código cada.

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

import com.thoughtworks.xstream.XStream;

public class XStreamIsGreat {

  public static void main(String[] args) {
    XStream xStream = new XStream();
    xStream.alias("good", Good.class);
    xStream.alias("pRoDuCeR", Producer.class);
    xStream.alias("customer", Customer.class);

    Producer a = new Producer("Apple");
    Producer s = new Producer("Samsung");
    Customer c = new Customer("Someone").add(new Good("S4", 10, new BigDecimal(600), s))
        .add(new Good("S4 mini", 5, new BigDecimal(450), s)).add(new Good("I5S", 3, new BigDecimal(875), a));
    String xml = xStream.toXML(c); // objects -> xml
    System.out.println("Marshalled:\n" + xml);
    Customer unmarshalledCustomer = (Customer)xStream.fromXML(xml); // xml -> objects
  }

  static class Good {
    Producer producer;

    String name;

    int quantity;

    BigDecimal price;

    Good(String name, int quantity, BigDecimal price, Producer p) {
      this.producer = p;
      this.name = name;
      this.quantity = quantity;
      this.price = price;
    }

  }

  static class Producer {
    String name;

    public Producer(String name) {
      this.name = name;
    }
  }

  static class Customer {
    String name;

    public Customer(String name) {
      this.name = name;
    }

    List<Good> stock = new ArrayList<Good>();

    Customer add(Good g) {
      stock.add(g);
      return this;
    }
  }
}

Ok, já tendo DOM, JaxB e XStream na lista de respostas, há ainda uma forma completamente diferente de ler e escrever XML: projecção de Dados Você pode dissociar a estrutura XML e Java estrutura por meio de uma biblioteca que fornece leitura e escrita vistas para os Dados XML como interfaces de Java. Dos tutoriais:

Dado algum XML do mundo real:

<weatherdata>
  <weather
    ... 
    degreetype="F"
    lat="50.5520210266113" lon="6.24060010910034" 
    searchlocation="Monschau, Stadt Aachen, NW, Germany" 
            ... >
    <current ... skytext="Clear" temperature="46"/>
  </weather>
</weatherdata>

Com a projecção de dados pode definir uma interface de projecção:

public interface WeatherData {

@XBRead("/weatherdata/weather/@searchlocation")   
String getLocation();

@XBRead("/weatherdata/weather/current/@temperature")
int getTemperature();

@XBRead("/weatherdata/weather/@degreetype")
String getDegreeType();

@XBRead("/weatherdata/weather/current/@skytext")
String getSkytext();

/**
 * This would be our "sub projection". A structure grouping two attribute
 * values in one object.
 */
interface Coordinates {
    @XBRead("@lon")
    double getLongitude();

    @XBRead("@lat")
    double getLatitude();
}

@XBRead("/weatherdata/weather")
Coordinates getCoordinates();
}

E utilizar instâncias desta interface tal como POJOs:

private void printWeatherData(String location) throws IOException {

final String BaseURL = "http://weather.service.msn.com/find.aspx?outputview=search&weasearchstr=";

// We let the projector fetch the data for us
WeatherData weatherData = new XBProjector().io().url(BaseURL + location).read(WeatherData.class);

// Print some values
System.out.println("The weather in " + weatherData.getLocation() + ":");
System.out.println(weatherData.getSkytext());
System.out.println("Temperature: " + weatherData.getTemperature() + "°"
                                   + weatherData.getDegreeType());

// Access our sub projection
Coordinates coordinates = weatherData.getCoordinates();
System.out.println("The place is located at " + coordinates.getLatitude() + ","
                                              + coordinates.getLongitude());
}

Isto funciona mesmo para criar XML, as expressões XPath podem ser escritas.

SAX o analisador está a trabalhar de forma diferente com um analisador DOM, não carrega nenhum documento XML na memória nem cria qualquer representação de objectos do documento XML. Em vez disso, o analisador SAX usa a função callback org.xml.sax.helpers.DefaultHandler para informar os clientes sobre a estrutura do documento XML.

SAX O analisador é mais rápido e usa menos memória que o analisador DOM. Ver os seguintes métodos de callback SAX:

startDocument() and endDocument() – Method called at the start and end of an XML document. startElement() e endElement() - método chamado no início e no fim de um elemento de Documento. characters() - método chamado com o conteúdo do texto entre as marcas iniciais e finais de um elemento de documento XML.

1. ficheiro XML

Crie um ficheiro XML simples.

<?xml version="1.0"?>
<company>
    <staff>
        <firstname>yong</firstname>
        <lastname>mook kim</lastname>
        <nickname>mkyong</nickname>
        <salary>100000</salary>
    </staff>
    <staff>
        <firstname>low</firstname>
        <lastname>yin fong</lastname>
        <nickname>fong fong</nickname>
        <salary>200000</salary>
    </staff>
</company>

1. analisador XML:

O ficheiro Java usa o analisador SAX para processar o ficheiro XML.

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class ReadXMLFile {
    public static void main(String argv[]) {

        try {
            SAXParserFactory factory = SAXParserFactory.newInstance();
            SAXParser saxParser = factory.newSAXParser();

            DefaultHandler handler = new DefaultHandler() {
                boolean bfname = false;
                boolean blname = false;
                boolean bnname = false;
                boolean bsalary = false;

                public void startElement(String uri, String localName,String qName, 
                            Attributes attributes) throws SAXException {

                    System.out.println("Start Element :" + qName);

                    if (qName.equalsIgnoreCase("FIRSTNAME")) {
                        bfname = true;
                    }

                    if (qName.equalsIgnoreCase("LASTNAME")) {
                        blname = true;
                    }

                    if (qName.equalsIgnoreCase("NICKNAME")) {
                        bnname = true;
                    }

                    if (qName.equalsIgnoreCase("SALARY")) {
                        bsalary = true;
                    }

                }

                public void endElement(String uri, String localName,
                    String qName) throws SAXException {

                    System.out.println("End Element :" + qName);

                }

                public void characters(char ch[], int start, int length) throws SAXException {

                    if (bfname) {
                        System.out.println("First Name : " + new String(ch, start, length));
                        bfname = false;
                    }

                    if (blname) {
                        System.out.println("Last Name : " + new String(ch, start, length));
                        blname = false;
                    }

                    if (bnname) {
                        System.out.println("Nick Name : " + new String(ch, start, length));
                        bnname = false;
                    }

                    if (bsalary) {
                        System.out.println("Salary : " + new String(ch, start, length));
                        bsalary = false;
                    }

                }

            };

            saxParser.parse("c:\\file.xml", handler);

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

    }

}

Elemento inicial: empresa
Elemento inicial: pessoal
Elemento inicial: nome próprio
nome : yong
Elemento final: nome próprio
Elemento inicial: lastname
Apelido: mook kim
Elemento final: lastname
Elemento inicial: alcunha
Nome do Nick: makyong
Elemento final: nickname
e assim por diante...

Fonte(MyKong) - http://www.mkyong.com/java/how-to-read-xml-file-in-java-sax-parser/