Java Android JSON名称顺序

我正在使用下面的代码来解析一个站点的信息，它可以正常工作，除非最后一个for循环中的旧版本出了问题<代码>名称（）显示为

[“569”、“570”、“565”、“566”、“567”、“568”、“562”、“563”、“564”]

这些数字应该是数字顺序，但不是。有没有好办法解决这个问题

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserFactory;

import android.annotation.SuppressLint;
import android.util.Log;

public class JSON {
   private String html;
   private String version = "version";
   private String pageString = null;
   private String urlString = "http://frc-manual.usfirst.org/a/GetAllItems/ManualID=3";

   public volatile boolean parsingComplete = true;
   public JSON(String page){
      this.pageString = page;
   }
   public String getHTML(){
      return html;
   }
   public String getVersion(){
      return version;
   }

   @SuppressLint("NewApi")
   public void readAndParseJSON(String in) {
      try {
         JSONObject reader = new JSONObject(in);


         JSONObject head = reader.getJSONObject("data").getJSONObject("SubChapter").getJSONObject("3").getJSONObject("children").getJSONObject(pageString);
         html = head.getString("item_content_text");

         if(head.has("children")){
             JSONObject children = head.getJSONObject("children");
             JSONArray sub1 = new JSONArray(children.names().toString());
             for(int i=sub1.length()-1;i>=0;i--){
                 JSONObject children2 = children.getJSONObject(Integer.toString(sub1.getInt(i)));
                 html = html + "<h2>" + children2.getString("secdisp")+ " " + children2.getString("item_name") + "</h2>";
                 html = html + children2.getString("item_content_text");
                 if(children2.has("children")){
                     JSONObject children3 = children2.getJSONObject("children");
                     JSONArray sub2 = new JSONArray(children3.names().toString());
                     html = html + sub2;
                     for(int j=sub2.length()-1;j>=0;j--){
                         JSONObject children4 = children3.getJSONObject((String) sub2.get(j));
                         html = html + "<h3>" + children4.getString("secdisp")+ " " + children4.getString("item_name") + "</h3>";
                         html = html + children4.getString("item_content_text");
                     }
                 }
             }
         }

         JSONObject main  = reader.getJSONObject("data");
         version = main.getString("LatestManualUpdate");

         parsingComplete = false;



        } catch (Exception e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
        }

   }
   public void fetchJSON(){
      Thread thread = new Thread(new Runnable(){
         @Override
         public void run() {
         try {
            URL url = new URL(urlString);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setReadTimeout(10000 /* milliseconds */);
            conn.setConnectTimeout(15000 /* milliseconds */);
            conn.setRequestMethod("GET");
            conn.setDoInput(true);
            // Starts the query
            conn.connect();
         InputStream stream = conn.getInputStream();

      String data = convertStreamToString(stream);

      readAndParseJSON(data);
         stream.close();

         } catch (Exception e) {
            e.printStackTrace();
         }
         }
      });

       thread.start();      
   }
   static String convertStreamToString(java.io.InputStream is) {
      java.util.Scanner s = new java.util.Scanner(is).useDelimiter("\\A");
      return s.hasNext() ? s.next() : "";
   }

}

