Como converter hashmap em objeto JSON em Java

Como converter ou converter hashmap em objeto JSON em Java e converter novamente objeto JSON em string JSON?

Você pode usar:

new JSONObject(map);

Cuidado: Isso funcionará apenas para umMap<String, String>!

Outras funções que você pode obter na documentação
http://stleary.github.io/JSON-java/index.html

O Gson também pode ser usado para serializar objetos arbitrariamente complexos.

Aqui está como você o usa:

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

Gsonconverterá automaticamente coleções em JSONmatrizes. O Gson pode serializar campos particulares e ignora automaticamente campos transitórios.

Exemplo 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) );

resultado::

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

Você também pode tentar usar o GSON do Google. O GSON do Google é a melhor biblioteca disponível para converter objetos Java em sua representação JSON.

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

Você pode converter Mappara JSONusar da Jacksonseguinte maneira:

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);

Dependências do 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>

Se você estiver usando a JSONObjectbiblioteca, poderá converter o mapa da JSONseguinte maneira:

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);

Dependências do Maven para JSONObject:

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

Espero que isso ajude. Feliz codificação.

No meu caso, eu não queria nenhuma dependência. Usando o Java 8, você pode obter JSON como uma string simples:

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(", "))+"}";

Você pode apenas enumerar o mapa e adicionar os pares de valor-chave ao JSONObject

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;
}

A biblioteca Underscore-java pode converter o mapa de hash ou a lista de matrizes em json e vice-verso.

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 para a festa, mas aqui está o meu escritor adhoc da GSON para serializar o hashmap. Eu tive que escrever um mapa de pares de valores-chave como atributos de string json, esperar que um específico seja do tipo inteiro. Eu não queria criar um wrapper JavaBean personalizado para este simples caso de usuário.

A classe GSON JsonWriter é fácil de usar, a classe serializador, contendo poucas funções writer.value () fortemente tipadas.

// 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();

Se nenhum dos tipos personalizados for necessário, eu poderia usar a função toJson (). A biblioteca gson-2.2.4.jar está abaixo de 190KB, sem nenhuma dependência brutal. Fácil de usar em qualquer aplicativo de servlet personalizado ou aplicativo independente, sem grandes integrações de estrutura.

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

Normalmente, este é o trabalho de uma biblioteca Json; você não deve tentar fazer isso sozinho. Todas as bibliotecas json devem implementar o que você está solicitando e você pode encontrar uma lista de bibliotecas Java Json em json.org , na parte inferior da página.

Eu encontrei outra maneira de lidar com isso.

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 isto ajude.

Obrigado.

Se você precisar usá-lo no código.

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

Para aqueles que usam org.json.simple.JSONObject, você pode converter o mapa em Json String e analisá-lo para obter o JSONObject.

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

Melhor chegar atrasado do que nunca. Usei o GSON para converter a lista de HashMap em string, caso você queira ter uma lista serializada.

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);

Isso jsonproduz[{"key":"value","key":"value","key":"value"}]

Aqui está minha solução de linha única com o GSON:

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

Esta solução funciona com JSONs complexos:

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;
    }
}

nós usamos o Gson.

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

Você pode usar o XStream - é realmente útil. Veja os exemplos aqui

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));       

    }

}

Se você estiver usando net.sf.json.JSONObject, não encontrará um JSONObject(map)construtor nele. Você tem que usar o public static JSONObject fromObject( Object object )método Este método aceita seqüências de caracteres formatadas em JSON, Maps, DynaBeans e JavaBeans.

JSONObject jsonObject = JSONObject.fromObject(myMap);

Se você usar objetos complexos, aplique enableComplexMapKeySerialization () , conforme indicado em https://stackoverflow.com/a/24635655/2914140 e 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));

A saída será:

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

Não há necessidade de bibliotecas de análise Gson ou JSON. Apenas usando new JSONObject(Map<String, JSONObject>).toString(), por exemplo:

/**
 * 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"]}

Se você realmente não precisa do HashMap, pode fazer algo assim:

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

Resultado:

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

Estou usando o Alibaba fastjson, fácil e simples:

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

e importar:

import com.alibaba.fastjson.JSON;

Então:

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

Está tudo bem.

Se você estiver usando JSR 374: API Java para processamento JSON (javax json), isso parece fazer o truque:

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

Você pode usar o Gson . Esta biblioteca fornece métodos simples para converter objetos Java em objetos JSON e vice-versa.

Exemplo:

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

Você pode usar um GsonBuilder quando precisar definir opções de configuração diferentes do padrão. No exemplo acima, o processo de conversão também serializará atributos nulos do objeto.

No entanto, essa abordagem funciona apenas para tipos não genéricos. Para tipos genéricos, você precisa usar toJson (objeto, Tipo).

Mais informações sobre Gson aqui .

Lembre-se de que o objeto deve implementar a interface serializável .

isso funciona para mim:

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

println new JsonBuilder(properties).toPrettyString()

Gson maneira para mapas e listas um pouco mais complexos usando o método TypeToken.getParameterized :

Temos um mapa parecido com este:

Map<Long, List<NewFile>> map;

Obtemos o Type usando o método getParameterized acima mencionado , como este:

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

E, em seguida, use o objeto Gson fromJson método como este usando o objeto mapOfList como este:

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

O objeto mencionado NewFile se parece com isso:

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;
    }
}

O JSON desserializado fica assim:

{
  "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"
    }
  ]
}

Eu enfrentei um problema semelhante ao desserializar a resposta de comandos personalizados no selênio. A resposta foi json, mas o selênio internamente traduz isso em um java.util.HashMap [String, Object]

Se você estiver familiarizado com o scala e usar a API play para JSON, poderá se beneficiar com isso:

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)
    })
  }
}

Descrição de código pequeno:

O código percorre recursivamente o HashMap até que tipos básicos (String, Inteiro, Booleano) sejam encontrados. Esses tipos básicos podem ser agrupados diretamente em um JsObject. Quando a recursão é desdobrada, o deepmerge concatena os objetos criados.

'@unchecked' cuida dos avisos de exclusão de tipo.

Primeiro converta todos os seus objetos em Strings válidas

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

Em seguida, insira o mapa inteiro em um org.json.JSONObject

JSONObject postData = new JSONObject(params);

Agora você pode obter o JSON simplesmente chamando toString do objeto

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

Crie um novo JSONObject

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

Ou como uma matriz de bytes para enviar por HTTP

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