Hashmap Java JSON nesnesine dönüştürme

Nasıl hashmap Java JSON nesnesine dönüştürmek veya döküm ve yine JSON nesnesini JSON dizeye dönüştürmek için?

Kullanabilirsiniz:

new JSONObject(map);

Dikkat: Bu sadece birMap<String, String>!

Dokümanlarından alabileceğiniz diğer fonksiyonlar
http://stleary.github.io/JSON-java/index.html

Gson ayrıca rastgele karmaşık nesneleri serileştirmek için de kullanılabilir.

İşte nasıl kullanacağınız:

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

Gsonkoleksiyonları otomatik olarak JSONdizilere dönüştürür . Gson özel alanları serileştirebilir ve geçici alanları otomatik olarak yok sayar.

Json kullanarak örnek

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

çıktı::

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

Google'ın GSON'unu da kullanmayı deneyebilirsiniz. Google'ın GSON'u, Java Nesnelerini JSON temsillerine dönüştürmek için mevcut en iyi kütüphanedir.

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

Sen dönüştürebilirsiniz Mapiçin JSONkullanıyor Jacksonşöyle:

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

Maven Bağımlılıkları 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>

JSONObjectKütüphane kullanıyorsanız , haritayı JSONaşağıdaki gibi dönüştürebilirsiniz :

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

Maven Bağımlılıkları JSONObject:

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

Umarım bu yardımcı olur. Mutlu kodlama.

Benim durumumda herhangi bir bağımlılık istemedim. Java 8'i kullanarak JSON'u bu kadar basit bir dize olarak alabilirsiniz:

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

Sadece haritayı numaralandırabilir ve anahtar / değer çiftlerini JSONObject öğesine ekleyebilirsiniz.

Yöntem :

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

Alt çizgi-java kütüphanesi karma harita veya dizi listesini json ve ayet'e dönüştürebilir.

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

Partiye geç kaldım ama işte, hashumu serileştirmek için GSON geçici yazarım. Anahtar-değer çiftlerinin haritası json string öznitelikleri olarak yazmak zorunda kaldım, belirli bir tamsayı türü olmasını bekliyorum. Bu basit kullanım için özel JavaBean sarmalayıcısı oluşturmak istemedim.

GSON JsonWriter sınıfının, güçlü yazılan birkaç writer.value () işlevi içeren serileştirici sınıfı kullanımı kolaydır.

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

Özel türlerin hiçbirine ihtiyaç duyulmazsa, sadece toJson () işlevini kullanabilirdim. gson-2.2.4.jar kütüphanesi acımasız bağımlılıklar olmadan 190 KB'ın hemen altındadır. Büyük çerçeve entegrasyonları olmadan herhangi bir özel sunucu uygulaması veya bağımsız uygulamada kullanımı kolaydır.

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

Bu genellikle bir Json kütüphanesinin çalışmasıdır, kendiniz yapmaya çalışmamalısınız. Tüm json kütüphaneleri, istediğinizi uygulamalıdır ve json.org'da sayfanın alt kısmında Java Json kütüphanelerinin bir listesini bulabilirsiniz .

Bununla başa çıkmanın başka bir yolunu buldum.

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

Bu yardımcı olur umarım.

Teşekkürler.

Kodda kullanmanız gerekiyorsa.

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

Kullananlar için org.json.simple.JSONObject, haritayı Json String'e dönüştürebilir ve almak için ayrıştırabilirsiniz JSONObject.

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

Asla geç kalmasan iyi olur. Serileştirilmiş bir listeye sahip olmak istiyorsanız, HashMap listesini dizeye dönüştürmek için GSON kullandım .

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

Bu jsonüretir[{"key":"value","key":"value","key":"value"}]

İşte GSON ile tek hat çözümüm:

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

Bu çözüm karmaşık JSON'larla çalışır:

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

Gson kullanıyoruz.

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

