JSON रूपांतरण के दौरान JSON कुंजियों के क्रम को CSV में रखें

Question 1

मैं यहाँ उपलब्ध JSON लाइब्रेरी का उपयोग कर रहा हूँ, http://www.json.org/java/index.html एक CS स्ट्रिंग जो मुझे CSV में बदलना है। लेकिन मेरे पास जो समस्या है, रूपांतरण के बाद चाबियों का क्रम खो गया है।

यह रूपांतरण कोड है:

    JSONObject jo = new JSONObject(someString);
    JSONArray ja = jo.getJSONArray("items");
    String s = CDL.toString(ja);
    System.out.println(s);

यह "someString" की सामग्री है:

{
    "items":
    [
        {
            "WR":"qwe",
            "QU":"asd",
            "QA":"end",
            "WO":"hasd",
            "NO":"qwer"
        },
    ]
}

यह परिणाम है:

WO,QU,WR,QA,NO
hasd,asd,qwe,end,qwer

जबकि मुझे उम्मीद है कि चाबियों के क्रम को बनाए रखना है:

WR,QU,QA,WO,NO
qwe,asd,end,hasd,qwer

क्या इस पुस्तकालय का उपयोग करने का कोई परिणाम हो सकता है? यदि नहीं, तो क्या कोई अन्य पुस्तकालय है जो परिणाम में चाबियों के क्रम को रखने की क्षमता प्रदान करेगा?

Question 2

इसे करने के तरीके (हैक) हैं ... लेकिन आपको ऐसा नहीं करना चाहिए।

JSON में, एक ऑब्जेक्ट इस प्रकार परिभाषित किया गया है:

ऑब्जेक्ट नाम / मान जोड़े का एक अनियंत्रित सेट है।

Http://json.org देखें ।

JSON के अधिकांश कार्यान्वयन किसी ऑब्जेक्ट के नाम / मूल्य जोड़े के आदेश को संरक्षित करने का कोई प्रयास नहीं करते हैं, क्योंकि यह (परिभाषा के अनुसार) महत्वपूर्ण नहीं है।

यदि आप चाहते हैं कि ऑर्डर संरक्षित हो, तो आपको अपनी डेटा संरचना को फिर से परिभाषित करने की आवश्यकता है; जैसे

{
    "items":
    [
        [
            {"WR":"qwe"},
            {"QU":"asd"},
            {"QA":"end"},
            {"WO":"hasd"},
            {"NO":"qwer"}
        ],
    ]
}

या अधिक बस:

{
    "items":
    [
        {"WR":"qwe"},
        {"QU":"asd"},
        {"QA":"end"},
        {"WO":"hasd"},
        {"NO":"qwer"}
    ]
}

जाँच करना

जानकारी के लिए धन्यवाद, लेकिन मेरे पास JSON का उपयोग करने के अलावा और कोई विकल्प नहीं है और मेरे आवेदन में JSON ऑब्जेक्ट की परिभाषा की परवाह किए बिना कुंजी के क्रम को बनाए रखने की आवश्यकता है ... मुझे JSON फ़ाइल का प्रारूप बदलने की अनुमति नहीं है भी...

आपको उस फ़ाइल संरचना को डिज़ाइन करने वाले के साथ एक कठिन वार्तालाप करने की आवश्यकता है और आपको इसे बदलने नहीं देगा। यह है / वे सादे गलत हैं। आपको उन्हें मनाने की जरूरत है।

यदि वे वास्तव में आपको इसे बदलने नहीं देंगे:

आपको इसे JSON नहीं कहने पर जोर देना चाहिए ... 'क्योंकि यह नहीं है।
आपको यह इंगित करना चाहिए कि आपको इस "नहीं JSON" प्रारूप को संभालने के लिए विशेष रूप से कोड लिखना / संशोधित करना होगा ... जब तक कि आप कुछ JSON कार्यान्वयन नहीं पा सकते हैं जो आदेश को संरक्षित करता है। यदि वे एक भुगतान करने वाले ग्राहक हैं, तो सुनिश्चित करें कि वे इस अतिरिक्त काम के लिए भुगतान करते हैं जो आपको करना है।
आपको यह इंगित करना चाहिए कि यदि "JSON नहीं" को किसी अन्य उपकरण द्वारा उपयोग करने की आवश्यकता है, तो यह समस्याग्रस्त होने वाला है। दरअसल, यह समस्या बार-बार आएगी ...

