GSON के साथ JSON एरे को पार्स कैसे करें

Question 1

मैं JSON सरणियों को पार्स करना और gson का उपयोग करना चाहता हूं। सबसे पहले, मैं JSON आउटपुट लॉग कर सकता हूं, सर्वर क्लाइंट के लिए स्पष्ट रूप से जिम्मेदार है।

यहाँ मेरा JSON आउटपुट है:

 [
      {
           id : '1',
           title: 'sample title',
           ....
      },
      {
           id : '2',
           title: 'sample title',
           ....
     },
      ...
 ]

मैंने इस संरचना को पार्स करने की कोशिश की। एक वर्ग, जो एकल arrayऔर ArrayListसभी JSONArray पर निर्भर करता है ।

 public class PostEntity {

      private ArrayList<Post> postList = new ArrayList<Post>();

      public List<Post> getPostList() { 
           return postList; 
      }

      public void setPostList(List<Post> postList) { 
           this.postList = (ArrayList<Post>)postList; 
      } 
 }

पोस्ट क्लास:

 public class Post {

      private String id;
      private String title;

      /* getters & setters */
 }

जब मैं कोई त्रुटि नहीं, कोई चेतावनी और लॉग का उपयोग करने का प्रयास करता हूं:

 GsonBuilder gsonb = new GsonBuilder();
 Gson gson = gsonb.create();

 PostEntity postEnt;
 JSONObject jsonObj = new JSONObject(jsonOutput);
 postEnt = gson.fromJson(jsonObj.toString(), PostEntity.class);

 Log.d("postLog", postEnt.getPostList().get(0).getId());

क्या गलत है, मैं कैसे हल कर सकता हूं?

Question 2

आप JSONArrayसीधे पार्स कर सकते हैं, अपनी Postकक्षा को PostEntityएक बार और लपेटने की आवश्यकता नहीं है और न ही नए की आवश्यकता है JSONObject().toString():

Gson gson = new Gson();
String jsonOutput = "Your JSON String";
Type listType = new TypeToken<List<Post>>(){}.getType();
List<Post> posts = gson.fromJson(jsonOutput, listType);

उम्मीद है की वो मदद करदे।

Question 3

मैं एक और अधिक सामान्य तरीके से ऑब्जेक्ट सरणियों को पार्स करने का एक तरीका ढूंढ रहा था; यहाँ मेरा योगदान है:

CollectionDeserializer.java:

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonParseException;

public class CollectionDeserializer implements JsonDeserializer<Collection<?>> {

    @Override
    public Collection<?> deserialize(JsonElement json, Type typeOfT,
            JsonDeserializationContext context) throws JsonParseException {
        Type realType = ((ParameterizedType)typeOfT).getActualTypeArguments()[0];

        return parseAsArrayList(json, realType);
    }

    /**
     * @param serializedData
     * @param type
     * @return
     */
    @SuppressWarnings("unchecked")
    public <T> ArrayList<T> parseAsArrayList(JsonElement json, T type) {
        ArrayList<T> newArray = new ArrayList<T>();
        Gson gson = new Gson();

        JsonArray array= json.getAsJsonArray();
        Iterator<JsonElement> iterator = array.iterator();

        while(iterator.hasNext()){
            JsonElement json2 = (JsonElement)iterator.next();
            T object = (T) gson.fromJson(json2, (Class<?>)type);
            newArray.add(object);
        }

        return newArray;
    }

}

JSONParsingTest.java:

public class JSONParsingTest {

    List<World> worlds;

    @Test
    public void grantThatDeserializerWorksAndParseObjectArrays(){

        String worldAsString = "{\"worlds\": [" +
            "{\"name\":\"name1\",\"id\":1}," +
            "{\"name\":\"name2\",\"id\":2}," +
            "{\"name\":\"name3\",\"id\":3}" +
        "]}";

        GsonBuilder builder = new GsonBuilder();
        builder.registerTypeAdapter(Collection.class, new CollectionDeserializer());
        Gson gson = builder.create();
        Object decoded = gson.fromJson((String)worldAsString, JSONParsingTest.class);

        assertNotNull(decoded);
        assertTrue(JSONParsingTest.class.isInstance(decoded));

        JSONParsingTest decodedObject = (JSONParsingTest)decoded;
        assertEquals(3, decodedObject.worlds.size());
        assertEquals((Long)2L, decodedObject.worlds.get(1).getId());
    }
}

