Cómo convertir hashmap a objeto JSON en Java

¿Cómo convertir o convertir hashmap a un objeto JSON en Java, y nuevamente convertir un objeto JSON a una cadena JSON?

Puedes usar:

new JSONObject(map);

Precaución: esto solo funcionará para unMap<String, String>!

Otras funciones que puede obtener de su documentación
http://stleary.github.io/JSON-java/index.html

Gson también se puede utilizar para serializar objetos complejos arbitrariamente.

Así es como lo usas:

Gson gson = new Gson(); 
String json = gson.toJson(myObject); 

Gsonconvertirá automáticamente las colecciones a JSONmatrices. Gson puede serializar campos privados e ignora automáticamente los campos transitorios.

Ejemplo usando json

Map<String, Object> data = new HashMap<String, Object>();
    data.put( "name", "Mars" );
    data.put( "age", 32 );
    data.put( "city", "NY" );
    JSONObject json = new JSONObject();
    json.putAll( data );
    System.out.printf( "JSON: %s", json.toString(2) );

salida::

JSON: {
  "age": 32,
  "name": "Mars",
  "city": "NY"
}

También puede intentar usar GSON de Google. GSON de Google es la mejor biblioteca disponible para convertir objetos Java en su representación JSON.

http://code.google.com/p/google-gson/

Puede convertir Mapa JSONusar de la Jacksonsiguiente manera:

Map<String,Object> map = new HashMap<>();
//You can convert any Object.
String[] value1 = new String[] { "value11", "value12", "value13" };
String[] value2 = new String[] { "value21", "value22", "value23" };
map.put("key1", value1);
map.put("key2", value2);
map.put("key3","string1");
map.put("key4","string2");

String json = new ObjectMapper().writeValueAsString(map);
System.out.println(json);

Dependencias de Maven para Jackson:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.5.3</version>
    <scope>compile</scope>
</dependency>

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.5.3</version>
    <scope>compile</scope>
</dependency>

Si está utilizando la JSONObjectbiblioteca, puede convertir el mapa de la JSONsiguiente manera:

Map<String, Object> map = new HashMap<>();
// Convert a map having list of values.
String[] value1 = new String[] { "value11", "value12", "value13" };
String[] value2 = new String[] { "value21", "value22", "value23" };
map.put("key1", value1);
map.put("key2", value2);

JSONObject json = new JSONObject(map);
System.out.println(json);

Dependencias de Maven para JSONObject:

<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20140107</version>
</dependency>

Espero que esto ayude. Feliz codificación

En mi caso no quería ninguna dependencia. Usando Java 8 puede obtener JSON como una cadena así de simple:

Map<String, Object> map = new HashMap<>();
map.put("key", "value");
map.put("key2", "value2");
String json = "{"+map.entrySet().stream()
    .map(e -> "\""+ e.getKey() + "\"" + ":\"" + String.valueOf(e.getValue()) + "\"")
    .collect(Collectors.joining(", "))+"}";

Simplemente puede enumerar el mapa y agregar los pares clave-valor al objeto JSON

Método:

private JSONObject getJsonFromMap(Map<String, Object> map) throws JSONException {
    JSONObject jsonData = new JSONObject();
    for (String key : map.keySet()) {
        Object value = map.get(key);
        if (value instanceof Map<?, ?>) {
            value = getJsonFromMap((Map<String, Object>) value);
        }
        jsonData.put(key, value);
    }
    return jsonData;
}

La biblioteca Underscore-java puede convertir el mapa hash o la lista de matrices a json y viceversa.

import com.github.underscore.lodash.U;
import java.util.*;

public class Main {

    public static void main(String[] args) {

        Map<String, Object> map = new LinkedHashMap<>();
        map.put("1", "a");
        map.put("2", "b");

        System.out.println(U.toJson(map));
        // {
        //    "1": "a",
        //    "2": "b"
        // }
    }
}

Tarde a la fiesta pero aquí está mi GSON escritor ad hoc de para serializar hashmap. Tuve que escribir un mapa de pares clave-valor como atributos de cadena json, espero que uno específico sea de tipo entero. No quería crear un contenedor JavaBean personalizado para este simple caso de uso.

La clase JONWriter de GSON es una clase de serializador fácil de usar que contiene pocas funciones de escritor fuertemente escritas.

// write Map as JSON document to http servlet response
Map<String,String> sd = DAO.getSD(123);
res.setContentType("application/json; charset=UTF-8");
res.setCharacterEncoding("UTF-8");
JsonWriter writer = new JsonWriter(new OutputStreamWriter(res.getOutputStream(), "UTF-8"));
writer.beginObject();
for(String key : sd.keySet()) {
    String val = sd.get(key);
    writer.name(key);
    if (key.equals("UniqueID") && val!=null)
        writer.value(Long.parseLong(val));
    else
        writer.value(val);
}
writer.endObject();
writer.close();

Si no se necesita ninguno de los tipos personalizados, podría haber usado la función toJson (). La biblioteca gson-2.2.4.jar tiene poco menos de 190 KB sin ninguna dependencia brutal. Fácil de usar en cualquier aplicación de servlet personalizada o aplicación independiente sin grandes integraciones de framework.

