Cómo eliminar pares clave-valor de un archivo JSON en java

Dec 03 2020

Me preguntaba si alguien puede ayudarme o indicarme cómo editar el archivo JSON ficticio adjunto en Java.

Como puede ver, tengo un objeto principal que contiene muchos valores e hijos que siguen el mismo patrón.

Quería saber si había una forma de eliminar todas las claves cuyo valor es -1.

Lo siguiente es lo que estaba probando basado en muchos sitios web que usan jackson:

try {
            // create object mapper instance
            ObjectMapper mapper = new ObjectMapper();

            // convert JSON file to map
            Map<?, ?> map = mapper.readValue(Paths.get("test.json").toFile(), Map.class);

            // print map entries
            for (Map.Entry<?, ?> entry : map.entrySet()) {
                isInteger = main.isObjectInteger(entry.getValue());

                
//              System.out.println("if value is all: " + entry.getKey() + "=" + entry.getValue());
//

El código anterior mostrará la estructura del archivo, sin embargo, mi problema es alcanzar los valores -1 dentro de los niños y eliminarlos.

Usando los métodos .getClass y .simpleName, sé que es una lista de matrices, pero estoy confundido sobre cómo buscar a través de ella.

¡Cualquier ayuda será apreciada!

Respuestas

1 MichałZiober Dec 04 2020 at 00:49

En Jacksonpuede leer la JSONcarga útil completa JsonNodee iterar sobre todas las propiedades, verifique la condición dada. En caso de que se cumpla la condición, puede eliminar el campo dado. Para hacer eso, necesita implementar un método recursivo . Eche un vistazo al siguiente ejemplo:

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;

import java.io.File;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map;
import java.util.Objects;
import java.util.function.Predicate;

public class JsonRemoveSomeFieldsApp {

    public static void main(String[] args) throws IOException {
        File jsonFile = new File("./resource/test.json").getAbsoluteFile();

        ObjectMapper mapper = new ObjectMapper();
        mapper.enable(SerializationFeature.INDENT_OUTPUT);
        JsonNode root = mapper.readTree(jsonFile);

        JsonCleaner jsonCleaner = new JsonCleaner(root, (node) -> node.isNumber() && node.numberValue().intValue() == -1);
        JsonNode result = jsonCleaner.removeAll();

        // write to file
        mapper.writeValue(System.out, result);
    }
}

class JsonCleaner {

    private final JsonNode root;
    private final Predicate<JsonNode> toRemoveCondition;

    JsonCleaner(JsonNode node, Predicate<JsonNode> toRemoveCondition) {
        this.root = Objects.requireNonNull(node);
        this.toRemoveCondition = Objects.requireNonNull(toRemoveCondition);
    }

    public JsonNode removeAll() {
        process(root);
        return root;
    }

    private void process(JsonNode node) {
        if (node.isObject()) {
            ObjectNode object = (ObjectNode) node;
            Iterator<Map.Entry<String, JsonNode>> fields = object.fields();
            while (fields.hasNext()) {
                Map.Entry<String, JsonNode> field = fields.next();
                JsonNode valueToCheck = field.getValue();
                if (valueToCheck.isContainerNode()) {
                    process(valueToCheck);
                } else if (toRemoveCondition.test(valueToCheck)) {
                    fields.remove();
                }
            }
        } else if (node.isArray()) {
            ArrayNode array = (ArrayNode) node;
            array.elements().forEachRemaining(this::process);
        }
    }
}

Por debajo de la JSONcarga útil:

{
  "name": "Head",
  "missed": -1,
  "covered": -1,
  "children": [
    {
      "name": "project1",
      "missed": -1,
      "covered": -1,
      "children": [
        {
          "name": "project1",
          "missed": 10,
          "covered": 11
        }
      ]
    },
    {
      "name": "project1",
      "missed": -1,
      "covered": 12,
      "children": [
        {
          "name": "project1",
          "missed": 10,
          "covered": -1
        }
      ]
    }
  ]
}

imprime el código anterior:

{
  "name" : "Head",
  "children" : [ {
    "name" : "project1",
    "children" : [ {
      "name" : "project1",
      "missed" : 10,
      "covered" : 11
    } ]
  }, {
    "name" : "project1",
    "covered" : 12,
    "children" : [ {
      "name" : "project1",
      "missed" : 10
    } ]
  } ]
}

Ver también:

Aplanar una cadena JSON anidada de 3 niveles en java

2 AnatolyG Dec 03 2020 at 11:09

Hay dos técnicas principales para analizar y generar datos JSON (así como muchos otros formatos como XML, etc.): mapeo de objetos y procesamiento orientado a eventos / token / flujo. La segunda forma es la mejor para muchos casos, incluido el filtrado. Accesorios:

no es necesario cargar el archivo / datos por completo en la memoria, puede procesar megas / conciertos sin problemas
Funciona mucho más rápido, especialmente para archivos grandes.
es fácil implementar cualquier tipo / regla de transformación personalizada con este patrón

Tanto Gson como Jackson admiten el procesamiento orientado a la transmisión. Para ilustrar la idea, aquí hay solo un ejemplo usando un pequeño analizador / generadorhttps://github.com/anatolygudkov/green-jelly