如何使用Jackson在Java中高效地从JSON文件读取数据？

我将所有静态数据存储在

JSON

文件中。此

JSON

文件最多有

1000行。如何在不将所有行存储为
ArrayList
的情况下获取所需数据

我的代码，我现在正在使用，我想提高它的效率

List<Colors> colorsList = new ObjectMapper().readValue(resource.getFile(), new TypeReference<Colors>() {});
    for(int i=0; i<colorsList.size(); i++){
        if(colorsList.get(i).getColor.equals("Blue")){
            return colorsList.get(i).getCode();
        }
    }

Resource.json

[
...
  {
    "color":"Blue",
    "code":["012","0324","15478","7412"]
  },
  {
    "color":"Red",
    "code":["145","001","1","7879","123984","89"]
  },
  {
    "color":"White",
    "code":["7","11","89","404"]
  }
...
]

Colors.java

class Colors {

    private String color;
    private List<String> code;

    public Colors() {
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public List<String> getCode() {
        return code;
    }

    public void setCode(List<String> code) {
        this.code = code;
    }

    @Override
    public String toString() {
        return "Colors{" +
                "color='" + color + '\'' +
                ", code=" + code +
                '}';
    }
}

类颜色{
私有字符串颜色；
私人名单代码；
公共颜色（）{
}
公共字符串getColor（）{
返回颜色；
}
公共void setColor（字符串颜色）{
这个颜色=颜色；
}
公共列表getCode（）{
返回码；
}
公共无效设置代码（列表代码）{
this.code=代码；
}
@凌驾
公共字符串toString（）{
返回“颜色{”+
“颜色='”+颜色+'\''+
“，code=“+code+
'}';
}
}
在这种情况下创建
POJO
类是一种浪费，因为我们不使用整个结果
列表
，而只使用一个内部属性。为了避免这种情况，我们可以使用本机
JsonNode
和
ArrayNode
数据类型。我们可以使用
readTree
方法读取
JSON
，迭代数组，找到给定的对象，最后转换内部
code
数组。它可能如下所示：

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

import java.io.File;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class JsonApp {

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

        ObjectMapper mapper = new ObjectMapper();

        ArrayNode rootArray = (ArrayNode) mapper.readTree(jsonFile);
        int size = rootArray.size();

        for (int i = 0; i < size; i++) {
            JsonNode jsonNode = rootArray.get(i);
            if (jsonNode.get("color").asText().equals("Blue")) {
                Iterator<JsonNode> codesIterator = jsonNode.get("code").elements();
                List<String> codes = new ArrayList<>();
                codesIterator.forEachRemaining(n -> codes.add(n.asText()));

                System.out.println(codes);
                break;
            }
        }
    }
}

这种解决方案的缺点是，我们将整个
JSON
加载到内存中，这对我们来说可能是个问题。让我们试着用它来做这件事。它使用起来有点困难，您必须知道
JSON
负载是如何构造的，但使用
Jackson
获取
code
数组是最快的方法。下面的实现是幼稚的，不能处理所有的可能性，因此您不应该依赖它：

import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class JsonApp {

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

        System.out.println(getBlueCodes(jsonFile));
    }

    private static List<String> getBlueCodes(File jsonFile) throws IOException {
        try (JsonParser parser = new JsonFactory().createParser(jsonFile)) {
            while (parser.nextToken() != JsonToken.END_OBJECT) {
                String fieldName = parser.getCurrentName();
                // Find color property
                if ("color".equals(fieldName)) {
                    parser.nextToken();
                    // Find Blue color
                    if (parser.getText().equals("Blue")) {
                        // skip everything until start of the array
                        while (parser.nextToken() != JsonToken.START_ARRAY) ;

                        List<String> codes = new ArrayList<>();
                        while (parser.nextToken() != JsonToken.END_ARRAY) {
                            codes.add(parser.getText());
                        }
                        return codes;
                    } else {
                        // skip current object because it is not `Blue`
                        while (parser.nextToken() != JsonToken.END_OBJECT) ;
                    }
                }
            }
        }

        return Collections.emptyList();
    }
}

最后，我需要提到解决方案，如果您可以使用其他库，该解决方案也可能很好：

import com.jayway.jsonpath.JsonPath;
import net.minidev.json.JSONArray;

import java.io.File;
import java.util.List;
import java.util.stream.Collectors;

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

        JSONArray array = JsonPath.read(jsonFile, "$[?(@.color == 'Blue')].code");
        JSONArray jsonCodes = (JSONArray)array.get(0);
        List<String> codes = jsonCodes.stream()
                .map(Object::toString).collect(Collectors.toList());

        System.out.println(codes);
    }
}

您可以使用流解析库来提高内存、CPU效率和快速开发。DSM使用基于YAML的映射文件，只读取整个数据一次

以下是您问题的解决方案：

映射文件：

params:
   colorsToFilter: ['Blue','Red']  # parameteres can be passed programmatically
result:
   type: array
   path: /.*colors  # path is regex
   filter: params.colorsToFilter.contains(self.data.color)  # select only color that exist in colorsToFilter list
   fields:
      color: 
      code:
         type: array

使用DSM解析json：

DSM dsm = new DSMBuilder(new File("path/maping.yaml")).create(Colors.class);
List<Colors> object = (List<Colors>) dsm.toObject(jsonData);

System.out.println(object);

忘记我说的一切。你真的需要提高效率吗？1000条线没那么大，你真的需要提高效率吗？现在使用ArrayList需要多长时间？您必须始终使用库来使用JSON文件：如果您需要访问单个对象，JSON可能不是存储它们的最佳选择。
import com.jayway.jsonpath.JsonPath;
import net.minidev.json.JSONArray;

import java.io.File;
import java.util.List;
import java.util.stream.Collectors;

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

        JSONArray array = JsonPath.read(jsonFile, "$[?(@.color == 'Blue')].code");
        JSONArray jsonCodes = (JSONArray)array.get(0);
        List<String> codes = jsonCodes.stream()
                .map(Object::toString).collect(Collectors.toList());

        System.out.println(codes);
    }
}

[012, 0324, 15478, 7412]

params:
   colorsToFilter: ['Blue','Red']  # parameteres can be passed programmatically
result:
   type: array
   path: /.*colors  # path is regex
   filter: params.colorsToFilter.contains(self.data.color)  # select only color that exist in colorsToFilter list
   fields:
      color: 
      code:
         type: array

DSM dsm = new DSMBuilder(new File("path/maping.yaml")).create(Colors.class);
List<Colors> object = (List<Colors>) dsm.toObject(jsonData);

System.out.println(object);

[Colors{color='Blue', code=[012, 0324, 15478, 7412]}, Colors{color='Red', code=[145, 001, 1, 7879, 123984, 89]}]