Gson gson = new Gson(); 
String json = gson.toJson(myMap); 

Este es típicamente el trabajo de una biblioteca Json, no debe intentar hacerlo usted mismo. Todas las bibliotecas json deben implementar lo que está solicitando, y puede encontrar una lista de bibliotecas Java Json en json.org , en la parte inferior de la página.

Encontré otra forma de manejarlo.

Map obj=new HashMap();    
obj.put("name","sonoo");    
obj.put("age",new Integer(27));    
obj.put("salary",new Double(600000));   
String jsonText = JSONValue.toJSONString(obj);  
System.out.print(jsonText);

Espero que esto ayude.

Gracias.

Si necesita usarlo en el código.

Gson gsone = new Gson();
JsonObject res = gsone.toJsonTree(sqlParams).getAsJsonObject();

Para aquellos que usan org.json.simple.JSONObject, puede convertir el mapa a Json String y analizarlo para obtener el JSONObject.

JSONObject object = (JSONObject) new JSONParser().parse(JSONObject.toJSONString(map));

Mejor llegar tarde que nunca. Solía GSON a la lista de conversión de HashMap de cadena si en caso de que quiera tener una lista serializado.

List<HashMap<String, String>> list = new ArrayList<>();
HashMap<String,String> hashMap = new HashMap<>();
hashMap.add("key", "value");
hashMap.add("key", "value");
hashMap.add("key", "value");
list.add(hashMap);

String json = new Gson().toJson(list);

Esto jsonproduce[{"key":"value","key":"value","key":"value"}]

Aquí mi solución de línea única con GSON:

myObject = new Gson().fromJson(new Gson().toJson(myHashMap), MyClass.class);

Esta solución funciona con JSON complejos:

public Object toJSON(Object object) throws JSONException {
    if (object instanceof HashMap) {
        JSONObject json = new JSONObject();
        HashMap map = (HashMap) object;
        for (Object key : map.keySet()) {
            json.put(key.toString(), toJSON(map.get(key)));
        }
        return json;
    } else if (object instanceof Iterable) {
        JSONArray json = new JSONArray();
        for (Object value : ((Iterable) object)) {
            json.put(toJSON(value));
        }
        return json;
    }
    else {
        return object;
    }
}

Usamos Gson.

Gson gson = new Gson();
Type gsonType = new TypeToken<HashMap>(){}.getType();
String gsonString = gson.toJson(elements,gsonType);

Puede usar XStream, es realmente útil. Mira los ejemplos aquí

package com.thoughtworks.xstream.json.test;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.json.JettisonMappedXmlDriver;

public class WriteTest {

    public static void main(String[] args) {

      HashMap<String,String> map = new HashMap<String,String>();
      map.add("1", "a");
      map.add("2", "b");
      XStream xstream = new XStream(new JettisonMappedXmlDriver());

      System.out.println(xstream.toXML(map));       

    }

}

Si está utilizando, net.sf.json.JSONObjectentonces no encontrará un JSONObject(map)constructor en él. Tienes que usar el public static JSONObject fromObject( Object object )método. Este método acepta cadenas con formato JSON, Maps, DynaBeans y JavaBeans.

JSONObject jsonObject = JSONObject.fromObject(myMap);

Si usa objetos complejos, debe aplicar enableComplexMapKeySerialization () , como se indica en https://stackoverflow.com/a/24635655/2914140 y https://stackoverflow.com/a/26374888/2914140 .

Gson gson = new GsonBuilder().enableComplexMapKeySerialization().create();
Map<Point, String> original = new LinkedHashMap<Point, String>();
original.put(new Point(5, 6), "a");
original.put(new Point(8, 8), "b");
System.out.println(gson.toJson(original));

La salida será:

{
 "(5,6)": "a",
 "(8,8)": "b"
}

No hay necesidad de bibliotecas de análisis Gson o JSON. Solo usando new JSONObject(Map<String, JSONObject>).toString(), por ejemplo:

/**
 * convert target map to JSON string
 *
 * @param map the target map
 * @return JSON string of the map
 */