इस तरह की बात वास्तव में बुरी है। एक ओर, आपका सॉफ़्टवेयर एक अच्छी तरह से स्थापित / लंबे समय तक चलने वाले विनिर्देश का उल्लंघन कर रहा होगा, जिसे इंटरऑपरेबिलिटी को बढ़ावा देने के लिए डिज़ाइन किया गया है। दूसरी ओर, नाइट-विट्स जिन्होंने इस लंगड़े को डिज़ाइन किया है (JSON नहीं!) फ़ाइल प्रारूप संभवतः अन्य लोगों के सिस्टम आदि को बंद कर रहे हैं 'क्योंकि सिस्टम उनकी बकवास का सामना नहीं कर सकता है ।

अपडेट करें

यह भी पढ़ने योग्य है कि JSON RFC (RFC 7159) इस विषय पर क्या कहता है। यहाँ कुछ अंश दिए गए हैं:

RFC 4627 के प्रकाशन के बाद के वर्षों में, JSON ने बहुत व्यापक उपयोग पाया है। इस अनुभव से कुछ प्रतिमानों का पता चला है, जो इसकी विशिष्टताओं द्वारा अनुमति देते समय, अंतर-समस्या का कारण बने हैं।

जावास्क्रिप्ट ऑब्जेक्ट नोटेशन (JSON) संरचित डेटा के क्रमांकन के लिए एक पाठ प्रारूप है। ...

JSON चार आदिम प्रकारों (तारों, संख्याओं, बूलियन और नल) और दो संरचित प्रकारों (वस्तुओं और गिरफ्तारियों) का प्रतिनिधित्व कर सकता है।

एक वस्तु शून्य या अधिक नाम / मूल्य जोड़े का एक अनियोजित संग्रह है, जहां एक नाम एक स्ट्रिंग है और एक मूल्य एक स्ट्रिंग, संख्या, बूलियन, अशक्त, वस्तु या सरणी है।

JSON पार्सिंग पुस्तकालयों में यह देखा गया है कि वे कॉलिंग सॉफ्टवेयर में दिखाई देने वाली वस्तु सदस्यों के क्रम को बनाते हैं या नहीं। कार्यान्वयन जिनका व्यवहार सदस्य के आदेश पर निर्भर नहीं करता है, इस अर्थ में अंतर होगा कि वे इन अंतरों से प्रभावित नहीं होंगे।

Question 3

आदेश को बनाए रखना काफी सरल है। मुझे DB लेयर से UI लेयर तक ऑर्डर बनाए रखने में समान समस्या थी।

JSONObject.java फ़ाइल खोलें। यह आंतरिक रूप से HashMap का उपयोग करता है जो आदेश को बनाए नहीं रखता है।

इसे LinkedHashMap में बदलें:

    //this.map = new HashMap();
    this.map = new LinkedHashMap();

इसने मेरे लिए काम किया। टिप्पणियों में क्या है मुझे जानने दें। मेरा सुझाव है कि JSON लाइब्रेरी में एक और JSONObject क्लास होनी चाहिए जो JSONOrderdObject.java की तरह ऑर्डर बनाए रखे। मैं नाम चुनने में बहुत गरीब हूं।

Question 4

JSONObject.javaजो भी नक्शा पास करवा लो। यह हो सकता है LinkedHashMapया TreeMapयह hashmapकेवल तभी लेगा जब नक्शा अशक्त होगा।

यहां JSONObject.javaक्लास का कंस्ट्रक्टर है जो मैप की चेकिंग करेगा।

 public JSONObject(Map paramMap)
  {
    this.map = (paramMap == null ? new HashMap() : paramMap);
  }

इसलिए एक जसन ऑब्जेक्ट कंस्ट्रक्शन बनाने से पहले LinkedHashMapऔर फिर उसे कंस्ट्रक्टर को इस तरह से पास करें,

LinkedHashMap<String, String> jsonOrderedMap = new LinkedHashMap<String, String>();

jsonOrderedMap.put("1","red");
jsonOrderedMap.put("2","blue");
jsonOrderedMap.put("3","green");

JSONObject orderedJson = new JSONObject(jsonOrderedMap);

JSONArray jsonArray = new JSONArray(Arrays.asList(orderedJson));

