5 техник итерации JSONObject в Java: от базовых до продвинутых

import org.json.JSONObject;

public class JSONObjectBasics {
public static void main(String[] args) {
// Создаем JSONObject
JSONObject developer = new JSONObject();

// Заполняем данными
developer.put("name", "Алексей");
developer.put("age", 28);
developer.put("skills", new JSONObject()
.put("languages", "Java, Python")
.put("frameworks", "Spring, Hibernate"));
developer.put("active", true);

System.out.println(developer.toString(2)); // Печать с отступом 2 пробела
}
}

import org.json.JSONException;
import org.json.JSONObject;
import java.util.Iterator;

public class JSONObjectIterationClassic {
public static void main(String[] args) {
String jsonString = "{\"name\":\"Иван\",\"age\":30,\"city\":\"Москва\",\"skills\":[\"Java\",\"Spring\"]}";

try {
JSONObject jsonObject = new JSONObject(jsonString);
Iterator<String> keys = jsonObject.keys();

while(keys.hasNext()) {
String key = keys.next();
Object value = jsonObject.get(key);

System.out.println(key + ": " + value);

// Обработка различных типов значений
if (value instanceof JSONObject) {
// Рекурсивная обработка вложенного объекта
processNestedObject((JSONObject) value);
}
}
} catch (JSONException e) {
e.printStackTrace();
}
}

private static void processNestedObject(JSONObject nestedObject) {
Iterator<String> nestedKeys = nestedObject.keys();
while(nestedKeys.hasNext()) {
String nestedKey = nestedKeys.next();
System.out.println(" " + nestedKey + ": " + nestedObject.get(nestedKey));
}
}
}

import org.json.JSONObject;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;
import java.util.Spliterator;
import java.util.Spliterators;

public class JSONObjectStreamAPI {
public static void main(String[] args) {
JSONObject developer = new JSONObject()
.put("name", "Ольга")
.put("experience", 7)
.put("technologies", "Java, Kotlin, Spring")
.put("remote", true)
.put("salary", 150000);

// Преобразование JSONObject в Map
Map<String, Object> developerMap = jsonObjectToMap(developer);

// Использование Stream API для фильтрации и обработки
developerMap.entrySet().stream()
.filter(entry -> !entry.getKey().equals("salary")) // Фильтруем конфиденциальные данные
.forEach(entry -> System.out.println(entry.getKey() + ": " + entry.getValue()));

// Агрегация данных с использованием Stream API
long totalNumericValues = developerMap.entrySet().stream()
.filter(entry -> entry.getValue() instanceof Number)
.mapToLong(entry -> ((Number) entry.getValue()).longValue())
.sum();

System.out.println("Сумма числовых значений: " + totalNumericValues);
}

// Метод для преобразования JSONObject в Map
private static Map<String, Object> jsonObjectToMap(JSONObject jsonObject) {
Map<String, Object> map = new HashMap<>();
Iterator<String> keys = jsonObject.keys();

while (keys.hasNext()) {
String key = keys.next();
map.put(key, jsonObject.get(key));
}

return map;
}

// Альтернативный способ с использованием StreamSupport (Java 8+)
private static Map<String, Object> jsonObjectToMapViaStream(JSONObject jsonObject) {
Iterator<String> keys = jsonObject.keys();

Iterable<String> iterable = () -> keys;
return StreamSupport.stream(
Spliterators.spliteratorUnknownSize(keys, Spliterator.ORDERED),
false)
.collect(Collectors.toMap(
key -> key,
jsonObject::get
));
}
}

public class JSONObjectStreamAdapter {
public static Stream<Map.Entry<String, Object>> stream(JSONObject jsonObject) {
return StreamSupport.stream(
Spliterators.spliteratorUnknownSize(
new Iterator<Map.Entry<String, Object>>() {
private final Iterator<String> keys = jsonObject.keys();

@Override
public boolean hasNext() {
return keys.hasNext();
}

@Override
public Map.Entry<String, Object> next() {
String key = keys.next();
return new AbstractMap.SimpleEntry<>(key, jsonObject.get(key));
}
},
Spliterator.ORDERED
),
false
);
}
}

// Использование:
JSONObjectStreamAdapter.stream(jsonObject)
.filter(entry -> entry.getValue() instanceof String)
.forEach(entry -> System.out.println(entry.getKey() + ": " + entry.getValue()));

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map.Entry;

