Jak przekonwertować HashMap na json Array w systemie Android?

Question

Chcę konwertować HashMap do json array mój kod jest następująca:

Map<String, String> map = new HashMap<String, String>(); 

map.put("first", "First Value"); 

map.put("second", "Second Value"); 

Próbowałem tego, ale to nie działa. Jakieś rozwiązanie?

JSONArray mJSONArray = new JSONArray(Arrays.asList(map)); 

Answer 1

Spróbuj tego,

public JSONObject (Map copyFrom) 

Tworzy nowy JSONObject kopiując wszystkie mapowania nazwa/wartość z danej mapie.

Parametry copyZ mapy, której klucze są typu String i których wartości są obsługiwanych typów.

Zgłasza Wyjątek NullPointerException, jeśli którykolwiek z kluczy mapy ma wartość NULL.

Podstawowe użycie:

JSONObject obj=new JSONObject(yourmap); 

dostać tablicy json z JSONObject

Edit:

JSONArray array=new JSONArray(obj.toString()); 

Edit: (Jeśli znaleziono wyjątek to można zmienić jak wspomnieć w komentarzu @ krb686)

JSONArray array=new JSONArray("["+obj.toString()+"]"); 

Answer 2

Można użyć

JSONArray jarray = JSONArray.fromObject(map);

Answer 3

Mapa składa się z par klucz/wartość, tj. Dwóch obiektów dla każdego wpisu, natomiast lista zawiera tylko jeden obiekt dla każdego wpisu. Co można zrobić, to wydobyć wszystko Map.Entry<K,V> a następnie umieścić je w tablicy:

Set<Map.Entry<String, String> entries = map.entrySet(); 
JSONArray mJSONArray = new JSONArray(entries); 

Alternatywnie, czasami warto wyodrębnić klucze lub wartości do kolekcji:

Set<String> keys = map.keySet(); 
JSONArray mJSONArray = new JSONArray(keys); 

lub

List<String> values = map.values(); 
JSONArray mJSONArray = new JSONArray(values); 

Uwaga: Jeśli zdecydujesz się wykorzystać klucze jak wpisy, t Zamówienie nie jest gwarantowane (metoda zwraca wartość Set). Dzieje się tak dlatego, że interfejs Map nie określa żadnej kolejności (chyba że Map ma postać SortedMap).

Answer 4

To jest najprostsza metoda.

Wystarczy użyć

JSONArray jarray = new JSONArray(hashmapobject.toString); 

Answer 5

Od androiad API Lvl 19, można po prostu zrobić new JSONObject(new HashMap()). Ale na starszych lvlach API dostajesz brzydki wynik (proste zastosowanie doString do każdej wartości nie-prymitywnej).

Zebrałem metody z JSONObject i JSONArray dla uproszczenia i pięknego wyniku. Można użyć moją klasę rozwiązanie:

package you.package.name; 

import org.json.JSONArray; 
import org.json.JSONException; 
import org.json.JSONObject; 

import java.lang.reflect.Array; 
import java.util.Collection; 
import java.util.Map; 

public class JsonUtils 
{ 
    public static JSONObject mapToJson(Map<?, ?> data) 
    { 
     JSONObject object = new JSONObject(); 

     for (Map.Entry<?, ?> entry : data.entrySet()) 
     { 
      /* 
      * Deviate from the original by checking that keys are non-null and 
      * of the proper type. (We still defer validating the values). 
      */ 
      String key = (String) entry.getKey(); 
      if (key == null) 
      { 
       throw new NullPointerException("key == null"); 
      } 
      try 
      { 
       object.put(key, wrap(entry.getValue())); 
      } 
      catch (JSONException e) 
      { 
       e.printStackTrace(); 
      } 
     } 

     return object; 
    } 

    public static JSONArray collectionToJson(Collection data) 
    { 
     JSONArray jsonArray = new JSONArray(); 
     if (data != null) 
     { 
      for (Object aData : data) 
      { 
       jsonArray.put(wrap(aData)); 
      } 
     } 
     return jsonArray; 
    } 

    public static JSONArray arrayToJson(Object data) throws JSONException 
    { 
     if (!data.getClass().isArray()) 
     { 
      throw new JSONException("Not a primitive data: " + data.getClass()); 
     } 
     final int length = Array.getLength(data); 
     JSONArray jsonArray = new JSONArray(); 
     for (int i = 0; i < length; ++i) 
     { 
      jsonArray.put(wrap(Array.get(data, i))); 
     } 

     return jsonArray; 
    } 

    private static Object wrap(Object o) 
    { 
     if (o == null) 
     { 
      return null; 
     } 
     if (o instanceof JSONArray || o instanceof JSONObject) 
     { 
      return o; 
     } 
     try 
     { 
      if (o instanceof Collection) 
      { 
       return collectionToJson((Collection) o); 
      } 
      else if (o.getClass().isArray()) 
      { 
       return arrayToJson(o); 
      } 
      if (o instanceof Map) 
      { 
       return mapToJson((Map) o); 
      } 
      if (o instanceof Boolean || 
        o instanceof Byte || 
        o instanceof Character || 
        o instanceof Double || 
        o instanceof Float || 
        o instanceof Integer || 
        o instanceof Long || 
        o instanceof Short || 
        o instanceof String) 
      { 
       return o; 
      } 
      if (o.getClass().getPackage().getName().startsWith("java.")) 
      { 
       return o.toString(); 
      } 
     } 
     catch (Exception ignored) 
     { 
     } 
     return null; 
    } 
} 

Następnie, jeśli stosuje mapToJson() metoda do mapy, można uzyskać wynik tak:

{ 
    "int": 1, 
    "Integer": 2, 
    "String": "a", 
    "int[]": [1,2,3], 
    "Integer[]": [4, 5, 6], 
    "String[]": ["a","b","c"], 
    "Collection": [1,2,"a"], 
    "Map": { 
    "b": "B", 
    "c": "C", 
    "a": "A" 
    } 
}