XStream kullanabilirsiniz - gerçekten kullanışlı. Buradaki örneklere bakın

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

    }

}

Kullanıyorsanız, içinde net.sf.json.JSONObjectbir JSONObject(map)kurucu bulamazsınız . public static JSONObject fromObject( Object object )Yöntemi kullanmalısınız . Bu yöntem JSON biçimli dizeleri, Haritalar, DynaBeans ve JavaBeans kabul eder.

JSONObject jsonObject = JSONObject.fromObject(myMap);

Karmaşık nesneler kullanıyorsanız, https://stackoverflow.com/a/24635655/2914140 ve https://stackoverflow.com/a/26374888/2914140 ' da belirtildiği gibi enableComplexMapKeySerialization () uygulamanız gerekir .

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

Çıktı:

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

Gson veya JSON ayrıştırma kitaplıklarına gerek yoktur. Sadece kullanarak new JSONObject(Map<String, JSONObject>).toString(), örneğin:

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

HashMap'e gerçekten ihtiyacınız yoksa, böyle bir şey yapabilirsiniz:

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

Çıktı:

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

Alibaba fastjson'u kullanıyorum, kolay ve basit:

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

ve içe aktar:

import com.alibaba.fastjson.JSON;

Sonra:

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

Her şey yolunda.

JSR 374: JSON İşleme için Java API (javax json) kullanıyorsanız Bu hile gibi görünüyor:

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

Gson'u kullanabilirsiniz . Bu kütüphane, Java nesnelerini JSON nesnelerine dönüştürmek için basit yöntemler sağlar.

Misal:

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

Varsayılandan farklı yapılandırma seçeneklerini ayarlamanız gerektiğinde bir GsonBuilder kullanabilirsiniz. Yukarıdaki örnekte, dönüştürme işlemi nesneden boş nitelikleri serileştirecektir.

Ancak, bu yaklaşım yalnızca jenerik olmayan tipler için geçerlidir. Genel türler için toJson (nesne, Tür) kullanmanız gerekir.

Gson hakkında daha fazla bilgi burada .

Nesnenin Serializable arabirimini uygulaması gerektiğini unutmayın .

bu benim için çalışıyor:

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

println new JsonBuilder(properties).toPrettyString()

Biraz kullanarak daha karmaşık haritalar ve listeler için GSON yolu TypeToken.getParameterized yöntem:

Şöyle bir haritamız var:

Map<Long, List<NewFile>> map;

Type'ı yukarıda belirtilen getParameterized yöntemini kullanarak şu şekilde elde ederiz:

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

Ve sonra bu gibi mapOfList nesnesini kullanarak Gson nesnesini fromJson yöntemini kullanın :

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

Bahsedilen NewFile nesnesi şöyle görünür:

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

Deserialized JSON şöyle görünür:

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

Selenyum'daki özel komutların Yanıtını serileştirirken benzer bir sorunla karşılaştım. Yanıt json'du, ancak selenyum bunu dahili olarak bir java.util.HashMap [String, Object] haline çevirir

Scala'yı biliyorsanız ve JSON için play-API'yi kullanıyorsanız, bundan faydalanabilirsiniz:

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

Küçük kod açıklaması:

Temel türler (String, Integer, Boolean) bulunana kadar kod, HashMap üzerinden özyinelemeli olarak geçer. Bu temel türler doğrudan bir JsObject içine sarılabilir. Özyineleme açıldığında, derinleştirme oluşturulan nesneleri birleştirir.

'@unchecked' tip silme uyarılarına dikkat eder.

Öncelikle tüm nesnelerinizi geçerli Dizelere dönüştürün

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

Ardından haritanın tamamını bir org.json.JSONObject dosyasına ekleyin

JSONObject postData = new JSONObject(params);

Artık sadece nesnenin toString'ini çağırarak JSON'u alabilirsiniz

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

Yeni bir JSONObject oluştur

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

Veya HTTP üzerinden göndermek için bir bayt dizisi olarak

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