@NonNull public String toJson(@NonNull Map<String, Target> map) {
    final Map<String, JSONObject> flatMap = new HashMap<>();
    for (String key : map.keySet()) {
        try {
            flatMap.put(key, toJsonObject(map.get(key)));
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }
    try {
        // 2 indentSpaces for pretty printing
        return new JSONObject(flatMap).toString(2);
    } catch (JSONException e) {
        e.printStackTrace();
        return "{}";
    }
}

    import org.json.JSONObject;

    HashMap<Object, Object> map = new HashMap<>();
    String[] list={"Grader","Participant"};
    String[] list1={"Assistant","intern"};
    map.put("TeachingAssistant",list);
    map.put("Writer",list1);
    JSONObject jsonObject = new JSONObject(map);
    System.out.printf(jsonObject.toString());

    // Result: {"TeachingAssistant":["Grader","Participant"],"Writer":["Assistant","intern"]}

Si realmente no necesita HashMap, puede hacer algo así:

String jsonString = new JSONObject() {{
  put("firstName", user.firstName);
  put("lastName", user.lastName);
}}.toString();

Salida:

{
  "firstName": "John",
  "lastName": "Doe"
}

Estoy usando Alibaba fastjson, fácil y simple:

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>VERSION_CODE</version>
</dependency>

e importar:

import com.alibaba.fastjson.JSON;

Luego:

String text = JSON.toJSONString(obj); // serialize
VO vo = JSON.parseObject("{...}", VO.class); //unserialize

Todo está bien.

Si está utilizando JSR 374: API Java para el procesamiento JSON (javax json) Esto parece ser el truco:

    JsonObjectBuilder job = Json.createObjectBuilder((Map<String, Object>) obj);
    JsonObject jsonObject = job.build();

Puedes usar Gson . Esta biblioteca proporciona métodos simples para convertir objetos Java en objetos JSON y viceversa.

Ejemplo:

GsonBuilder gb = new GsonBuilder();
Gson gson = gb.serializeNulls().create();
gson.toJson(object);

Puede usar un GsonBuilder cuando necesite establecer opciones de configuración distintas a las predeterminadas. En el ejemplo anterior, el proceso de conversión también serializará atributos nulos del objeto.

Sin embargo, este enfoque solo funciona para tipos no genéricos. Para los tipos genéricos, debe usar toJson (objeto, tipo).

Más información sobre Gson aquí .

Recuerde que el objeto debe implementar la interfaz serializable .

esto funciona para mi:

import groovy.json.JsonBuilder
properties = new Properties()
properties.put("name", "zhangsan")

println new JsonBuilder(properties).toPrettyString()

Manera de Gson para mapas y listas un poco más complejos usando el método TypeToken.getParameterized :

Tenemos un mapa que se ve así:

Map<Long, List<NewFile>> map;

Obtenemos el tipo usando el método getParameterized mencionado anteriormente como este:

Type listOfNewFiles = TypeToken.getParameterized(ArrayList.class, NewFile.class).getType();
Type mapOfList = TypeToken.getParameterized(LinkedHashMap.class, Long.class, listOfNewFiles).getType();

Y luego use el objeto Gson del método Json como este usando el objeto mapOfList como este:

Map<Long, List<NewFile>> map = new Gson().fromJson(fileContent, mapOfList);

El objeto mencionado NewFile se ve así:

class NewFile
{
    private long id;
    private String fileName;

    public void setId(final long id)
    {
        this.id = id;
    }

    public void setFileName(final String fileName)
    {
        this.fileName = fileName;
    }
}

El JSON deserializado se ve así:

{
  "1": [
    {
      "id": 12232,
      "fileName": "test.html"
    },
    {
      "id": 12233,
      "fileName": "file.txt"
    },
    {
      "id": 12234,
      "fileName": "obj.json"
    }
  ],
 "2": [
    {
      "id": 122321,
      "fileName": "test2.html"
    },
    {
      "id": 122332,
      "fileName": "file2.txt"
    },
    {
      "id": 122343,
      "fileName": "obj2.json"
    }
  ]
}

Me enfrenté a un problema similar al deserializar la respuesta de los comandos personalizados en selenio. La respuesta fue json, pero el selenio se traduce internamente en java.util.HashMap [String, Object]

Si está familiarizado con scala y utiliza la API de reproducción para JSON, podría beneficiarse de esto:

import play.api.libs.json.{JsValue, Json}
import scala.collection.JavaConversions.mapAsScalaMap


object JsonParser {

  def parse(map: Map[String, Any]): JsValue = {
    val values = for((key, value) <- map) yield {
      value match {
        case m: java.util.Map[String, _] @unchecked => Json.obj(key -> parse(m.toMap))
        case m: Map[String, _] @unchecked => Json.obj(key -> parse(m))
        case int: Int => Json.obj(key -> int)
        case str: String => Json.obj(key -> str)
        case bool: Boolean => Json.obj(key -> bool)
      }
    }

    values.foldLeft(Json.obj())((temp, obj) => {
      temp.deepMerge(obj)
    })
  }
}

Descripción del código pequeño:

El código atraviesa recursivamente el HashMap hasta que se encuentran tipos básicos (String, Integer, Boolean). Estos tipos básicos se pueden envolver directamente en un JsObject. Cuando se despliega la recursividad, la fusión profunda concatena los objetos creados.

'@unchecked' se encarga de las advertencias de borrado de tipo.

Primero convierta todos sus objetos en cadenas válidas

HashMap<String, String> params = new HashMap<>();
params.put("arg1", "<b>some text</b>");
params.put("arg2", someObject.toString());

Luego inserte todo el mapa en un org.json.JSONObject

JSONObject postData = new JSONObject(params);

Ahora puede obtener el JSON simplemente llamando a toString del objeto

postData.toString()
//{"arg1":"<b>some text<\/b>" "arg2":"object output"}

Crear un nuevo objeto JSON

JSONObject o = new JSONObject(postData.toString());

O como una matriz de bytes para enviar a través de HTTP

postData.toString().getBytes("UTF-8");