Java 迭代JSON并将列表数组添加到对象/数组中

我有两个

JSON

数组：

{ 
  "Person": {
    "Info": [
      "name": "Becky",
      "age": 14
    ]
   },
  "Fruits": [
    {
      "name": "avocado",
      "organic": true
    },
    {
      "name": "mango",
      "organic": true
    }
  ],
  "Vegetables": [
    {
      "name": "brocoli",
      "organic": true
    },
    {
      "name": "lettuce",
      "organic": true
    }
  ]
}

我想做的是使用

Jackson

和

Gson

库让一切看起来都很漂亮

像这样的。这适用于

Gson

。所以我想要的输出是：

{ 
  "Person": {
    "Info": [
      "name":"Becky",
      "age": 14
    ]
  },
  "FruitsList": {
    "Fruits": [
      {
        "name": "avocado",
        "organic": true
      },
      {
        "name": "mango",
        "organic": true
      }
    ]
  },
  "VegetablesList": {
    "Vegetables": [
      {
        "name": "brocoli",
        "organic": true
      },
      {
        "name": "lettuce",
        "organic": true
      }
    ]
  }
}

我已将我的课程设置为：

class Person{
   private List<Info> InfoList;
   //Set and get were set
}

class Info{
   private String name;
   private int age;
   //Set and get were set
}

class Fruits{
   private String name;
   private boolean organic;
   //Set and get were set
   public String toString(){
            return "Fruits:{" +
            "name:'" + name+ '\'' +
            ", organic:" + organic+'\''+
            '}';
   }
 }

 class Vegetables{
   private String name;
   private boolean;
   //Set and get were set
   public String toString(){
            return "Fruits:[" +
            "name:'" + name+ '\'' +
            ", organic:" + organic+'\''+
            ']';
   }
 }

class rootFinal{
    private List<Fruits> fruitList;
    private List<Vegetables> vegetablesList;
    private List<Person> personList;
    //Set and get were set
}

class mainJson{
   final InputStream fileData = ..("testPVF.json");

   ObjectMapper map = new Ob..();
   rootFinal root = map.readValue(fileData,rootFinal.class);
   // I can access each class with 
   System.out.printl(root.getHeaderList.get(0));
}

但这不是我想要的

我正在尝试对JSON文件进行迭代，或者如果有更好的方法检查数组是否存在。向其添加其他对象/数组

如果我找到

Veg

或

Fruit

我想以某种方式添加

VegList

和

FruitList

，如图所示。它应该忽略

“Person”：{}

，因为它位于

{}

符号中

---

有没有办法用

Gson

做到这一点

如果我理解正确，您希望使用

JSON对象

节点包装每个

JSON数组

节点。要做到这一点，您不需要使用

POJO

model，您可以将

JSON

负载读取为

ObjectNode

，并使用它的

API

来更新它

杰克逊 使用

Jackson

库的简单示例：

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

import java.io.File;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

public class JsonObjectApp {

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

        ObjectMapper mapper = new ObjectMapper();
        mapper.enable(SerializationFeature.INDENT_OUTPUT);

        ObjectNode root = (ObjectNode) mapper.readTree(jsonFile);

        Map<String, JsonNode> valuesToAdd = new LinkedHashMap<>();

        // create fields iterator
        Iterator<Map.Entry<String, JsonNode>> fieldsIterator = root.fields();
        while (fieldsIterator.hasNext()) {
            Map.Entry<String, JsonNode> entry = fieldsIterator.next();

            // if entry represents array
            if (entry.getValue().isArray()) {
                // create wrapper object
                ObjectNode arrayWrapper = mapper.getNodeFactory().objectNode();
                arrayWrapper.set(entry.getKey(), root.get(entry.getKey()));

                valuesToAdd.put(entry.getKey(), arrayWrapper);

                // remove it from object.
                fieldsIterator.remove();
            }
        }

        valuesToAdd.forEach((k, v) -> root.set(k + "List", v));

        System.out.println(mapper.writeValueAsString(root));
    }
}

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;

import java.io.File;
import java.io.FileReader;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

public class GsonApp {

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

        Gson gson = new GsonBuilder()
                .setPrettyPrinting()
                .create();

        try (FileReader reader = new FileReader(jsonFile)) {
            JsonObject root = gson.fromJson(reader, JsonObject.class);

            Map<String, JsonElement> valuesToAdd = new LinkedHashMap<>();

            // create fields iterator
            Iterator<Map.Entry<String, JsonElement>> fieldsIterator = root.entrySet().iterator();
            while (fieldsIterator.hasNext()) {
                Map.Entry<String, JsonElement> entry = fieldsIterator.next();
                // if entry represents array
                if (entry.getValue().isJsonArray()) {
                    // create wrapper object
                    JsonObject arrayWrapper = new JsonObject();
                    arrayWrapper.add(entry.getKey(), root.get(entry.getKey()));

                    valuesToAdd.put(entry.getKey(), arrayWrapper);

                    // remove it from object.
                    fieldsIterator.remove();
                }
            }

            valuesToAdd.forEach((k, v) -> root.add(k + "List", v));

            System.out.println(gson.toJson(root));
        }
    }
}