import java.io.IOException；
导入java.io.InputStream；
导入java.io.InputStreamReader；
导入java.io.StringWriter；
导入java.io.UnsupportedEncodingException；
导入java.net.HttpURLConnection；
导入java.net.URL；
导入java.util.ArrayList；
导入java.util.HashMap；
导入java.util.Iterator；
导入java.util.LinkedList；
导入java.util.List；
导入java.util.Map；
导入java.util.SortedMap；
导入java.util.TreeMap；
导入org.json.JSONArray；
导入org.json.JSONException；
导入org.json.JSONObject；
导入org.xmlpull.v1.XmlPullParser；
导入org.xmlpull.v1.XmlPullParserFactory；
导入android.annotation.SuppressLint；
导入android.util.Log；
公共类JSON{
私有字符串html；
私有字符串version=“version”；
私有字符串pageString=null；
专用字符串urlString=”http://frc-manual.usfirst.org/a/GetAllItems/ManualID=3";
public volatile boolean parsingplete=true；
公共JSON（字符串页）{
this.pageString=page；
}
公共字符串getHTML（）{
返回html；
}
公共字符串getVersion（）{
返回版本；
}
@SuppressLint（“新API”）
public void readAndParseJSON（字符串输入）{
试一试{
JSONObject reader=新的JSONObject（in）；
JSONObject head=reader.getJSONObject（“数据”）.getJSONObject（“分章”）.getJSONObject（“3”）.getJSONObject（“子项”）.getJSONObject（页面字符串）；
html=head.getString（“项目内容文本”）；
如果（校长有（“子女”））{
JSONObject children=head.getJSONObject（“children”）；
JSONArray sub1=新的JSONArray（children.names（）.toString（））；
对于（int i=sub1.length（）-1；i>=0；i--）{
JSONObject children2=children.getJSONObject（Integer.toString（sub1.getInt（i））；
html=html+“”+children2.getString（“secdisp”）+“”+children2.getString（“项目名称”）+“”；
html=html+children2.getString（“项目内容文本”）；
如果（儿童2.有（“儿童”））{
JSONObject children3=children2.getJSONObject（“children”）；
JSONArray sub2=新的JSONArray（children3.names（）.toString（））；
html=html+sub2；
对于（int j=sub2.length（）-1；j>=0；j--）{
JSONObject children4=children3.getJSONObject（（字符串）sub2.get（j））；
html=html+“”+children4.getString（“secdisp”）+“”+children4.getString（“项目名称”）+“”；
html=html+children4.getString（“项目内容文本”）；
}
}
}
}
JSONObject main=reader.getJSONObject（“数据”）；
version=main.getString（“LatestManualUpdate”）；
parsingComplete=false；
}捕获（例外e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
public-void-fetchJSON（）{
Thread Thread=新线程（new Runnable（）{
@凌驾
公开募捐{
试一试{
URL=新URL（URL字符串）；
HttpURLConnection conn=（HttpURLConnection）url.openConnection（）；
conn.setReadTimeout（10000/*毫秒*/）；
conn.setConnectTimeout（15000/*毫秒*/）；
conn.setRequestMethod（“GET”）；
conn.setDoInput（真）；
//启动查询
连接（）；
InputStream=conn.getInputStream（）；
字符串数据=convertStreamToString（流）；
readAndParseJSON（数据）；
stream.close（）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
});
thread.start（）；
}
静态字符串convertStreamToString（java.io.InputStream为）{
java.util.Scanner s=新的java.util.Scanner（is）.useDelimiter（“\\A”）；
返回s.hasNext（）？s.next（）：“”；
}
}
未定义
JSONObject
中键的顺序（有关详细信息，请参阅文档）。在实践中，这意味着它们可能会根据它们的哈希代码进行排序，这显然不是您想要的。如果您需要按特定顺序保存这些项目，您可以：


使用不同的JSON解析器。谷歌搜索有很多可用的功能；我建议，“推式解析器”可能是最合适的类型，因为这将保证按照定义的顺序一个接一个地为您提供对象中的项。就是这样一个解析器。请看“解码示例”页面中的示例5和6。或者，请参见示例4，了解如何在对象模型模式下更改用于存储JSON对象的
Map
的类型，并注意
LinkedHashMap
保留向其添加值的顺序
在使用名称之前，先对名称列表进行排序
将JSON更改为使用包含数字的对象数组，而不是使用数字作为键的对象，因为数组（显然）保持在原始JSON中出现的顺序
您所期望的东西超出了JSON的表示模型

根据报告：

“对象是一组无序的名称/值对。”

事实上，你可以暗示一个订单是不相关的。JSON信息模型不承认存在这种排序。这就是为什么大多数JSON解析器忽略您的隐含顺序，并且许多内存中的JSON对象表示无法记录它


那你该怎么办

我的建议是更改JSON模式。例如，与此相反：{ "name1" : "value1", "name2" : "value2", "name3" : "value3" }

[ [ "name1", "value1" ], [ "name2", "value2" ], [ "name3", "value3" ] ]

[ { "name": "name1", "val" : "value1" }, 
  { "name": "name2", "val" : "value2" }, 
  { "name": "name3", "val" : "value3" } ]