जावा में हैशमैप को JSON ऑब्जेक्ट में कैसे बदलें


287

जावा में JSON ऑब्जेक्ट को हैशमैप कैसे करें या कैसे डालें, और फिर JSON ऑब्जेक्ट को JSON स्ट्रिंग में कैसे बदलें?

जवाबों:


435

आप उपयोग कर सकते हैं:

new JSONObject(map);

सावधानी: यह केवल एक के लिए काम करेगाMap<String, String>!

अन्य कार्य आप इसके प्रलेखन http://stleary.github.io/JSON-java/index.html से प्राप्त कर सकते हैं


85
यह केवल एक स्ट्रिंग, स्ट्रिंग मैप के लिए काम करता है न कि एक जटिल स्ट्रिंग, ऑब्जेक्ट।
slott

2
आप लगा रहे हैं Mapमें JSONObjectलेकिन तुम कैसे JSONObject से इस नक्शे मिल सकता है?
युबराज

1
@ युबी यह आपकी मदद कर सकता है: stackoverflow.com/questions/21720759/convert-jsonobject-to-map
हन्नून यासिर

8
@slott पुराने संस्करणों के लिए सही है। नया संस्करण किटकैट की तरह अधिक जटिल वस्तुओं के साथ ठीक काम कर रहा है, जैसे हैशपैम <स्ट्रींग, ऑब्जेक्ट> () जिसमें हैशपे <स्ट्रिंग, ऑब्जेक्ट> () ऑब्जेक्ट के रूप में है। तो मैं Gson सलाह देते हैं।
लूइस्मि

मैं बस इसे खोज रहा था
नावेद अहमद

169

मनमाने ढंग से जटिल वस्तुओं को क्रमबद्ध करने के लिए भी गन्स का उपयोग किया जा सकता है।

यहाँ आप इसका उपयोग कैसे करें:

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

Gsonस्वचालित रूप से संग्रह को JSONसरणियों में बदल देगा । गन्स निजी क्षेत्रों को क्रमबद्ध कर सकते हैं और स्वचालित रूप से क्षणिक क्षेत्रों की उपेक्षा कर सकते हैं।


1
नोट: यह शून्य मानों के साथ कुंजियों को संरक्षित नहीं करता है।
विकास

58

उदाहरण 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) );

उत्पादन ::

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

आप Google के GSON का उपयोग करने का भी प्रयास कर सकते हैं ।Google का GSON जावा ऑब्जेक्ट को उनके JSON प्रतिनिधित्व में परिवर्तित करने के लिए सर्वोत्तम लाइब्रेरी उपलब्ध है।

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