System.out.println("Ordered JSON Fianl CSV :: "+CDL.toString(jsonArray));

इसलिए JSONObject.javaकक्षा को बदलने की कोई आवश्यकता नहीं है । आशा है कि यह किसी की मदद करता है।

Question 5

इस तरह की समस्या के लिए एक अधिक क्रिया, लेकिन मोटे तौर पर लागू समाधान डेटा संरचनाओं की एक जोड़ी का उपयोग करना है: आदेश को समाहित करने के लिए एक सूची, और संबंधों को शामिल करने के लिए एक नक्शा।

उदाहरण के लिए:

{
    "items":
    [
        {
            "WR":"qwe",
            "QU":"asd",
            "QA":"end",
            "WO":"hasd",
            "NO":"qwer"
        },
    ],
    "itemOrder":
        ["WR", "QU", "QA", "WO", "NO"]
}

आप आइटमऑडर सूची को पुनरावृत्त करते हैं, और मानचित्र मानों को देखने के लिए उन का उपयोग करते हैं। ऑर्डरिंग संरक्षित है, जिसमें कोई कीचड़ नहीं है।

मैंने इस विधि का कई बार उपयोग किया है।

Question 6

प्रतिबिंबित का उपयोग कर एक और हैकी समाधान:

JSONObject json = new JSONObject();
Field map = json.getClass().getDeclaredField("map");
map.setAccessible(true);//because the field is private final...
map.set(json, new LinkedHashMap<>());
map.setAccessible(false);//return flag

Question 7

अपाचे विंक ने ऑर्डर कियाजॉनऑब्जेक्ट । यह स्ट्रिंग को पार्स करते समय आदेश रखता है।

Question 8

बस एक ही समस्या पर ठोकर खाई, मुझे विश्वास है कि लेखक द्वारा उपयोग किया जाने वाला अंतिम समाधान एक कस्टम कंटेनर का उपयोग करने में शामिल है:

public static Values parseJSONToMap(String msgData) {
    JSONParser parser = new JSONParser();
    ContainerFactory containerFactory = new ContainerFactory(){
        @Override
        public Map createObjectContainer() {
            return new LinkedHashMap();
        }

        @Override
        public List creatArrayContainer() {
            return null;
        }
    };
    try {
        return (Map<String,Object>)parser.parse(msgData, containerFactory);
    } catch (ParseException e) {
        log.warn("Exception parsing JSON string {}", msgData, e);
    }
    return null;
}

http://juliusdavies.ca/json-simple-1.1.1-javadocs/org/json/simple/parser/JSONParser.html#parse(java.io.eader.org.jim.simple.parser.ContainerFactory) देखें

Question 9

हल किया।

मैंने यहां से JSON.simple लाइब्रेरी का उपयोग किया। https://code.google.com/p/json-simple/ ने चाबियाँ के क्रम को बनाए रखने के लिए JSON स्ट्रिंग को पढ़ने के लिए और यहाँ से JavaCSV लाइब्रेरी का उपयोग करने के लिए http://sourceforge.net/ परियोजनाओं / javacsv / सीएसवी प्रारूप में परिवर्तित करने के लिए।

Question 10

मुझे पता है कि यह हल हो गया है और यह सवाल बहुत समय पहले पूछा गया था, लेकिन जैसा कि मैं एक समान समस्या से निपट रहा हूं, मैं इस पर पूरी तरह से अलग दृष्टिकोण देना चाहूंगा:

सरणियों के लिए यह कहता है "एक सरणी मूल्यों का एक संग्रहित संग्रह है।" पर http://www.json.org/ - लेकिन वस्तुओं ( "एक वस्तु नाम / मान युग्म के एक अव्यवस्थित सेट है।") का आदेश दिया नहीं कर रहे हैं।

मुझे आश्चर्य है कि वह वस्तु एक सरणी में क्यों है - इसका तात्पर्य एक आदेश है जो वहां नहीं है।

{
"items":
[
    {
        "WR":"qwe",
        "QU":"asd",
        "QA":"end",
        "WO":"hasd",
        "NO":"qwer"
    },
]
}

तो एक समाधान के लिए एक "वास्तविक" सरणी में चाबियाँ डाल दिया जाएगा और इस तरह से प्रत्येक कुंजी के लिए वस्तुओं के रूप में डेटा जोड़ना होगा:

