Giữ thứ tự của các khóa JSON trong quá trình chuyển đổi JSON thành CSV

Tôi đang sử dụng thư viện JSON được cung cấp tại đây http://www.json.org/java/index.html để chuyển đổi chuỗi json mà tôi có thành CSV. Nhưng vấn đề tôi gặp phải là, thứ tự của các phím bị mất sau khi chuyển đổi.

Đây là mã chuyển đổi:

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

Đây là nội dung của "someString":

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

Đây là kết quả:

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

Trong khi những gì tôi mong đợi là giữ thứ tự của các phím:

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

Có cách nào tôi có thể có kết quả này bằng cách sử dụng thư viện này không? Nếu không, có thư viện nào khác sẽ cung cấp khả năng giữ thứ tự các khóa trong kết quả không?

Có nhiều cách (hacky) để làm điều đó ... nhưng bạn không nên.

Trong JSON, một đối tượng được định nghĩa như vậy:

Một đối tượng là một tập hợp các cặp tên / giá trị không có thứ tự.

Xem http://json.org .

Hầu hết các triển khai JSON đều không cố gắng duy trì thứ tự của các cặp tên / giá trị của một đối tượng, vì nó (theo định nghĩa) không đáng kể.

Nếu bạn muốn thứ tự được giữ nguyên, bạn cần xác định lại cấu trúc dữ liệu của mình; ví dụ

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

hoặc đơn giản hơn:

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

THEO SÁT

Cảm ơn bạn đã cung cấp thông tin, nhưng tôi không có lựa chọn nào khác ngoài việc sử dụng JSON trong ứng dụng của mình và ứng dụng của tôi cần giữ thứ tự của các khóa bất kể định nghĩa của đối tượng JSON là gì ... Tôi không được phép thay đổi định dạng của tệp JSON cũng...

Bạn cần có một cuộc trò chuyện khó khăn với người đã thiết kế cấu trúc tệp đó và sẽ không cho phép bạn thay đổi cấu trúc đó. Đó là / họ rõ ràng là sai. Bạn cần thuyết phục họ.

Nếu họ thực sự không cho phép bạn thay đổi nó:

• Bạn nên kiên quyết không gọi nó là JSON ... 'vì nó không phải vậy.
• Bạn nên chỉ ra rằng bạn sẽ phải viết / sửa đổi mã đặc biệt để xử lý định dạng "không phải JSON" này ... trừ khi bạn có thể tìm thấy một số triển khai JSON duy trì thứ tự. Nếu họ là khách hàng trả tiền, hãy đảm bảo rằng họ trả tiền cho công việc bạn phải làm.
• Bạn nên chỉ ra rằng nếu "không phải JSON" cần được sử dụng bởi một số công cụ khác, thì nó sẽ có vấn đề. Thật vậy, vấn đề này sẽ xảy ra lặp đi lặp lại ...

Loại điều này thực sự tồi tệ. Một mặt, phần mềm của bạn sẽ vi phạm đặc điểm kỹ thuật lâu đời / đã được thiết lập tốt được thiết kế để thúc đẩy khả năng tương tác. Mặt khác, các nit-wits đã thiết kế định dạng tệp khập khiễng này (không phải JSON!) Có thể đang xỉa xói hệ thống của người khác, v.v. vì hệ thống không thể đối phó với những điều vô nghĩa của chúng .

CẬP NHẬT

Nó cũng đáng đọc những gì JSON RFC (RFC 7159) nói về chủ đề này. Dưới đây là một số đoạn trích:

Trong những năm kể từ khi xuất bản RFC 4627, JSON đã được sử dụng rất rộng rãi. Trải nghiệm này đã tiết lộ một số mẫu nhất định, mặc dù được thông số kỹ thuật cho phép, nhưng đã gây ra các vấn đề về khả năng tương tác.

JavaScript Object Notation (JSON) là một định dạng văn bản để tuần tự hóa dữ liệu có cấu trúc. ...

JSON có thể đại diện cho bốn kiểu nguyên thủy (chuỗi, số, boolean và null) và hai kiểu có cấu trúc (đối tượng và mảng).

Đối tượng là một tập hợp không có thứ tự gồm không hoặc nhiều cặp tên / giá trị, trong đó tên là một chuỗi và một giá trị là một chuỗi, số, boolean, null, đối tượng hoặc mảng.

Các thư viện phân tích cú pháp JSON đã được quan sát thấy có sự khác biệt về việc chúng có hiển thị thứ tự của các thành viên đối tượng đối với phần mềm gọi hay không. Các triển khai có hành vi không phụ thuộc vào thứ tự của thành viên sẽ có thể tương tác với nhau theo nghĩa là chúng sẽ không bị ảnh hưởng bởi những khác biệt này.

Nó là khá đơn giản để duy trì trật tự. Tôi đã gặp vấn đề tương tự với việc duy trì thứ tự từ lớp DB sang Lớp giao diện người dùng.

Mở tệp JSONObject.java. Nó sử dụng nội bộ HashMap không duy trì thứ tự.

Thay đổi nó thành LinkedHashMap:

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

Điều này đã làm việc cho tôi. Hãy cho tôi biết ở phần bình luận. Tôi đề nghị bản thân thư viện JSON nên có một lớp JSONObject khác duy trì thứ tự, như JSONOrderdObject.java. Tôi rất kém trong việc chọn tên.