public class JacksonIteration {
public static void main(String[] args) {
String jsonString = "{\"company\":\"TechCorp\",\"employees\":[{\"name\":\"Иван\",\"role\":\"Developer\"},{\"name\":\"Мария\",\"role\":\"Designer\"}],\"founded\":2010}";

ObjectMapper mapper = new ObjectMapper();
try {
// Парсинг в JsonNode
JsonNode rootNode = mapper.readTree(jsonString);

// Итерация 1: через fields()
System.out.println("Итерация через fields():");
Iterator<Entry<String, JsonNode>> fields = rootNode.fields();
while (fields.hasNext()) {
Entry<String, JsonNode> entry = fields.next();
System.out.println(entry.getKey() + ": " + entry.getValue());
}

// Итерация 2: через fieldNames() и get()
System.out.println("\nИтерация через fieldNames():");
Iterator<String> fieldNames = rootNode.fieldNames();
while (fieldNames.hasNext()) {
String fieldName = fieldNames.next();
JsonNode field = rootNode.get(fieldName);
System.out.println(fieldName + ": " + field);
}

// Итерация 3: преобразование в Map и использование entrySet()
System.out.println("\nИтерация через преобразование в Map:");
ObjectNode objectNode = (ObjectNode) rootNode;
objectNode.fields().forEachRemaining(entry -> 
System.out.println(entry.getKey() + " => " + entry.getValue())
);

} catch (IOException e) {
e.printStackTrace();
}
}
}

import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import java.util.Map.Entry;
import java.util.Set;

public class GsonIteration {
public static void main(String[] args) {
String jsonString = "{\"project\":\"API Gateway\",\"technologies\":[\"Java\",\"Spring\"],\"team\":{\"size\":8,\"location\":\"Москва\"}}";

// Парсинг в JsonObject
JsonObject jsonObject = JsonParser.parseString(jsonString).getAsJsonObject();

// Итерация через entrySet()
System.out.println("Итерация через entrySet():");
Set<Entry<String, JsonElement>> entrySet = jsonObject.entrySet();
for (Entry<String, JsonElement> entry : entrySet) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}

// Итерация с обработкой разных типов
System.out.println("\nИтерация с типизацией:");
for (Entry<String, JsonElement> entry : jsonObject.entrySet()) {
String key = entry.getKey();
JsonElement element = entry.getValue();

if (element.isJsonPrimitive()) {
System.out.println(key + " (примитив): " + element.getAsString());
} else if (element.isJsonArray()) {
System.out.println(key + " (массив): " + element);
} else if (element.isJsonObject()) {
System.out.println(key + " (объект): " + element);
}
}

// Рекурсивная итерация для вложенных объектов
processJsonElement("", jsonObject);
}

private static void processJsonElement(String prefix, JsonElement element) {
if (element.isJsonObject()) {
JsonObject obj = element.getAsJsonObject();
for (Entry<String, JsonElement> entry : obj.entrySet()) {
String newPrefix = prefix.isEmpty() ? entry.getKey() : prefix + "." + entry.getKey();
if (entry.getValue().isJsonPrimitive()) {
System.out.println(newPrefix + " = " + entry.getValue().getAsString());
} else {
processJsonElement(newPrefix, entry.getValue());
}
}
} else if (element.isJsonArray()) {
// Обработка массивов...
}
}
}

// Jackson: прямая десериализация
Developer dev = mapper.readValue(jsonString, Developer.class);

// Gson: прямая десериализация
Developer dev = new Gson().fromJson(jsonString, Developer.class);

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;

public class LargeJSONProcessing {
public static void main(String[] args) {
File largeJSONFile = new File("large_data.json");
JsonFactory factory = new JsonFactory();

try (JsonParser parser = factory.createParser(largeJSONFile)) {
// Поиск конкретных полей без загрузки всего документа
while (parser.nextToken() != JsonToken.END_OBJECT) {
String fieldName = parser.getCurrentName();
if ("targetField".equals(fieldName)) {
// Переходим к значению
parser.nextToken();
System.out.println("Найдено целевое поле: " + parser.getText());
break; // Раннее завершение после нахождения
}
}

// Счетчик для определенного типа элементов
parser.nextToken(); // Перемещаемся в начало
int userCount = 0;

while (parser.nextToken() != null) {
if (parser.getCurrentToken() == JsonToken.FIELD_NAME && 
"type".equals(parser.getText()) && 
parser.nextToken() == JsonToken.VALUE_STRING && 
"user".equals(parser.getText())) {
userCount++;
}
}

System.out.println("Количество пользователей: " + userCount);

} catch (IOException e) {
e.printStackTrace();
}
}
}

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ParallelJSONProcessing {
public static void main(String[] args) {
try {
ObjectMapper mapper = new ObjectMapper();
JsonNode rootNode = mapper.readTree(new File("large_data.json"));
JsonNode itemsNode = rootNode.get("items");

if (itemsNode.isArray()) {
ExecutorService executor = Executors.newWorkStealingPool();
List<CompletableFuture<Void>> futures = new ArrayList<>();

for (JsonNode item : itemsNode) {
CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
try {
// Обработка отдельного элемента в параллельном потоке
processItem(item);
} catch (Exception e) {
e.printStackTrace();
}
}, executor);
futures.add(future);
}

// Ожидание завершения всех задач
CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
executor.shutdown();
}
} catch (Exception e) {
e.printStackTrace();
}
}

private static void processItem(JsonNode item) {
// Ресурсоемкая обработка отдельного элемента JSON
String id = item.get("id").asText();
System.out.println("Обработка элемента " + id + " в потоке: " + 
Thread.currentThread().getName());
// ... дополнительная логика обработки
}
}