Manejo de arrays JSON en Java

Para leer un array JSON desde un archivo en Java, añade a tu proyecto un analizador JSON, como JSON.simple; analiza el archivo y recorre el array resultante. Java no incluye un analizador JSON de propósito general en sus bibliotecas estándar. JSON.simple es una dependencia externa, así que debes añadirla mediante la herramienta de compilación o el gestor de dependencias de tu proyecto.

JSON.simple ha tenido varias versiones y líneas de API. El ejemplo siguiente usa la familia de API org.json.simple; antes de utilizarla, elige una versión y consulta su documentación para conocer las coordenadas de la dependencia, la API del analizador y los tipos de valores. Aquí no se presupone una versión ni una herramienta de compilación concretas. Si la versión elegida usa otros paquetes o firmas de métodos, adapta el ejemplo según su documentación en lugar de copiar una declaración de dependencia que corresponda a otra versión.

Cómo manejar arrays JSON en Java

JSON (JavaScript Object Notation) representa datos mediante objetos, arrays, cadenas, números, valores booleanos y null. El código Java necesita un analizador para convertir el texto JSON en valores con los que pueda trabajar. JSON.simple es una opción para realizar ese análisis.

Un array es una secuencia ordenada delimitada por corchetes. Un objeto es una colección de valores con nombre delimitada por llaves. Los arrays y los objetos pueden anidarse; por eso, un archivo puede comenzar con un array cuyos elementos sean objetos que, a su vez, contengan otros arrays u objetos.

Objetos JSON y arrays JSON en Java

Un objeto almacena valores bajo claves de tipo cadena: cada clave y su valor se separan con dos puntos, y las entradas se separan con comas. Un array almacena valores según su posición y los separa con comas. Por ejemplo, el valor JSON integrado [1, "abc", {"name":"xyz"}] es un array que contiene un número, una cadena y un objeto. El objeto tiene una clave name cuyo valor es una cadena.

El archivo del ejemplo tiene un array en el nivel superior con un objeto. Ese objeto contiene una cadena, un número, dos arrays anidados y un objeto anidado:

[{"name":"MMN","roll":24,"marks":[91,95,97,97,94],"parents":{"name":"IMT","mobile":"1234567890"},"hobbies":["sports","reading","music"],"others":["A",1]}]

La estructura importa al extraer valores: el código que lee name, roll o parents presupone que esas claves existen y contienen los tipos JSON esperados. Si los datos provienen de una fuente que no controlas, valida cada valor antes de tratarlo como un tipo Java concreto.

Leer un array JSON desde un archivo en Java con JSON.simple

Añade JSON.simple mediante el gestor de dependencias de tu proyecto. Usa las coordenadas del artefacto documentadas para la versión exacta que hayas elegido; este artículo no especifica coordenadas porque no se ha establecido una versión ni una herramienta de compilación concretas. La familia de paquetes org.json.simple es externa, así que sus importaciones y llamadas al analizador no pueden ejecutarse en un entorno que solo tenga Java sin incluir la biblioteca correspondiente en el classpath.

En un proyecto que use una versión compatible de JSON.simple, el paso de análisis puede expresarse conceptualmente como new JSONParser().parse(reader). Confirma en la documentación de esa versión la API exacta del analizador y los tipos de colecciones que devuelve. El ejemplo siguiente se centra en el paso posterior: recorrer la estructura de colecciones Java una vez que el analizador la ha generado. Sus valores coinciden con los del archivo de muestra y utiliza únicamente colecciones de la biblioteca estándar de Java, por lo que puede ejecutarse de forma independiente.

import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

public class JSONArrayTraversal {
  public static void main(String[] args) {
    Map<String, Object> parents = new LinkedHashMap<>();
    parents.put("name", "IMT");
    parents.put("mobile", "1234567890");

    Map<String, Object> record = new LinkedHashMap<>();
    record.put("name", "MMN");
    record.put("roll", 24);
    record.put("marks", Arrays.asList(91, 95, 97, 97, 94));
    record.put("parents", parents);
    record.put("hobbies", Arrays.asList("sports", "reading", "music"));
    record.put("others", Arrays.asList("A", 1));
    List<Map<String, Object>> records = Arrays.asList(record);

    for (Map<String, Object> item : records) {
      System.out.println("Name: " + item.get("name"));
      System.out.println("Roll: " + item.get("roll"));
      System.out.println("Marks: " + item.get("marks"));
      System.out.println("Hobbies: " + item.get("hobbies"));
      Map<?, ?> parent = (Map<?, ?>) item.get("parents");
      System.out.println("Parent's Name: " + parent.get("name")
          + ", Mobile: " + parent.get("mobile"));
      System.out.println("Others: " + item.get("others"));
    }
  }
}

Name: MMN
Roll: 24
Marks: [91, 95, 97, 97, 94]
Hobbies: [sports, reading, music]
Parent's Name: IMT, Mobile: 1234567890
Others: [A, 1]

En una aplicación, pasa a un código de recorrido adaptado a los tipos de colecciones de esa versión el valor que devuelva el analizador JSON.simple elegido. Aquí, records representa el array analizado del nivel superior. Las conversiones de tipo y las búsquedas de campos dependen del esquema de muestra; si la entrada puede variar, valida cada elemento del array y cada campo antes de confiar en su tipo. Mantén el lector abierto durante el análisis y ciérralo después, incluso si el análisis falla. Gestiona los errores de acceso al archivo y de análisis según el comportamiento documentado para la versión elegida y las necesidades de tu aplicación. Al conectar este recorrido con la lectura del archivo, proporciona una ruta existente y legible en tu entorno.

Conclusión

Un array JSON es una secuencia ordenada, mientras que un objeto JSON asocia valores con nombre a sus claves. Para leer un array desde un archivo en Java, utiliza un analizador externo como JSON.simple, añade a tu proyecto la dependencia documentada para la versión elegida y recorre la estructura analizada según el esquema de entrada. Consulta la API y los tipos numéricos de esa versión antes de depender de conversiones de tipo o conversiones numéricas.