Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

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.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW