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

The Jackson library is a powerful tool for working with JSON (JavaScript Object Notation) in Java applications. Additionally, it provides a wide range of features to read, write, and manipulate JSON data efficiently. Consequently, one common task when dealing with JSON is removing specific elements from the JSON structure.

In this tutorial, we’ll explore how to remove JSON elements using Jackson and understand the process through practical examples.

2. Setting up the Environment

To use Jackson, let’s first add the jackson-dataformat-xml dependency to our pom.xml file:

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

This library allows us to use the data binding API.

3. Removing JSON Elements by Key

When it comes to removing JSON, the simplest way to do that is by its key. Jackson provides several methods that facilitate this task. One of the commonly used approaches is with the JsonNode class, which represents a JSON node in the Jackson API.

To remove an element by key, we’d follow these steps:

  • Parse the JSON string or input stream using the Jackson ObjectMapper
  • Convert the JSON data into a JsonNode object
  • Use the remove(String fieldName) method on the JsonNode object to remove the desired element
  • Convert the modified JsonNode back into a JSON string usingObjectMapper

Let’s suppose we have the following JSON object:

{
    "name": "John",
    "age": 30,
    "city": "New York"
}

We’d like to remove the age property from this object. Below is the corresponding code snippet:

@Test
public void given_JsonData_whenUsingJackson_thenRemoveElementByKey() throws JsonProcessingException {
    String json = "{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}";
    ObjectMapper objectMapper = new ObjectMapper();
    JsonNode jsonNode = objectMapper.readTree(json);
    ObjectNode object = (ObjectNode) jsonNode;
    object.remove("age");
    String updatedJson = objectMapper.writeValueAsString(object);
    Assertions.assertEquals("{\"name\":\"John\",\"city\":\"New York\"}", updatedJson);
}

In the above test method, we remove the element with the key age from the JSON object and verify that the resulting JSON string doesn’t contain that element.

The expected and actual JSON output should be the same:

{
    "name": "John",
    "city": "New York"
}

4. Removing JSON Elements by Conditions

Sometimes, there are situations where we need to remove elements from a collection based on specific conditions. For instance, we might want to remove all elements with a particular value or of a particular type.

Luckily, Jackson offers multiple methods to achieve this objective. One approach involves using JsonNode, iterating through its elements, and removing elements that meet the given condition.

Let’s consider the given scenario where we have the following JSON object:

{
    "name": "John",
    "age": 30,
    "city": "New York"
}

We’d like to remove any element that is a number and has a value of 30 from this object. Let’s see how to do this:

@Test
public void given_JsonData_whenUsingJackson_thenRemoveElementsByCondition() throws JsonProcessingException {
    String json = "{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}";
    ObjectMapper objectMapper = new ObjectMapper();
    JsonNode jsonNode = objectMapper.readTree(json);
    Iterator<JsonNode> elements = jsonNode.elements();
    while (elements.hasNext()) {
        JsonNode element = elements.next();
        if (element.isNumber() && element.asInt() == 30) {
            elements.remove();
        }
    }
    String updatedJson = objectMapper.writeValueAsString(jsonNode);
    Assertions.assertEquals("{\"name\":\"John\",\"city\":\"New York\"}", updatedJson);
}

In the above example, we iterate through the elements of the JsonNode and remove any element that’s a number and has a value of 30. The resulting JSON string doesn’t contain the removed element.

The expected JSON output and the actual JSON output should be the same:

{
    "name": "John",
    "city": "New York"
}

5. Removing JSON Elements From Complex Structures

In some cases, we may encounter complex JSON structures that consist of nested objects or arrays. Handling these structures efficiently requires the ability to remove specific elements based on our requirements.

By using Jackson’s rich set of APIs, we can iterate over the elements of a JsonNode instance and perform conditional checks to identify elements for removal.

To remove elements from nested objects or arrays, we follow these steps:

  • Parse the JSON string or input stream usingObjectMapper
  • Traverse the JSON structure to reach the desired element using JsonNode methods like get(String fieldName) or path(String fieldName)
  • Use the appropriate removal method (remove(String fieldName), remove(int index), etc.) on the selected JsonNode
  • Convert the modified JsonNode back into a JSON string using the ObjectMapper

Let’s consider we’re dealing with a nested JSON object that has a complex structure:

{
    "name": "John",
    "details": {
        "age": 30,
        "city": "New York"
    }
}

We’d like to remove the element with the key age from the details nested object:

@Test
public void given_JsonData_whenUsingJackson_thenRemoveElementFromNestedStructure() throws JsonProcessingException {
    String json = "{\"name\": \"John\", \"details\": {\"age\": 30, \"city\": \"New York\"}}";
    ObjectMapper objectMapper = new ObjectMapper();
    JsonNode jsonNode = objectMapper.readTree(json);
    JsonNode detailsNode = jsonNode.path("details");
    ((ObjectNode) detailsNode).remove("age");
    String updatedJson = objectMapper.writeValueAsString(jsonNode);
    Assertions.assertEquals("{\"name\":\"John\",\"details\":{\"city\":\"New York\"}}", updatedJson);
}

In the above code, we access the nested object (details) and remove the element with the key (age). The resulting JSON string reflects the modified structure, and the expected JSON output should be the same as the actual JSON output:

{
    "name": "John",
    "details": {
        "city": "New York"
    }
}

6. Conclusion

In this article, we explored different techniques to remove JSON elements using the Jackson library in Java. We discussed removing elements by key, removing elements based on conditions, and removing elements from complex JSON structures.

Overall, by using the powerful features provided by Jackson, we can easily manipulate JSON data to meet our application’s requirements.

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