World.java:

public class World {
    private String name;
    private Long id;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

}

Question 4

ऑब्जेक्ट एरे में परिवर्तित करना

Gson gson=new Gson();
ElementType [] refVar=gson.fromJson(jsonString,ElementType[].class);

पोस्ट प्रकार के रूप में परिवर्तित करने के लिए

Gson gson=new Gson();
Post [] refVar=gson.fromJson(jsonString,Post[].class);

वस्तुओं की सूची के रूप में इसे पढ़ने के लिए टाइपटोन का उपयोग किया जा सकता है

List<Post> posts=(List<Post>)gson.fromJson(jsonString, 
                     new TypeToken<List<Post>>(){}.getType());

Question 5

Type listType = new TypeToken<List<Post>>() {}.getType();
List<Post> posts = new Gson().fromJson(jsonOutput.toString(), listType);

Question 6

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

इसे पाने के लिए मुझे एरे को पढ़ना था और एरे के अंदर एक-एक करके ऑब्जेक्ट्स को बदलना था। बेशक यह तरीका सबसे तेज़ नहीं है और मैं इसका उपयोग करने की सलाह नहीं देता अगर आपके पास सरणी बहुत बड़ी है, लेकिन यह मेरे लिए काम करता है।

परियोजना में जसन पुस्तकालय को शामिल करना आवश्यक है। यदि आप Android पर विकसित कर रहे हैं, तो यह शामिल है:

/**
 * Convert JSON string to a list of objects
 * @param sJson String sJson to be converted
 * @param tClass Class
 * @return List<T> list of objects generated or null if there was an error
 */
public static <T> List<T> convertFromJsonArray(String sJson, Class<T> tClass){

    try{
        Gson gson = new Gson();
        List<T> listObjects = new ArrayList<>();

        //read each object of array with Json library
        JSONArray jsonArray = new JSONArray(sJson);
        for(int i=0; i<jsonArray.length(); i++){

            //get the object
            JSONObject jsonObject = jsonArray.getJSONObject(i);

            //get string of object from Json library to convert it to real object with Gson library
            listObjects.add(gson.fromJson(jsonObject.toString(), tClass));
        }

        //return list with all generated objects
        return listObjects;

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

    //error: return null
    return null;
}

Question 7

[
      {
           id : '1',
           title: 'sample title',
           ....
      },
      {
           id : '2',
           title: 'sample title',
           ....
     },
      ...
 ]

इस आउटपुट के लिए आसान कोड की जाँच करें

 Gson gson=new GsonBuilder().create();
                List<Post> list= Arrays.asList(gson.fromJson(yourResponse.toString,Post[].class));

Question 8

आप निम्नलिखित कोड का उपयोग करके आसानी से कोटलिन में कर सकते हैं:

val fileData = "your_json_string"
val gson = GsonBuilder().create()
val packagesArray = gson.fromJson(fileData , Array<YourClass>::class.java).toList()

मूल रूप से, आप केवल एक प्रदान करने की आवश्यकता Arrayकी YourClassवस्तुओं।

Question 9

आप प्रकार वस्तु का उपयोग किए बिना सूची मूल्य प्राप्त कर सकते हैं ।

EvalClassName[] evalClassName;
ArrayList<EvalClassName> list;
evalClassName= new Gson().fromJson(JSONArrayValue.toString(),EvalClassName[].class);
list = new ArrayList<>(Arrays.asList(evalClassName));

मैंने इसका परीक्षण किया है और यह काम कर रहा है।

Question 10

में Kotlin :

val jsonArrayString = "['A','B','C']"

val gson = Gson()

val listType: Type = object : TypeToken<List<String?>?>() {}.getType()

val stringList : List<String> = gson.fromJson(
                            jsonArrayString,
                            listType)