JSONObject.javalấy bất kỳ bản đồ nào bạn vượt qua. Nó có thể là LinkedHashMaphoặc TreeMapvà sẽ hashmapchỉ mất khi bản đồ trống.

Đây là hàm tạo của JSONObject.javalớp sẽ thực hiện việc kiểm tra bản đồ.

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

Vì vậy, trước khi xây dựng một cấu trúc đối tượng json LinkedHashMapvà sau đó chuyển nó cho hàm tạo như thế này,

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

Vì vậy không cần thiết phải thay đổi JSONObject.javalớp. Hy vọng nó sẽ giúp ai đó.

Một giải pháp dài dòng hơn, nhưng có thể áp dụng rộng rãi cho loại vấn đề này là sử dụng một cặp cấu trúc dữ liệu: một danh sách để chứa thứ tự và một bản đồ để chứa các quan hệ.

Ví dụ:

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

Bạn lặp lại danh sách itemOrder và sử dụng chúng để tra cứu các giá trị bản đồ. Thứ tự được bảo toàn, không có kludges.

Tôi đã sử dụng phương pháp này nhiều lần.

Một giải pháp hacky khác sử dụng phản xạ:

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

Apache Wink đã OrderJSONObject . Nó giữ thứ tự trong khi phân tích chuỗi.

Chỉ tình cờ gặp phải vấn đề tương tự, tôi tin rằng giải pháp cuối cùng mà tác giả sử dụng là sử dụng ContainerFactory tùy chỉnh:

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

xem http://juliusdavies.ca/json-simple-1.1.1-javadocs/org/json/simple/parser/JSONParser.html#parse(java.io.Reader,org.json.simple.parser.ContainerFactory)

Đã giải quyết.

Tôi đã sử dụng thư viện JSON.simple từ đây https://code.google.com/p/json-simple/ để đọc chuỗi JSON nhằm giữ thứ tự các khóa và sử dụng thư viện JavaCSV từ đây http://sourceforge.net/ project / javacsv / để chuyển đổi sang định dạng CSV.

Tôi biết điều này đã được giải quyết và câu hỏi đã được đặt ra từ lâu, nhưng khi tôi đang giải quyết một vấn đề tương tự, tôi muốn đưa ra một cách tiếp cận hoàn toàn khác cho vấn đề này:

Đối với mảng, nó nói "Một mảng là một tập hợp các giá trị có thứ tự." tại http://www.json.org/ - nhưng các đối tượng ("Một đối tượng là một tập hợp các cặp tên / giá trị không có thứ tự.") không được sắp xếp theo thứ tự.

Tôi tự hỏi tại sao đối tượng đó lại nằm trong một mảng - điều đó ngụ ý một thứ tự không có ở đó.

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

Vì vậy, một giải pháp sẽ là đặt các khóa trong một mảng "thực" và thêm dữ liệu dưới dạng đối tượng vào mỗi khóa như sau:

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

Vì vậy, đây là một cách tiếp cận cố gắng xem xét lại mô hình ban đầu và mục đích của nó. Nhưng tôi chưa thử nghiệm (và tôi tự hỏi) liệu tất cả các công cụ liên quan có bảo toàn thứ tự của mảng JSON gốc đó không.

Trong thế giới thực, một ứng dụng hầu như sẽ luôn có java bean hoặc miền sẽ được tuần tự hóa / hủy tuần tự hóa đến / từ JSON. Nó đã được đề cập rằng đặc tả đối tượng JSON không đảm bảo trật tự và bất kỳ thao tác nào đối với hành vi đó không phù hợp với yêu cầu. Tôi đã có cùng một kịch bản trong ứng dụng của mình, nơi tôi cần duy trì trật tự chỉ vì mục đích dễ đọc. Tôi đã sử dụng cách jackson tiêu chuẩn để tuần tự hóa bean java của mình thành JSON:

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

Để tạo json với một tập hợp các phần tử có thứ tự, tôi chỉ cần sử dụng chú thích thuộc tính JSON trong Java bean mà tôi đã sử dụng để chuyển đổi. Ví dụ dưới đây:

@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 () được sử dụng ở trên:

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

Kết quả hiển thị theo chú thích thứ tự thuộc tính Json:

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

Cách an toàn nhất có lẽ là phương pháp ghi đè khóa được sử dụng để tạo đầu ra:

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

patchFor (answer @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()) {

Bạn có thể sử dụng mã sau để thực hiện tuần tự hóa ORDERED tùy chỉnh và deserialization của JSON Array (Ví dụ này giả sử bạn đang đặt hàng các Chuỗi nhưng có thể áp dụng cho tất cả các loại):

Serialization

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

Hủy đăng ký

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

Ví dụ của bạn:

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

thêm một phần tử "itemorder"

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

Mã này tạo ra kết quả mong muốn mà không có dòng tiêu đề cột:

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

thay vì sử dụng jsonObject, hãy thử sử dụng CsvSchema theo cách của nó dễ dàng hơn và trực tiếp chuyển đổi đối tượng thành csv

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

và nó đề cập đến id đơn hàng mà pojo của bạn có @JsonPropertyOrder trong đó

Underscore-java giữ thứ tự cho các phần tử trong khi đọc json. Tôi là người duy trì dự án.

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

Đã thử nghiệm giải pháp nháy mắt và hoạt động tốt:

@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());
}