格森 我们可以通过

Gson

库实现非常类似的解决方案：

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

import java.io.File;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

public class JsonObjectApp {

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

        ObjectMapper mapper = new ObjectMapper();
        mapper.enable(SerializationFeature.INDENT_OUTPUT);

        ObjectNode root = (ObjectNode) mapper.readTree(jsonFile);

        Map<String, JsonNode> valuesToAdd = new LinkedHashMap<>();

        // create fields iterator
        Iterator<Map.Entry<String, JsonNode>> fieldsIterator = root.fields();
        while (fieldsIterator.hasNext()) {
            Map.Entry<String, JsonNode> entry = fieldsIterator.next();

            // if entry represents array
            if (entry.getValue().isArray()) {
                // create wrapper object
                ObjectNode arrayWrapper = mapper.getNodeFactory().objectNode();
                arrayWrapper.set(entry.getKey(), root.get(entry.getKey()));

                valuesToAdd.put(entry.getKey(), arrayWrapper);

                // remove it from object.
                fieldsIterator.remove();
            }
        }

        valuesToAdd.forEach((k, v) -> root.set(k + "List", v));

        System.out.println(mapper.writeValueAsString(root));
    }
}

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;

import java.io.File;
import java.io.FileReader;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

public class GsonApp {

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

        Gson gson = new GsonBuilder()
                .setPrettyPrinting()
                .create();

        try (FileReader reader = new FileReader(jsonFile)) {
            JsonObject root = gson.fromJson(reader, JsonObject.class);

            Map<String, JsonElement> valuesToAdd = new LinkedHashMap<>();

            // create fields iterator
            Iterator<Map.Entry<String, JsonElement>> fieldsIterator = root.entrySet().iterator();
            while (fieldsIterator.hasNext()) {
                Map.Entry<String, JsonElement> entry = fieldsIterator.next();
                // if entry represents array
                if (entry.getValue().isJsonArray()) {
                    // create wrapper object
                    JsonObject arrayWrapper = new JsonObject();
                    arrayWrapper.add(entry.getKey(), root.get(entry.getKey()));

                    valuesToAdd.put(entry.getKey(), arrayWrapper);

                    // remove it from object.
                    fieldsIterator.remove();
                }
            }

            valuesToAdd.forEach((k, v) -> root.add(k + "List", v));

            System.out.println(gson.toJson(root));
        }
    }
}

import com.google.gson.gson；
导入com.google.gson.GsonBuilder；
导入com.google.gson.JsonElement；
导入com.google.gson.JsonObject；
导入java.io.File；
导入java.io.FileReader；
导入java.util.Iterator；
导入java.util.LinkedHashMap；
导入java.util.Map；
公共类GsonApp{
公共静态void main（字符串[]args）引发异常{
File jsonFile=新文件（“./resource/test.json”）.getAbsoluteFile（）；
Gson Gson=new GsonBuilder（）
.setPrettyPrinting（）
.create（）；
try（FileReader=newfilereader（jsonFile））{
JsonObject root=gson.fromJson（reader，JsonObject.class）；
Map valuesToAdd=新建LinkedHashMap（）；
//创建字段迭代器
迭代器fieldsIterator=root.entrySet（）.Iterator（）；
while（fieldsIterator.hasNext（））{
Map.Entry=fieldsIterator.next（）；
//如果条目表示数组
if（entry.getValue（）.isJsonArray（））{
//创建包装器对象
JsonObject arrayWrapper=新的JsonObject（）；
add（entry.getKey（），root.get（entry.getKey（））；
valuesToAdd.put（entry.getKey（），arrayWrapper）；
//从对象中删除它。
fieldsIterator.remove（）；
}
}
valuesToAdd.forEach（（k，v）->root.add（k+“List”，v））；
System.out.println（gson.toJson（root））；
}
}
}

输出相同。

检查

也检查

示例代码：

//此示例使用输入作为JSONNode
//可以使用ObjectMapper将POJO序列化到JSONNode。
ObjectMapper mapper=新的ObjectMapper（）；
mapper.writerWithDefaultPrettyPrinter（）.writeValueAsString(
inputNode）

这太棒了！非常感谢。这比我以前做的要简单得多。我是硬编码的，名声不高。很抱歉刚开始用这个。对不起，你会如何处理GSON？有没有办法让GSON做到这一点？