{
"items":
[
    {"WR": {"data": "qwe"}},
    {"QU": {"data": "asd"}},
    {"QA": {"data": "end"}},
    {"WO": {"data": "hasd"}},
    {"NO": {"data": "qwer"}}
]
}

तो यह एक दृष्टिकोण है जो मूल मॉडलिंग और उसके इरादे पर पुनर्विचार करने की कोशिश करता है। लेकिन मैंने परीक्षण नहीं किया है (और मुझे आश्चर्य है) यदि सभी शामिल उपकरण उस मूल JSON सरणी के आदेश को संरक्षित करेंगे।

Question 11

वास्तविक दुनिया में, एक एप्लिकेशन के पास लगभग हमेशा जावा बीन या डोमेन होगा जो JSON द्वारा क्रमबद्ध / डी-क्रमांकित / किया जाना है। इसका पहले से ही उल्लेख है कि JSON ऑब्जेक्ट विनिर्देश आदेश की गारंटी नहीं देता है और उस व्यवहार में किसी भी हेरफेर की आवश्यकता को उचित नहीं ठहराता है। मेरे आवेदन में मेरे पास वही परिदृश्य था जहाँ मुझे पठनीयता के उद्देश्य के लिए आदेश को संरक्षित करने की आवश्यकता थी। मैंने अपने जावा बीन को JSON में क्रमबद्ध करने के लिए मानक जैक्सन तरीके का उपयोग किया:

Object object = getObject();  //the source java bean that needs conversion
String jsonString = new com.fasterxml.jackson.databind.ObjectMapper().writeValueAsString(object);

तत्वों के एक निर्धारित सेट के साथ जसन बनाने के लिए मैं सिर्फ जावा बीन में रूपांतरण के लिए उपयोग किए जाने वाले JSON संपत्ति एनोटेशन का उपयोग करता हूं। नीचे एक उदाहरण:

@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonPropertyOrder({"name","phone","city","id"})
public class SampleBean implements Serializable {
    private int id;
    private String name:
    private String city;
    private String phone;

    //...standard getters and setters
}

getObject () ऊपर प्रयोग किया जाता है:

public SampleBean getObject(){
    SampleBean bean  = new SampleBean();
    bean.setId("100");
    bean.setName("SomeName");
    bean.setCity("SomeCity");
    bean.setPhone("1234567890");
    return bean;
}

JSON प्रॉपर्टी ऑर्डर एनोटेशन के अनुसार आउटपुट दिखाता है:

{
    name: "SomeName",
    phone: "1234567890",
    city: "SomeCity",
    id: 100
}

Question 12

सबसे सुरक्षित तरीका संभवतः कुंजी विधि है जो आउटपुट उत्पन्न करने के लिए उपयोग किया जाता है:

new JSONObject(){
  @Override
  public Iterator keys(){
    TreeSet<Object> sortedKeys = new TreeSet<Object>();
    Iterator keys = super.keys();
    while(keys.hasNext()){
      sortedKeys.add(keys.next());
    }
    return sortedKeys.iterator();
  }
};

Question 13

पैचफ़ॉर (उत्तर @gary):

$ git diff JSONObject.java                                                         
diff --git a/JSONObject.java b/JSONObject.java
index e28c9cd..e12b7a0 100755
--- a/JSONObject.java
+++ b/JSONObject.java
@@ -32,7 +32,7 @@ import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.Collection;
 import java.util.Enumeration;
-import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.Iterator;
 import java.util.Locale;
 import java.util.Map;
