How to Parse XML to HashMap in Java

1. Introduction

XML is one of the popular formats for data interchange over the internet. When working with XML data, it’s common to convert it into a more usable format for further processing.

In this tutorial, we’ll explore the different ways to parse XML into a HashMap, a data structure that allows for efficient data retrieval and manipulation.

2. Setup

We’ll parse the following XML into a HashMap using different libraries:

<employees>
    <employee>
        <id>654</id>
        <firstName>John</firstName>
        <lastName>Doe</lastName>
    </employee>
    <employee>
        <id>776</id>
        <firstName>Steve</firstName>
        <lastName>Smith</lastName>
    </employee>
</employees>

Let’s use the below POJO to store the XML data:

public class Employee {
    private String id;
    private String firstName;
    private String lastName;

    // standard getters and setters
}

We’ll set up our common test method to validate our results for all the cases:

void verify(Map<String, Employee> employeeMap) {
    Employee employee1 = employeeMap.get("654");
    Employee employee2 = employeeMap.get("776");
    Assertions.assertEquals("John", employee1.getFirstName());
    Assertions.assertEquals("Doe", employee1.getLastName());
    Assertions.assertEquals("Steve", employee2.getFirstName());
    Assertions.assertEquals("Smith", employee2.getLastName());
}

3. Parse XML Using XStream

XStream is a third-party library to serialize and deserialize objects to and from XML. With minimal configuration, XStream provides us with the ability to parse XML data.

We’ll use the below Maven dependency:

<dependency>
    <groupId>com.thoughtworks.xstream</groupId>
    <artifactId>xstream</artifactId>
    <version>1.4.18</version>
</dependency>

We’ll create a new instance of XStream and set up some aliases:

XStream xStream=new XStream(); 
xStream.alias("employees", List.class); 
xStream.alias("employee", Employee.class);

We set an alias for the employees element in the XML to be interpreted as a List. We also set an alias for the employee element to be interpreted as an Employee object.

We’ll add permission to allow any type to be unmarshaled, which is required by XStream for deserializing XML into a list of objects:

xStream.addPermission(AnyTypePermission.ANY);

Let’s parse the XML string into a list of Employee objects using XStream’s fromXML() method:

List<Employee> employees = (List<Employee>) xStream.fromXML(xml);

We then convert the list of employees into a Map, using the id as the key and the employee object itself as the value, using streams:

employees.stream().collect(Collectors.toMap(Employee::getId, Function.identity()))

4. Parse XML Using Underscore-java

Underscore-java is a utility library providing a wide range of functional programming and data manipulation functions. It requires Java 11 or higher.

We’ll use the below Maven dependency:

<dependency>
    <groupId>com.github.javadev</groupId>
    <artifactId>underscore</artifactId>
    <version>1.89</version>
</dependency>

Let’s use Underscore-java’s fromXmlMap() function to parse the XML string and convert it into a nested map structure:

Map<String, Object> employeeList = (Map<String, Object>)U.fromXmlMap(xml).get("employees"); 
List<LinkedHashMap<String, String>> list=(List<LinkedHashMap<String,String>>)employeeList.get("employee"); 
parseXmlToMap(employeeMap, list);

We extract the employees element from the resulting map. We then convert the resulting LinkedHashMap to a HashMap:

void parseXmlToMap(Map<String, Employee> employeeMap, List<LinkedHashMap<String, String>> list) {
    list.forEach(empMap -> {
        Employee employee = new Employee();
        for (Map.Entry<String, String> key : empMap.entrySet()) {
            switch (key.getKey()) {
            case "id":
                employee.setId(key.getValue());
                break;
            case "firstName":
                employee.setFirstName(key.getValue());
                break;
            case "lastName":
                employee.setLastName(key.getValue());
                break;
            default:
                break;
            }
        }
        employeeMap.put(employee.getId(), employee);
    });
}

Once we have our nested map structure we iterate over each LinkedHashMap in the list, representing an individual employee’s data. We then create a new Employee object and populate its fields based on the data in the map.

