Jak usunąć pary klucz-wartość z pliku JSON w java
Zastanawiałem się, czy ktoś może mi pomóc lub podpowiedzieć, jak edytować załączony fikcyjny plik JSON w Javie.
Jak widać, mam obiekt głowy, który zawiera wiele wartości i dzieci, które mają ten sam wzór.
Chciałem wiedzieć, czy istnieje sposób na usunięcie wszystkich kluczy, których wartość wynosi -1.

Oto, co próbowałem na podstawie wielu witryn korzystających z 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());
//
Powyższy kod wyświetli strukturę pliku, jednak moim problemem jest osiągnięcie wartości -1 wewnątrz dzieci i ich usunięcie.
Używając metod .getClass i .simpleName, wiem, że jest to arrayList, ale nie wiem, jak ją przeszukiwać.
Każda pomoc będzie mile widziana!
Odpowiedzi
W Jackson
możesz odczytać cały JSON
ładunek JsonNode
i iterować po wszystkich właściwościach, sprawdzić podany warunek. W przypadku spełnienia warunku możesz usunąć dane pole. Aby to zrobić, musisz zaimplementować metodę rekurencyjną . Spójrz na poniższy przykład:
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);
}
}
}
Dla poniższego JSON
ładunku:
{
"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
}
]
}
]
}
powyższy kod drukuje:
{
"name" : "Head",
"children" : [ {
"name" : "project1",
"children" : [ {
"name" : "project1",
"missed" : 10,
"covered" : 11
} ]
}, {
"name" : "project1",
"covered" : 12,
"children" : [ {
"name" : "project1",
"missed" : 10
} ]
} ]
}
Zobacz też:
- Spłaszczanie 3-poziomowego zagnieżdżonego ciągu JSON w java
Istnieją dwie główne techniki analizowania i generowania danych JSON (a także wiele innych formatów, takich jak XML itp.): Mapowanie obiektów i przetwarzanie zorientowane na zdarzenia / token / strumień. Drugi sposób jest najlepszy w wielu przypadkach, w tym w filtrowaniu. Rekwizyty:
- plik / dane nie wymagają ładowania w całości do pamięci, można bez problemu przetwarzać meg / gigabajty
- działa znacznie szybciej, szczególnie w przypadku dużych plików
- za pomocą tego wzorca łatwo jest zaimplementować dowolny niestandardowy typ / regułę transformacji
Zarówno Gson, jak i Jackson obsługują przetwarzanie strumieniowe. Aby zilustrować tę ideę, posłużę się tylko przykładem z użyciem małego parsera / generatorahttps://github.com/anatolygudkov/green-jelly
import org.green.jelly.AppendableWriter;
import org.green.jelly.JsonBufferedWriter;
import org.green.jelly.JsonEventPump;
import org.green.jelly.JsonNumber;
import org.green.jelly.JsonParser;
import java.io.StringWriter;
public class UpdateMyJson {
private static final String jsonToUpdate = "{\n" +
"\"name\": \"Head\",\n" +
"\"missed\": -1,\n" +
"\"children\": [\n" +
" {\n" +
" \"name\": \"project1\",\n" +
" \"fixes\": 0,\n" +
" \"commits\": -1,\n" +
" },\n" +
" {\n" +
" \"name\": \"project2\",\n" +
" \"fixes\": 20,\n" +
" \"commits\": 5,\n" +
" }\n" +
"]\n" +
"}";
public static void main(String[] args) {
final StringWriter result = new StringWriter(); // you can use FileWriter
final JsonParser parser = new JsonParser();
parser.setListener(new MyJsonUpdater(new AppendableWriter<>(result)));
parser.parseAndEoj(jsonToUpdate); // if you read a file with a buffer,
// to don't load the whole file into memory,
// call parse() several times (part by part) in a loop until EOF
// and then call .eoj()
System.out.println(result);
}
static class MyJsonUpdater extends JsonEventPump {
MyJsonUpdater(final JsonBufferedWriter output) {
super(output);
}
@Override
public boolean onNumberValue(final JsonNumber number) {
if (number.mantissa() == -1 && number.exp() == 0) {
return true; // return immediately
}
return super.onNumberValue(number); // otherwise pump the value to the result JSON
}
}
}