@@ -152,7 +152,9 @@ public class JSONObject {
      * Construct an empty JSONObject.
      */
     public JSONObject() {
-        this.map = new HashMap<String, Object>();
+//      this.map = new HashMap<String, Object>();
+        // I want to keep order of the given data:
+        this.map = new LinkedHashMap<String, Object>();
     }

     /**
@@ -243,7 +245,7 @@ public class JSONObject {
      * @throws JSONException
      */
     public JSONObject(Map<String, Object> map) {
-        this.map = new HashMap<String, Object>();
+        this.map = new LinkedHashMap<String, Object>();
         if (map != null) {
             Iterator<Entry<String, Object>> i = map.entrySet().iterator();
             while (i.hasNext()) {

Question 14

आप निम्नलिखित कोड का उपयोग कर सकते हैं कस्टम क्रमबद्ध क्रमांकन और JSON एरे के deserialization (यह उदाहरण मानता है कि आप स्ट्रिंग्स का आदेश दे रहे हैं लेकिन सभी प्रकारों पर लागू किया जा सकता है):

क्रमबद्धता

JSONArray params = new JSONArray();
int paramIndex = 0;

for (String currParam : mParams)
{
    JSONObject paramObject = new JSONObject();
    paramObject.put("index", paramIndex);
    paramObject.put("value", currParam);

    params.put(paramObject);
    ++paramIndex;
}

json.put("orderedArray", params);

अक्रमांकन

JSONArray paramsJsonArray = json.optJSONArray("orderedArray");
if (null != paramsJsonArray)
{
    ArrayList<String> paramsArr = new ArrayList<>();
    for (int i = 0; i < paramsJsonArray.length(); i++)
    {
        JSONObject param = paramsJsonArray.optJSONObject(i);
        if (null != param)
        {
            int paramIndex = param.optInt("index", -1);
            String paramValue = param.optString("value", null);

            if (paramIndex > -1 && null != paramValue)
            {
                paramsArr.add(paramIndex, paramValue);
            }
        }
    }
}

Question 15

आपका उदाहरण:

{
    "items":
    [
        {
            "WR":"qwe",
            "QU":"asd",
            "QA":"end",
            "WO":"hasd",
            "NO":"qwer"
        },
        ...
    ]
}

एक तत्व जोड़ें "आइटमऑर्डर"

{
    "items":
    [
        {
            "WR":"qwe",
            "QU":"asd",
            "QA":"end",
            "WO":"hasd",
            "NO":"qwer"
        },
        ...
    ],
    "itemorder":["WR","QU","QA","WO","NO"]
}

यह कोड कॉलम शीर्षक लाइन के बिना वांछित आउटपुट उत्पन्न करता है:

JSONObject output = new JSONObject(json);
JSONArray docs = output.getJSONArray("data");
JSONArray names = output.getJSONArray("itemOrder");
String csv = CDL.toString(names,docs);

Question 16

बजाय jsonObject का उपयोग करने के बजाय CsvSchema का उपयोग करके अपने तरीके को आसान बनाने और सीधे ऑब्जेक्ट को सीएसवी में कनवर्ट करने का प्रयास करें

CsvSchema schema = csvMapper.schemaFor(MyClass.class).withHeader();
        csvMapper.writer(schema).writeValueAsString(myClassList);

और इसमें उस ऑर्डर आईडी का उल्लेख किया गया है जिसमें आपके पूजो में @JsonPropertyOrder है

Question 17

अंडरस्कोर-जावा जावा पढ़ते समय तत्वों के लिए आदेश रखता है। मैं परियोजना का अनुरक्षक हूं।

String json = "{\n"
      + "    \"items\":\n"
      + "    [\n"
      + "        {\n"
      + "            \"WR\":\"qwe\",\n"
      + "            \"QU\":\"asd\",\n"
      + "            \"QA\":\"end\",\n"
      + "            \"WO\":\"hasd\",\n"
      + "            \"NO\":\"qwer\"\n"
      + "        }\n"
      + "    ]\n"
      + "}";
System.out.println(U.fromJson(json));

// {items=[{WR=qwe, QU=asd, QA=end, WO=hasd, NO=qwer}]}

Question 18

विंक समाधान का परीक्षण किया, और ठीक काम कर रहा है:

@Test
public void testJSONObject() {
    JSONObject jsonObject = new JSONObject();
    jsonObject.put("bbb", "xxx");
    jsonObject.put("ccc", "xxx");
    jsonObject.put("aaa", "xxx");
    jsonObject.put("xxx", "xxx");
    System.out.println(jsonObject.toString());
    assertTrue(jsonObject.toString().startsWith("{\"xxx\":"));
}

@Test
public void testWinkJSONObject() throws JSONException {
    org.apache.wink.json4j.JSONObject jsonObject = new OrderedJSONObject();
    jsonObject.put("bbb", "xxx");
    jsonObject.put("ccc", "xxx");
    jsonObject.put("aaa", "xxx");
    jsonObject.put("xxx", "xxx");
    assertEquals("{\"bbb\":\"xxx\",\"ccc\":\"xxx\",\"aaa\":\"xxx\",\"xxx\":\"xxx\"}", jsonObject.toString());
}