5. Parse XML Using Jackson

Jackson is a Java library that seamlessly maps XML elements and attributes to Java objects using annotations or customizable configuration.

We’ll use the following Maven dependencies:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
</dependency>

XmlMapper is a specialized mapper for XML data, which allows us to read and write XML:

XmlMapper xmlMapper = new XmlMapper();
Map<String, Object> map= xmlMapper.readValue(xml, Map.class);

We read the XML data and convert it into a map of key-value pairs. Jackson dynamically parses the XML and builds the corresponding map structure. We extract the list of employee elements from the map:

List<LinkedHashMap<String, String>> list= (List<LinkedHashMap<String, String>>) map.get("employee");

We can then use the same parseXmlToMap() method defined earlier to extract a map of employees.

6. Parse XML Using JAXB

JAXB is the Java Architecture for XML binding and it supports a binding framework that maps XML elements and attributes to Java using annotations.

We’ll use the following Maven dependency:

<dependency>
    <groupId>com.sun.xml.bind</groupId>
    <artifactId>jaxb-impl</artifactId>
    <version>2.3.3</version>
</dependency>

Let’s set up the Employees class with the following annotations to help bind it to the Java object:

@XmlRootElement(name = "employees")
public class Employees {

    private List<Employee> employeeList;

    @XmlElement(name = "employee")
    public List<Employee> getEmployeeList() {
        return employeeList;
    }
    // standard setter
}

Let’s create a JAXBContext which is used to manage the binding between XML data and Java objects:

JAXBContext context = JAXBContext.newInstance(Employees.class); 
Unmarshaller unmarshaller = context.createUnmarshaller(); 
Employees employees = (Employees) unmarshaller.unmarshal(new StringReader(xmlData));

The Unmarshaller is responsible for converting XML data into objects based on the mapping defined by JAXB annotations in the classes.

We convert the list of employees into a Map, using the id as the key and the employee object itself as the value, using Java Streams as done in the earlier section.

7. Parse XML Using DOM Parser and XPath

DOM Parser is a way to parse XML without any third-party libraries. DOM Parser supports XPath for navigating through XML and extracting data.

Let’s create a factory for producing DOM parsers, which will be used to parse the XML document:

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); 
DocumentBuilder builder = factory.newDocumentBuilder(); 
Document doc = builder.parse(new InputSource(new StringReader(xmlData)));

We parse the XML data into a Document object using the builder responsible for building the DOM representation of the XML.

We’ll then set up an XPath instance to query the DOM:

XPathFactory xPathfactory = XPathFactory.newInstance(); 
XPath xpath = xPathfactory.newXPath(); 
XPathExpression xPathExpr = xpath.compile("/employees/employee");

We configure an XPath instance that compiles an XPath expression that selects all employee elements within the employees element in the XML document.

Let’s evaluate the XPath expression on doc to retrieve a NodeList containing all matched employee elements:

NodeList nodes = (NodeList) xPathExpr.evaluate(doc, XPathConstants.NODESET);

We iterate over the NodeList and extract the employee elements into a HashMap:

for (int i = 0; i < nodes.getLength(); i++) {
    Element node = (Element) nodes.item(i);
    Employee employee = new Employee();
    employee.setId(node.getElementsByTagName("id").item(0).getTextContent());
    employee.setFirstName(node.getElementsByTagName("firstName").item(0).getTextContent());
    employee.setLastName(node.getElementsByTagName("lastName").item(0).getTextContent());
    map.put(employee.getId(), employee);
}

8. Conclusion

In this article, we explored the diverse methods of parsing XML into HashMap, a fundamental data structure for storing key-value pairs.

XStream and Underscore, with their minimal configuration, are ideal for straightforward XML parsing.

Jackson seamlessly maps XML elements to Java objects, offering flexibility and ease of use.

JAXB, with its annotations, excels in scenarios demanding a standardized mapping approach.

Meanwhile, DOM parsing with XPath provides fine-grained control over XML elements.