2
खुदाई के लिए खेद है लेकिन 2` 2में क्या करता है json.toString()
जैक

सार्वजनिक स्ट्रिंग स्ट्रिंग (int मूलांक) .toString (2) स्ट्रिंग प्रतिनिधित्व के लिए उपयोग किया जाता है। अधिक stackoverflow.com/questions/3615721/… के लिए
मोहम्मद हुसैन

11
यह कौन सा JSONObject वर्ग है?
Janus Troelsen

18
ऐसी कोई विधि नहीं: (new org.json.JSONObject ()) putAll ();
जोन

50

आप परिवर्तित कर सकते हैं Mapकरने के लिए JSONउपयोग करते हुए Jacksonइस प्रकार है:

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

के लिए मावेन निर्भरताएँ 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>

यदि आप JSONObjectपुस्तकालय का उपयोग कर रहे हैं , तो आप मानचित्र को JSONनिम्नानुसार परिवर्तित कर सकते हैं:

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

के लिए मावेन निर्भरताएँ JSONObject:

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

आशा है कि यह मदद करेगा। खुश कोडिंग।


1
पता नहीं था कि मैं मानचित्र को एक तर्क के रूप में पारित कर सकता हूं, धन्यवाद, बहुत मदद की।
गोरखा

@ गोरखा सराहना के लिए धन्यवाद।
अंकुर महाजन

1
@AnkurMahajan +1 निर्भरता के साथ उचित उत्तर देने के लिए :)
बैडमैन

1
स्ट्रिंग जोंस = नया ObjectMapper ()। writeValueAsString (मानचित्र); ग्रेटे
रोहित लूथरा

7

मेरे मामले में मुझे कोई निर्भरता नहीं चाहिए थी। Java 8 का उपयोग करके आप JSON को इस सरल स्ट्रिंग के रूप में प्राप्त कर सकते हैं:

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

2
आप बच नहीं रहे हैं ... यदि कुंजी या मान शामिल है ", तो यह टूट जाता है
जानुस ट्रेलसेन

आप सही हैं, इस समाधान में कुछ सीमाएँ हैं, नेस्टेड नक्शे भी समर्थित नहीं हैं
एंड्री सरुल

7

आप बस नक्शे में गणना कर सकते हैं और JSONObject में मुख्य-मूल्य जोड़े जोड़ सकते हैं

तरीका :

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

1
बिना किसी अतिरिक्त पुस्तकालय के कोई शॉर्टकट और प्रभावी ढंग से काम करना
Maveň '

Map.Entry <K, V >> entrySet () नक्शे के पुनरावृत्ति के लिए है। कुंजियों को पढ़ना और प्रत्येक कुंजी के लिए मानचित्र की खोज करना एक उप-तरीका है।
मार्टिन

7

अंडरस्कोर-जावा लाइब्रेरी हैश मैप या एरे लिस्ट को जसन और वाइस वर्जन में बदल सकती है।

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

5

पार्टी में देर हो रही है लेकिन यहाँ मेरा GSON है को क्रमबद्ध करने के लिए एडहॉक लेखक है। मुझे json स्ट्रिंग विशेषताओं के रूप में मुख्य-मूल्य वाले जोड़े के मानचित्र लिखना था, एक पूर्णांक प्रकार के होने की उम्मीद थी। मैं इस सरल usecase के लिए कस्टम जावाबीन आवरण बनाना नहीं चाहता था।

GSON JsonWriter वर्ग कुछ दृढ़ता से टाइप किए गए लेखक.वल्यू () फ़ंक्शंस वाले सीरलाइज़र वर्ग का उपयोग करना आसान है।

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

यदि कोई भी कस्टम प्रकार की आवश्यकता नहीं है, तो मैं सिर्फ toson () फ़ंक्शन का उपयोग कर सकता हूं। gson-2.2.4.jar पुस्तकालय बिना किसी क्रूर निर्भरता के 190KB के अंतर्गत है। बड़े फ्रेमवर्क एकीकरण के बिना किसी भी कस्टम सर्वलेट ऐप या स्टैंडअलोन एप्लिकेशन पर उपयोग करना आसान है।

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

4

यह आमतौर पर एक Json लाइब्रेरी का काम है, आपको इसे स्वयं करने का प्रयास नहीं करना चाहिए। सभी json पुस्तकालयों को लागू करना चाहिए जो आप पूछ रहे हैं, और आप पृष्ठ के निचले भाग में json.org पर Java Json पुस्तकालयों की सूची पा सकते हैं ।


4

मुझे इसे संभालने का एक और तरीका मिला।

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

उम्मीद है की यह मदद करेगा।

धन्यवाद।


3

यदि आपको कोड में इसका उपयोग करने की आवश्यकता है।

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

3

उपयोग करने वालों के लिए org.json.simple.JSONObject, आप मैप को Json स्ट्रिंग में परिवर्तित कर सकते हैं और इसे प्राप्त करने के लिए पार्स कर सकते हैं JSONObject

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

3

बेहतर है कि कभी देर न करें। यदि आप सिलसिलेवार सूची रखना चाहते हैं तो मैंने जीएएसएन का उपयोग हैशपॉप की सूची को स्ट्रिंग में बदलने के लिए किया।

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

यह jsonपैदा करता है[{"key":"value","key":"value","key":"value"}]


इस सवाल का जवाब नहीं है। यह JSON सरणी का निर्माण कर रहा है, JSON ऑब्जेक्ट का नहीं। और किसी और ने हमें पहले ही दिखाया है कि कैसे एक हैशमैप का उपयोग करके JSON ऑब्जेक्ट बनाया जाए Gson
स्टीफन सी

हाय @StephenC, कुछ JSON ऑब्जेक्ट के बजाय JSON सरणी के उदाहरण की तलाश कर सकते हैं क्योंकि शीर्ष टिप्पणी पहले से ही अब तक का सबसे अच्छा जवाब प्रदान करती है। मुझे उम्मीद है कि हम जीएसओएन का उपयोग करते हुए धारावाहिक से संबंधित अन्य उत्तर प्रदान कर सकते हैं। मेरी क्षमायाचना, यह उत्तर एक अलग सूत्र पर पोस्ट किया जाना चाहिए।
केली बडोल

हमें उन लोगों के लिए उत्तर लिखना चाहिए जो ठीक से खोज करते हैं। यदि हम उन लोगों के लिए पूरा करने का प्रयास करते हैं जो ऑफ-टॉपिक उत्तर पोस्ट करके खोज नहीं कर सकते हैं, तो यह साइट को "शोर" से हटा देता है, और उन लोगों के लिए कठिन बनाता है जो प्रासंगिक उत्तर खोजने के लिए खोज करना जानते हैं । यदि आप (अब) सहमत हैं कि यह उत्तर गलत जगह पर है, तो कृपया इसे हटा दें।
स्टीफन सी

1
@KellyBudol अच्छा या बुरा, आपका जवाब है कि मैं क्या देख रहा हूँ। धन्यवाद मैन
vd

2

यहाँ GSON के साथ मेरा सिंगल-लाइन समाधान:

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

2

यह समाधान जटिल JSONs के साथ काम करता है:

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


1

आप XStream का उपयोग कर सकते हैं - यह वास्तव में आसान है। यहां उदाहरण देखें

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

    }

}

लेकिन आपको अपनी एक्सस्ट्रीम वस्तु को किसी को भी कैश करना चाहिए
जोस्ट

1

यदि आप उपयोग कर रहे हैं net.sf.json.JSONObjectतो आपको JSONObject(map)इसमें कंस्ट्रक्टर नहीं मिलेगा । आपको public static JSONObject fromObject( Object object )विधि का उपयोग करना होगा । यह विधि JSON के स्वरूपित स्ट्रिंग्स, मैप्स, डायनाबीन्स और JavaBeans को स्वीकार करती है।

JSONObject jsonObject = JSONObject.fromObject(myMap);


1

यदि आप जटिल वस्तुओं का उपयोग करते हैं, तो आपको https://ComxxflowKeySerialization () , जैसा कि https://stackoverflow.com/a/24635655/2914140 और https://stackoverflow.com/a/26374648/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));

आउटपुट होगा:

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

1

GSON या JSON पार्सिंग लाइब्रेरी की कोई आवश्यकता नहीं है। बस का उपयोग कर new JSONObject(Map<String, JSONObject>).toString(), जैसे:

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

अपवादों को निगलना और खाली वस्तु वापस करना एक बुरा विचार है।
स्टीफन सी

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

यह केवल पहले वाला उत्तर दोहरा रहा है।
स्टीफन सी

1

अगर आपको वास्तव में हाशपा की जरूरत नहीं है तो आप ऐसा कुछ कर सकते हैं:

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

आउटपुट:

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

सही है। हालाँकि, सवाल JSON ऑब्जेक्ट को बनाने का एक तरीका पूछता हैHashMap , और यह उत्तर नहीं देता है।
स्टीफन सी।

कुछ लोग एक सामान्य समाधान की तलाश में Google से यहां उतर सकते हैं। उपरोक्त उत्तर उनकी मदद कर सकता है।
रफाल एंडेन

1

मैं अलीबाबा तेज, आसान और सरल का उपयोग कर रहा हूँ:

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

और आयात:

import com.alibaba.fastjson.JSON;

फिर:

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

सब कुछ ठीक है।


1

यदि आप JSR 374 का उपयोग कर रहे हैं: JSON प्रसंस्करण के लिए जावा एपीआई (javax json) यह चाल करने के लिए लगता है:

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

0

आप Gson का उपयोग कर सकते हैं । यह लाइब्रेरी जावा ऑब्जेक्ट्स को JSON ऑब्जेक्ट्स में बदलने के लिए सरल तरीके प्रदान करती है और इसके विपरीत।

उदाहरण:

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

जब आप डिफ़ॉल्ट के अलावा कॉन्फ़िगरेशन विकल्प सेट करने की आवश्यकता होती है तो आप GsonBuilder का उपयोग कर सकते हैं। उपरोक्त उदाहरण में, रूपांतरण प्रक्रिया ऑब्जेक्ट से अशक्त विशेषताओं को अनुक्रमित भी करेगी।

हालांकि, यह दृष्टिकोण केवल गैर-सामान्य प्रकारों के लिए काम करता है। जेनेरिक प्रकारों के लिए आपको toson (ऑब्जेक्ट, टाइप) का उपयोग करने की आवश्यकता होती है।

Gson के बारे में अधिक जानकारी यहाँ

याद रखें कि ऑब्जेक्ट को Serializable इंटरफ़ेस को लागू करना होगा ।


0

यह मेरे लिए काम करता है:

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

println new JsonBuilder(properties).toPrettyString()

1
यह एक ग्रूवी प्रश्न नहीं है।
स्टीफन सी

@ स्टीफन-सी जावा सिर्फ भाषा नहीं बल्कि एक मंच है, सिर्फ एक जार है।
जियाउत

आपके प्रश्न का कोड जावा नहीं है। यदि वह कोड वास्तव में आपके लिए काम करता है तो आप जावा का उपयोग नहीं कर रहे हैं। जावा में "प्रिंटलाइन" कथन नहीं है, और आप इस तरह एक चर घोषित नहीं कर सकते। मेरा अनुमान है कि आप ग्रूवी का उपयोग कर रहे हैं, लेकिन मुझे यकीन नहीं है। किसी भी तरह से, जावा कोड में जावा पुस्तकालयों के बजाय ग्रूवी पुस्तकालयों का उपयोग करने के लिए लोगों की सिफारिश करना ... एक अच्छा विचार नहीं है।
स्टीफन सी

0

थोड़ा और अधिक जटिल मानचित्रों के लिए रास्ता टाइप करें और TypeToken.getParameterized का उपयोग करके सूचीबद्ध करें करें।

हमारे पास एक नक्शा है जो इस तरह दिखता है:

Map<Long, List<NewFile>> map;

हम इस तरह के उपरोक्त getParameterized विधि का उपयोग कर प्रकार प्राप्त करते हैं :

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

और फिर Gson वस्तु का उपयोग fromJson का उपयोग कर इस तरह विधि mapOfList इस तरह वस्तु:

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

उल्लिखित वस्तु न्यूफ़ाइल इस प्रकार है:

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 इस तरह दिखता है:

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


-1

सेलेनियम में कस्टम कमांड्स से रिस्पॉन्स को डिसेररलाइज़ करते समय मुझे इसी तरह की समस्या का सामना करना पड़ा। प्रतिक्रिया जौनसारी थी, लेकिन सेलेनियम आंतरिक रूप से एक java.util में अनुवाद करता है। हाशपा [स्ट्रिंग, ऑब्जेक्ट]

यदि आप scala से परिचित हैं और JSON के लिए play-API का उपयोग करते हैं, तो आपको इससे लाभ हो सकता है:

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

छोटे कोड का विवरण:

जब तक बुनियादी प्रकार (स्ट्रिंग, इंटेगर, बुलियन) पाए जाते हैं तब तक कोड हैशमैप के माध्यम से पुन: प्राप्त होता है। इन बुनियादी प्रकारों को सीधे JsObject में लपेटा जा सकता है। जब पुनरावृत्ति सामने आती है, तो गहरी निर्मित वस्तुओं को समाप्‍त कर देता है।

'@unchecked' टाइप इरेज़र चेतावनियों का ध्यान रखता है।


यह एक स्काला प्रश्न नहीं है
स्टीफन सी

-1

सबसे पहले अपनी सभी वस्तुओं को वैध स्ट्रिंग्स में परिवर्तित करें

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

फिर एक org.json.JSONObject में पूरा नक्शा डालें

JSONObject postData = new JSONObject(params);

अब आप केवल ऑब्जेक्ट के इनस्ट्रिंग को कॉल करके JSON प्राप्त कर सकते हैं

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

एक नया JSONObject बनाएँ

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

या HTTP पर भेजने के लिए बाइट सरणी के रूप में

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

यह वही बात कह रहा है जो पिछले वर्षों से पहले की है, बिना संक्षिप्त लाभ के।
स्टीफन सी।

@StephenC मुझे नहीं पता कि आप किस बारे में हैं
G_V

@StephenC "जावा में JSON ऑब्जेक्ट में हैशमैप कैसे कन्वर्ट या कास्ट करें, और फिर JSON स्ट्रिंग को JSON स्ट्रिंग में कनवर्ट करें?"
G_V

362 लोग (और गिनती) सोचते हैं कि stackoverflow.com/a/12155874/139985 सवाल का जवाब देता है। यह मूल रूप से कहता है कि आपके उत्तर में फ्रिली बिट्स के बिना क्या कहा गया है।
स्टीफन सी
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.