Comment supprimer des paires clé / valeur d'un fichier JSON en Java

Dec 03 2020

Je me demandais si quelqu'un pouvait m'aider ou m'indiquer comment modifier le fichier JSON factice joint en Java.

Comme vous pouvez le voir, j'ai un objet head qui contient de nombreuses valeurs et des enfants qui suivent le même modèle.

Je voulais savoir s'il y avait un moyen de supprimer toutes les clés dont la valeur est -1.

Voici ce que j'essayais sur la base de nombreux sites Web utilisant 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());
//

Le code ci-dessus affichera la structure du fichier, mais mon problème est d'atteindre les valeurs -1 à l'intérieur des enfants et de les supprimer.

En utilisant les méthodes .getClass et .simpleName, je sais qu'il s'agit d'un arrayList mais je ne sais pas comment le rechercher.

Toute aide est la bienvenue!

Réponses

1 MichałZiober Dec 04 2020 at 00:49

Dans Jacksonvous pouvez lire la JSONcharge utile entière JsonNodeet itérer sur toutes les propriétés vérifier la condition donnée. Si la condition est remplie, vous pouvez supprimer un champ donné. Pour ce faire, vous devez implémenter une méthode récursive . Jetez un œil à l'exemple ci-dessous:

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);
        }
    }
}

Pour la JSONcharge utile ci-dessous :

{
  "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
        }
      ]
    }
  ]
}

le code ci-dessus imprime:

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

Voir également:

Aplatir une chaîne JSON imbriquée à 3 niveaux en Java

2 AnatolyG Dec 03 2020 at 11:09

Il existe deux techniques principales pour analyser et générer des données JSON (ainsi que de nombreux autres formats comme XML, etc.): le mappage d'objets et le traitement orienté événement / jeton / flux. La deuxième méthode est la meilleure pour de nombreux cas, y compris le filtrage. Accessoires:

le fichier / les données ne nécessitent pas d'être entièrement chargés en mémoire, vous pouvez traiter des mégas / concerts sans problème
cela fonctionne beaucoup plus rapidement, en particulier pour les gros fichiers
il est facile d'implémenter n'importe quel type / règle de transformation personnalisé avec ce modèle

Gson et Jackson prennent tous deux en charge le traitement orienté flux. Pour illustrer l'idée, voici juste un exemple utilisant un petit analyseur / générateurhttps://github.com/anatolygudkov/green-jelly