安卓json

安卓JSON初学

2020-12-01 20:50:28

安卓JSON初学通过解析JSON数据来获取天气信息 1.创建weather.json，放在res/raw下 [ {"temp":"20℃/30℃", "weather":"晴转多云", "name":"上海", "pm":"80", "wind":"1级"}, {"temp":"15℃/30℃", "weather":...

安卓JSON初学
通过解析JSON数据来获取天气信息

1.创建weather.json，放在res/raw下
 [
    {"temp":"20℃/30℃", "weather":"晴转多云", "name":"上海", "pm":"80", "wind":"1级"},
    {"temp":"15℃/30℃", "weather":"晴", "name":"北京", "pm":"98", "wind":"3级"},
    {"temp":"26℃/32℃", "weather":"多云", "name":"广州", "pm":"30", "wind":"2级"}
 ]

2.创建工具类

在WeatherService类中定义getInfosFromJson()方法，通过Gson读取JSON文件
package com.example.student;

import android.util.Xml;

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;

import java.io.InputStream;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

public class WeatherService {

   /* public static List<WeatherInfo> getInfosFromXML(InputStream is) throws Exception{
        XmlPullParser parser = Xml.newPullParser();
        parser.setInput(is, "utf-8");
        List<WeatherInfo> weatherInfos = null;
        WeatherInfo weatherInfo = null;
        int type = parser.getEventType();
        while(type != XmlPullParser.END_DOCUMENT){
            switch (type){
                case XmlPullParser.START_TAG:
                    if("infos".equals(parser.getName())){
                        weatherInfos = new ArrayList<WeatherInfo>();
                    }
                    else if("city".equals(parser.getName())){
                        weatherInfo = new WeatherInfo();
                        String idstr = parser.getAttributeValue(0);
                        weatherInfo.setId(idstr);
                    }
                    else if("temp".equals(parser.getName())){
                        String temp = parser.nextText();
                        weatherInfo.setTemp(temp);
                    }
                    else if("weather".equals(parser.getName())){
                        String temp = parser.nextText();
                        weatherInfo.setWeather(temp);
                    }
                    else if("name".equals(parser.getName())){
                        String temp = parser.nextText();
                        weatherInfo.setName(temp);
                    }
                    else if("pm".equals(parser.getName())){
                        String temp = parser.nextText();
                        weatherInfo.setPm(temp);
                    }
                    else if("wind".equals(parser.getName())){
                        String temp = parser.nextText();
                        weatherInfo.setWind(temp);
                    }
                    break;

                    case XmlPullParser.END_TAG:
                        if("city".equals(parser.getName())){
                            weatherInfos.add(weatherInfo);
                            weatherInfo = null;
                        }
                        break;
            }

            type = parser.next();

        }

        return weatherInfos;

    }*/

    public static List<WeatherInfo> getInfosFromJson(InputStream is)throws Exception{
        byte butter[] = new byte[is.available()];  //本地读入
        is.read(butter);
        String json = new String(butter, "utf-8");
        Gson gson = new Gson();
        Type list = new TypeToken<List<WeatherInfo>>(){}.getType();
        List<WeatherInfo> weatherInfos = gson.fromJson(json, list); //从JSON相关对象到JAVA实体
        return weatherInfos;
    }

}


注意使用Gson解析JSON数据，需要手动导入Gson库！

（1）打开工程的Project Structure

（2）在Dependencies中，点击➕



找到如下com.google.code.gson.gson:2.6.2库



点击OK，进行导入
3 .编写交互界面代码
package com.example.student;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    private TextView tv_city, tv_weather, tv_wind, tv_pm, tv_temp;
    private ImageView tv_iv;
    private Map<String, String> map;
    private List<Map<String, String>> list;
    private String temp, weather, name, wind, pm;
    private Button bbj, bgz, bsh;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
        try {
            InputStream is = this.getResources().openRawResource(R.raw.weather2);
            List<WeatherInfo> weatherInfos = WeatherService.getInfosFromJson(is);
            list = new ArrayList<Map<String, String>>();
            for(WeatherInfo info : weatherInfos){
                map = new HashMap<String, String>();
                map.put("temp", info.getTemp());
                map.put("weather", info.getWeather());
                map.put("name", info.getName());
                map.put("pm", info.getPm());
                map.put("wind", info.getWind());
                list.add(map);
            }
        } catch (Exception e) {
            e.printStackTrace();
            Toast.makeText(this, "解析信息失败", Toast.LENGTH_SHORT).show();
        }

        getMap(1, R.drawable.cc);

    }

    @Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.bsh:
                getMap(0, R.drawable.ee);
                break;
            case R.id.bbj:
                getMap(1, R.drawable.cc);
                break;
            case R.id.bgz:
                getMap(2, R.drawable.dd);
                break;
        }
    }

    private void initView() {
        tv_city = findViewById(R.id.city);
        tv_weather = findViewById(R.id.weather);
        tv_temp = findViewById(R.id.temp);
        tv_wind = findViewById(R.id.wind);
        tv_pm = findViewById(R.id.time);
        tv_iv = findViewById(R.id.iv);
        bsh = findViewById(R.id.bsh);
        bbj = findViewById(R.id.bbj);
        bgz = findViewById(R.id.bgz);

        bsh.setOnClickListener(this);
        bbj.setOnClickListener(this);
        bgz.setOnClickListener(this);

    }

    private void getMap(int i, int aa) {
        Map<String, String> cityMap = list.get(i);
        temp = cityMap.get("temp");
        weather = cityMap.get("weather");
        name = cityMap.get("name");
        pm = cityMap.get("pm");
        wind = cityMap.get("wind");
        tv_city.setText(name);
        tv_weather.setText(weather);
        tv_pm.setText(pm);
        tv_wind.setText("风力：" + wind);
        tv_temp.setText("" + temp);
        tv_iv.setImageResource(aa);
    }
}


4 .运行程序

收起

展开全文

gson java

安卓json解析数组后的应用
2016-10-11 02:05:00
安卓json解析数组后怎么写进自定义的数组，然后怎么调用数组里的数据？
收起

安卓Json解析

2017-11-25 15:30:47

在安卓apk与后台服务通信时,我们一般有2中可以选择的数据格式xml和json. 而json作为一种轻量级的数据交换格式，具有良好的可读和便于快速编写的特性。可以在不同平台间进行数据交换。JSON采用兼容性很高的文本格式,...

在安卓apk与后台服务通信时,我们一般有2中可以选择的数据格式xml和json. 而json作为一种轻量级的数据交换格式，具有良好的可读和便于快速编写的特性。可以在不同平台间进行数据交换。JSON采用兼容性很高的文本格式,相比xml更轻量级,传输速度更快.在安卓中对json的解析我们一般有两种方式,一种是使用安卓自带api,一种是使用gson这个第三方的库.
一原生解析
系统自带的解析类都在org.json这个包下面.常用的类有JSONObject,JSONStringer,JSONArray.


JSONObject:可以传入一段json字符串参数,也可以不传参数新建一个json对象.

常用方法 :put(key,value)为json对象添加键值
getType和optType:更具键值或者索引(Json数组)获取json对象的值,两者的区别在于,optType可以在没有值的时候
提供一个默认值
JSONArray::可以传入一段json字符串参数,也可以不传参数新建一个jsonarray对象.
常用api:1.put(key,value)为json对象添加键值

2.getType和optType:更具键值或者索引(Json数组)获取json对象的值,两者的区别在于,optType可以在没有值的时候提供一个默认值
JSONStringer:利用代码的形式来构建json文本

JSONStringer jsonText = new JSONStringer();    
    // 首先是{，对象开始。object和endObject必须配对使用    
    jsonText.object();    
    jsonText.key("phone");    
    // 键phone的值是数组。array和endArray必须配对使用    
    jsonText.array();    
    jsonText.value("123").value("345");    
    jsonText.endArray();    
        
    jsonText.key("name");    
    jsonText.value("zhangfei");    
    jsonText.key("age");    
    jsonText.value(100);    
        
    jsonText.key("address");    
    // 键address的值是对象    
    jsonText.object();    
    jsonText.key("country");    
    jsonText.value("china");    
    jsonText.key("province");    
    jsonText.value("jiangsu");    
    jsonText.endObject();    
        
    jsonText.key("isStudent");    
    jsonText.value(false);    
        
    // }，对象结束    
    jsonText.endObject();    二 Gson框架

使用如下:1.将字符串转化为javabean对象
Gson gson = new Gson();  

Student student = gson.fromJson(jsonString,Student.class);

使用gson时解析数据时,必须新建javabean对象,还要注意javabean的属性名字必须和json字符串的名字一样.

2.将对象转为json字符串

   Gson gson = new Gson();

   String string = gson.toJson(value);

关于更多gson的api请参考gson官网

收起

展开全文

gson

安卓Json操作

2016-11-21 21:07:37

实体要继承serialable接口实体命名属性首字母小写或加下划线下面是个封装好的工具类 package com.pro.addresslist.tools; import java.lang.reflect.Array;...import jav


实体要继承serialable接口











实体命名属性首字母小写或加下划线






下面是个封装好的工具类

package com.pro.addresslist.tools;

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;

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

import android.util.Log;


/**
 * @author libs
 * 
 */
public class JSONHelper {
	private static String TAG = "JSONHelper";

	/**
	 * 将对象转换成Json字符串
	 * @param obj
	 * @return json类型字符串
	 */
	public static String toJSON(Object obj) {
		JSONStringer js = new JSONStringer();
		serialize(js, obj);
		return js.toString();
	}

	/**
	 * 序列化为JSON
	 * @param js json对象
	 * @param o	待需序列化的对象
	 */
	private static void serialize(JSONStringer js, Object o) {
		if (isNull(o)) {
			try {
				js.value(null);
			} catch (JSONException e) {
				e.printStackTrace();
			}
			return;
		}

		Class<?> clazz = o.getClass();
		if (isObject(clazz)) { // 对象
			serializeObject(js, o);
		} else if (isArray(clazz)) { // 数组
			serializeArray(js, o);
		} else if (isCollection(clazz)) { // 集合
			Collection<?> collection = (Collection<?>) o;
			serializeCollect(js, collection);
		}else if (isMap(clazz)) { // 集合
			HashMap<?,?> collection = (HashMap<?,?>) o;
			serializeMap(js, collection);
		} else { // 单个值
			try {
				js.value(o);
			} catch (JSONException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 序列化数组 
	 * @param js	json对象
	 * @param array	数组
	 */
	private static void serializeArray(JSONStringer js, Object array) {
		try {
			js.array();
			for (int i = 0; i < Array.getLength(array); ++i) {
				Object o = Array.get(array, i);
				serialize(js, o);
			}
			js.endArray();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 序列化集合
	 * @param js	json对象
	 * @param collection	集合
	 */
	private static void serializeCollect(JSONStringer js, Collection<?> collection) {
		try {
			js.array();
			for (Object o : collection) {
				serialize(js, o);
			}
			js.endArray();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 序列化Map
	 * @param js	json对象
	 * @param map	map对象
	 */
	private static void serializeMap(JSONStringer js, Map<?,?> map) {
		try {
			js.object();
			@SuppressWarnings("unchecked")
			Map valueMap = (Map) map;
			Iterator> it = valueMap.entrySet().iterator();
			while (it.hasNext()) {
				Map.Entry entry = (Map.Entry)it.next();
				js.key(entry.getKey());
				serialize(js,entry.getValue());
			}
			js.endObject();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 序列化对象
	 * @param js	json对象
	 * @param obj	待序列化对象
	 */
	private static void serializeObject(JSONStringer js, Object obj) {
		try {
			js.object();
			Class<? extends Object> objClazz = obj.getClass();
			Method[] methods = objClazz.getDeclaredMethods();   
	        Field[] fields = objClazz.getDeclaredFields();     
	        for (Field field : fields) {   
	            try {   
	                String fieldType = field.getType().getSimpleName();   
	                String fieldGetName = parseMethodName(field.getName(),"get");   
	                if (!haveMethod(methods, fieldGetName)) {   
	                    continue;   
	                }   
	                Method fieldGetMet = objClazz.getMethod(fieldGetName, new Class[] {});   
	                Object fieldVal = fieldGetMet.invoke(obj, new Object[] {});   
	                Object result = null;   
	                if ("Date".equals(fieldType)) {   
	                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.US);   
	                    result = sdf.format((Date)fieldVal);  

	                } else {   
	                    if (null != fieldVal) {   
	                        result = fieldVal;   
	                    }   
	                }   
	                js.key(field.getName());
					serialize(js, result);  
	            } catch (Exception e) {   
	                continue;   
	            }   
	        }  
			js.endObject();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 判断是否存在某属性的 get方法
	 * @param methods	引用方法的数组
	 * @param fieldMethod	方法名称
	 * @return true或者false
	 */
	public static boolean haveMethod(Method[] methods, String fieldMethod) {
		for (Method met : methods) {
			if (fieldMethod.equals(met.getName())) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 拼接某属性的 get或者set方法
	 * @param fieldName	字段名称
	 * @param methodType	方法类型
	 * @return 方法名称
	 */
	public static String parseMethodName(String fieldName,String methodType) {
		if (null == fieldName || "".equals(fieldName)) {
			return null;
		}
		return methodType + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
	}
	
	/**  
     * 给字段赋值  
     * @param obj  实例对象
     * @param valMap  值集合
     */  
    public static void setFieldValue(Object obj, Map valMap) {   
        Class<?> cls = obj.getClass();   
        // 取出bean里的所有方法   
        Method[] methods = cls.getDeclaredMethods();   
        Field[] fields = cls.getDeclaredFields();   
  
        for (Field field : fields) {   
            try {     
                String setMetodName = parseMethodName(field.getName(),"set");   
                if (!haveMethod(methods, setMetodName)) {   
                    continue;   
                }   
                Method fieldMethod = cls.getMethod(setMetodName, field   
                        .getType());   
                String value = valMap.get(field.getName());   
                if (null != value && !"".equals(value)) {   
                    String fieldType = field.getType().getSimpleName();   
                    if ("String".equals(fieldType)) {   
                        fieldMethod.invoke(obj, value);   
                    } else if ("Date".equals(fieldType)) {   
                        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.US);   
                        Date temp = sdf.parse(value);    
                        fieldMethod.invoke(obj, temp);   
                    } else if ("Integer".equals(fieldType)   
                            || "int".equals(fieldType)) {   
                        Integer intval = Integer.parseInt(value);   
                        fieldMethod.invoke(obj, intval);   
                    } else if ("Long".equalsIgnoreCase(fieldType)) {   
                        Long temp = Long.parseLong(value);   
                        fieldMethod.invoke(obj, temp);   
                    } else if ("Double".equalsIgnoreCase(fieldType)) {   
                        Double temp = Double.parseDouble(value);   
                        fieldMethod.invoke(obj, temp);   
                    } else if ("Boolean".equalsIgnoreCase(fieldType)) {   
                        Boolean temp = Boolean.parseBoolean(value);   
                        fieldMethod.invoke(obj, temp);   
                    } else {   
                        System.out.println("setFieldValue not supper type:" + fieldType);   
                    }   
                }   
            } catch (Exception e) {   
                continue;   
            }   
        }   
  
    } 
    
    /**
     * bean对象转Map
     * @param obj	实例对象
     * @return	map集合
     */
    public static Map beanToMap(Object obj) {   
        Class<?> cls = obj.getClass();   
        Map valueMap = new HashMap();   
        // 取出bean里的所有方法   
        Method[] methods = cls.getDeclaredMethods();   
        Field[] fields = cls.getDeclaredFields();     
        for (Field field : fields) {   
            try {   
                String fieldType = field.getType().getSimpleName();   
                String fieldGetName = parseMethodName(field.getName(),"get");   
                if (!haveMethod(methods, fieldGetName)) {   
                    continue;   
                }   
                Method fieldGetMet = cls.getMethod(fieldGetName, new Class[] {});   
                Object fieldVal = fieldGetMet.invoke(obj, new Object[] {});   
                String result = null;   
                if ("Date".equals(fieldType)) {   
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.CHINA);   
                    result = sdf.format((Date)fieldVal);   

                } else {   
                    if (null != fieldVal) {   
                        result = String.valueOf(fieldVal);   
                    }   
                }   
                valueMap.put(field.getName(), result);   
            } catch (Exception e) {   
                continue;   
            }   
        }   
        return valueMap;   
  
    }   

	/**
	 * 给对象的字段赋值
	 * @param obj	类实例
	 * @param fieldSetMethod	字段方法
	 * @param fieldType	字段类型
	 * @param value
	 */
	public static void setFiedlValue(Object obj,Method fieldSetMethod,String fieldType,Object value){
		   
        try {    
            if (null != value && !"".equals(value)) {    
            	if ("String".equals(fieldType)) {   
                	fieldSetMethod.invoke(obj, value.toString());   
                } else if ("Date".equals(fieldType)) {   
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.CHINA);   
                    Date temp = sdf.parse(value.toString());    
                    fieldSetMethod.invoke(obj, temp);   
                } else if ("Integer".equals(fieldType)   
                        || "int".equals(fieldType)) {   
                    Integer intval = Integer.parseInt(value.toString());   
                    fieldSetMethod.invoke(obj, intval);   
                } else if ("Long".equalsIgnoreCase(fieldType)) {   
                    Long temp = Long.parseLong(value.toString());   
                    fieldSetMethod.invoke(obj, temp);   
                } else if ("Double".equalsIgnoreCase(fieldType)) {   
                    Double temp = Double.parseDouble(value.toString());   
                    fieldSetMethod.invoke(obj, temp);   
                } else if ("Boolean".equalsIgnoreCase(fieldType)) {   
                    Boolean temp = Boolean.parseBoolean(value.toString());   
                    fieldSetMethod.invoke(obj, temp);   
                } else {   
                	fieldSetMethod.invoke(obj, value); 
                	Log.e(TAG, TAG  + ">>>>setFiedlValue -> not supper type" + fieldType);   
                } 
			}
                
        } catch (Exception e) {   
//            Log.e(TAG, TAG  + ">>>>>>>>>>set value error.",e);
        	e.printStackTrace();
        }   
    
	}
	
	/**
	 * 反序列化简单对象
	 * @param jo	json对象
	 * @param clazz	实体类类型
	 * @return	反序列化后的实例
	 * @throws JSONException 
	 */
	public static  T parseObject(JSONObject jo, Class clazz) throws JSONException {
		if (clazz == null || isNull(jo)) {
			return null;
		}

		T obj = newInstance(clazz);
		if (obj == null) {
			return null;
		}
		if(isMap(clazz)){ 
			setField(obj,jo);
		}else{
			  // 取出bean里的所有方法   
	        Method[] methods = clazz.getDeclaredMethods();   
	        Field[] fields = clazz.getDeclaredFields();   	        
			for (Field f : fields) {
				String setMetodName = parseMethodName(f.getName(),"set");   
                if (!haveMethod(methods, setMetodName)) {   
                    continue;   
                }                 
				try {
					Method fieldMethod = clazz.getMethod(setMetodName, f.getType());
					setField(obj,fieldMethod,f, jo);
				} catch (Exception e) {
					e.printStackTrace();
				}  
			}
		}
		return obj;
	}
	
	/**
	 * 反序列化简单对象
	 * @param jsonStr	json字符串
	 * @param clazz	实体类类型
	 * @return	反序列化后的实例
	 * @throws JSONException 
	 */
	public static  T parseObject(String jsonStr, Class clazz) throws JSONException {
		if (clazz == null || jsonStr == null || jsonStr.length() == 0) {
			return null;
		}
		
		JSONObject jo = null;
		jo = new JSONObject(jsonStr);
		if (isNull(jo)) {
			return null;
		}

		return parseObject(jo, clazz);
	}

	/**
	 * 反序列化数组对象
	 * @param ja	json数组
	 * @param clazz	实体类类型
	 * @return	反序列化后的数组
	 */
	public static  T[] parseArray(JSONArray ja, Class clazz) {
		if (clazz == null || isNull(ja)) {
			return null;
		}

		int len = ja.length();

		@SuppressWarnings("unchecked")
		T[] array = (T[]) Array.newInstance(clazz, len);

		for (int i = 0; i < len; ++i) {
			try {
				JSONObject jo = ja.getJSONObject(i);
				T o = parseObject(jo, clazz);
				array[i] = o;
			} catch (JSONException e) {
				e.printStackTrace();
			}
		}

		return array;
	}

	
	/**
	 * 反序列化数组对象
	 * @param jsonStr	json字符串
	 * @param clazz	实体类类型
	 * @return	序列化后的数组
	 */
	public static  T[] parseArray(String jsonStr, Class clazz) {
		if (clazz == null || jsonStr == null || jsonStr.length() == 0) {
			return null;
		}
		JSONArray jo = null;
		try {
			jo = new JSONArray(jsonStr);
		} catch (JSONException e) {
			e.printStackTrace();
		}

		if (isNull(jo)) {
			return null;
		}

		return parseArray(jo, clazz);
	}

	/**
	 * 反序列化泛型集合
	 * @param ja	json数组
	 * @param collectionClazz	集合类型
	 * @param genericType	实体类类型
	 * @return
	 * @throws JSONException 
	 */
	@SuppressWarnings("unchecked")
	public static  Collection parseCollection(JSONArray ja, Class<?> collectionClazz,
			Class genericType) throws JSONException {

		if (collectionClazz == null || genericType == null || isNull(ja)) {
			return null;
		}

		Collection collection = (Collection) newInstance(collectionClazz);

		for (int i = 0; i < ja.length(); ++i) {
			try {
				JSONObject jo = ja.getJSONObject(i);
				T o = parseObject(jo, genericType);
				collection.add(o);
			} catch (JSONException e) {
				e.printStackTrace();
			}
		}

		return collection;
	}

	/**
	 * 反序列化泛型集合
	 * @param jsonStr	json字符串
	 * @param collectionClazz	集合类型
	 * @param genericType	实体类类型
	 * @return	反序列化后的数组
	 * @throws JSONException 
	 */
	public static  Collection parseCollection(String jsonStr, Class<?> collectionClazz,
			Class genericType) throws JSONException {
		if (collectionClazz == null || genericType == null || jsonStr == null
				|| jsonStr.length() == 0) {
			return null;
		}
		JSONArray jo = null;
		try {
			//如果为数组，则此处转化时，需要去掉前面的键，直接后面的[]中的值
			int index = jsonStr.indexOf("[");
			String arrayString=null; 
			
			//获取数组的字符串
			if(-1!=index){
				arrayString = jsonStr.substring(index);
			}
			
			//如果为数组，使用数组转化
			if(null!=arrayString){
				jo = new JSONArray(arrayString);
			}
			else{
				jo = new JSONArray(jsonStr);
			}
			
		} catch (JSONException e) {
			e.printStackTrace();
		}

		if (isNull(jo)) {
			return null;
		}

		return parseCollection(jo, collectionClazz, genericType);
	}

	/**
	 * 根据类型创建对象
	 * @param clazz	待创建实例的类型
	 * @return	实例对象
	 * @throws JSONException 
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	private static  T newInstance(Class clazz) throws JSONException {
		if (clazz == null)
			return null;
		T obj = null;
		if (clazz.isInterface()) {
			if (clazz.equals(Map.class)) {
				obj = (T) new HashMap();
			}else if (clazz.equals(List.class)) {
				obj = (T) new ArrayList();
			}else if (clazz.equals(Set.class)) {
				obj = (T) new HashSet();
			}else{
				throw new JSONException("unknown interface: " + clazz);
			}
		}else{
			try {
				obj = clazz.newInstance();
			}catch (Exception e) {
				throw new JSONException("unknown class type: " + clazz);
			}
		}	
		return obj;
	}
	
	/**
	 * 设定Map的值
	 * @param obj	待赋值字段的对象
	 * @param jo	json实例
	 */
	private static void setField(Object obj, JSONObject jo) {
		try {
			@SuppressWarnings("unchecked")
			Iterator keyIter = jo.keys();
			String key;
			Object value;
			@SuppressWarnings("unchecked")
			Map valueMap = (Map) obj;
			while (keyIter.hasNext()) {
				key = (String) keyIter.next();
				value = jo.get(key);				
				valueMap.put(key, value);

			}
		} catch (JSONException e) {
			e.printStackTrace();
		}
	}	
	
	/**
	 * 设定字段的值
	 * @param obj	待赋值字段的对象
	 * @param fieldSetMethod	字段方法名
	 * @param field	字段
	 * @param jo	json实例
	 */
	private static void setField(Object obj, Method fieldSetMethod,Field field, JSONObject jo) {
		String name = field.getName();
		Class<?> clazz = field.getType();		
		try {
			if (isArray(clazz)) { // 数组
				Class<?> c = clazz.getComponentType();
				JSONArray ja = jo.optJSONArray(name);
				if (!isNull(ja)) {
					Object array = parseArray(ja, c);
					setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), array);
				}
			} else if (isCollection(clazz)) { // 泛型集合
				// 获取定义的泛型类型
				Class<?> c = null;
				Type gType = field.getGenericType();
				if (gType instanceof ParameterizedType) {
					ParameterizedType ptype = (ParameterizedType) gType;
					Type[] targs = ptype.getActualTypeArguments();
					if (targs != null && targs.length > 0) {
						Type t = targs[0];
						c = (Class<?>) t;
					}
				}

				JSONArray ja = jo.optJSONArray(name);
				if (!isNull(ja)) {
					Object o = parseCollection(ja, clazz, c);
					setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);
				}
			} else if (isSingle(clazz)) { // 值类型
				Object o = jo.opt(name);
				if (o != null) {
					setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);
				}
			} else if (isObject(clazz)) { // 对象
				JSONObject j = jo.optJSONObject(name);
				if (!isNull(j)) {
					Object o = parseObject(j, clazz);
					setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);
				}
			} else if (isList(clazz)) { // 列表
//				JSONObject j = jo.optJSONObject(name);
//				if (!isNull(j)) {
//					Object o = parseObject(j, clazz);
//					f.set(obj, o);
//				}
			} else {
				throw new Exception("unknow type!");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 设定字段的值 
	 * @param obj	待赋值字段的对象
	 * @param field	字段
	 * @param jo	json实例
	 */
	@SuppressWarnings("unused")
	private static void setField(Object obj, Field field, JSONObject jo) {
		String name = field.getName();
		Class<?> clazz = field.getType();
		try {
			if (isArray(clazz)) { // 数组
				Class<?> c = clazz.getComponentType();
				JSONArray ja = jo.optJSONArray(name);
				if (!isNull(ja)) {
					Object array = parseArray(ja, c);
					field.set(obj, array);
				}
			} else if (isCollection(clazz)) { // 泛型集合
				// 获取定义的泛型类型
				Class<?> c = null;
				Type gType = field.getGenericType();
				if (gType instanceof ParameterizedType) {
					ParameterizedType ptype = (ParameterizedType) gType;
					Type[] targs = ptype.getActualTypeArguments();
					if (targs != null && targs.length > 0) {
						Type t = targs[0];
						c = (Class<?>) t;
					}
				}
				JSONArray ja = jo.optJSONArray(name);
				if (!isNull(ja)) {
					Object o = parseCollection(ja, clazz, c);
					field.set(obj, o);
				}
			} else if (isSingle(clazz)) { // 值类型
				Object o = jo.opt(name);
				if (o != null) {
					field.set(obj, o);
				}
			} else if (isObject(clazz)) { // 对象
				JSONObject j = jo.optJSONObject(name);
				if (!isNull(j)) {
					Object o = parseObject(j, clazz);
					field.set(obj, o);
				}
			} else if (isList(clazz)) { // 列表
				JSONObject j = jo.optJSONObject(name);
				if (!isNull(j)) {
					Object o = parseObject(j, clazz);
					field.set(obj, o);
				}
			}else {
				throw new Exception("unknow type!");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 判断对象是否为空
	 * @param obj	实例
	 * @return
	 */
	private static boolean isNull(Object obj) {
		if (obj instanceof JSONObject) {
			return JSONObject.NULL.equals(obj);
		}
		return obj == null;
	}

	/**
	 * 判断是否是值类型 
	 * @param clazz	
	 * @return
	 */
	private static boolean isSingle(Class<?> clazz) {
		return isBoolean(clazz) || isNumber(clazz) || isString(clazz);
	}

	/**
	 * 是否布尔值
	 * @param clazz	
	 * @return
	 */
	public static boolean isBoolean(Class<?> clazz) {
		return (clazz != null)
				&& ((Boolean.TYPE.isAssignableFrom(clazz)) || (Boolean.class
						.isAssignableFrom(clazz)));
	}

	/**
	 * 是否数值 
	 * @param clazz	
	 * @return
	 */
	public static boolean isNumber(Class<?> clazz) {
		return (clazz != null)
				&& ((Byte.TYPE.isAssignableFrom(clazz)) || (Short.TYPE.isAssignableFrom(clazz))
						|| (Integer.TYPE.isAssignableFrom(clazz))
						|| (Long.TYPE.isAssignableFrom(clazz))
						|| (Float.TYPE.isAssignableFrom(clazz))
						|| (Double.TYPE.isAssignableFrom(clazz)) || (Number.class
						.isAssignableFrom(clazz)));
	}

	/**
	 * 判断是否是字符串 
	 * @param clazz	
	 * @return
	 */
	public static boolean isString(Class<?> clazz) {
		return (clazz != null)
				&& ((String.class.isAssignableFrom(clazz))
						|| (Character.TYPE.isAssignableFrom(clazz)) || (Character.class
						.isAssignableFrom(clazz)));
	}

	/**
	 * 判断是否是对象
	 * @param clazz	
	 * @return
	 */
	private static boolean isObject(Class<?> clazz) {
		return clazz != null && !isSingle(clazz) && !isArray(clazz) && !isCollection(clazz) && !isMap(clazz);
	}

	/**
	 * 判断是否是数组 
	 * @param clazz
	 * @return
	 */
	public static boolean isArray(Class<?> clazz) {
		return clazz != null && clazz.isArray();
	}

	/**
	 * 判断是否是集合
	 * @param clazz
	 * @return
	 */
	public static boolean isCollection(Class<?> clazz) {
		return clazz != null && Collection.class.isAssignableFrom(clazz);
	}
		
	/**
	 * 判断是否是Map
	 * @param clazz
	 * @return
	 */
	public static boolean isMap(Class<?> clazz) {
		return clazz != null && Map.class.isAssignableFrom(clazz);
	}
	
	/**
	 * 判断是否是列表 
	 * @param clazz
	 * @return
	 */
	public static boolean isList(Class<?> clazz) {
		return clazz != null && List.class.isAssignableFrom(clazz);
	}
	
}

收起

展开全文

Android

安卓 json解析
2016-05-04 23:16:40
类似这样的json ,我用gson 和映射做，返回的List<User>一直是空，只有一层的时候对，请问，多层json用对象怎么解析，百度的东西已用，未解决 { “users”: [ { \id\: 2783110155, \idstr\: \...
收起

安卓json的解析

2014-09-04 21:41:45

方法一（使用安卓包含的JSON解析类） import org.json.JSONArray; import org.json.JSONObject; import org.json.JSONTokener; try { JSONTokener tokener = new JSONTokener(json...


本文由PurpleSword(jzj1993)原创，转载请注明

原文网址 http://blog.csdn.net/jzj1993



方法一（使用安卓包含的JSON解析类）





import org.json.JSONArray;
import org.json.JSONObject;
import org.json.JSONTokener;



    try {
        JSONTokener tokener = new JSONTokener(json);
        JSONObject joResult = new JSONObject(tokener);
        JSONArray words = joResult.getJSONArray("ws");
        for (int i = 0; i < words.length(); i++) {
            JSONArray items = words.getJSONObject(i).getJSONArray("cw");
            JSONObject obj = items.getJSONObject(0);
            chComTmp = outerparseCom(obj.getString("w"));
        }
    } catch (Exception e) {
        e.printStackTrace();
    }




方法二（使用谷歌开源项目Gson，需要gson.jar程序库的支持）


按照json的嵌套格式定义类，其中各种变量名称和json变量名相同（int，String等类型皆可支持），数组则使用List格式，然后用new Gson().fromJson(json, WeatherResult.class)进行解析（注意用try…catch捕获异常）。


添加gson.jar程序库到Java或安卓工程的方法：jar文件放到项目下的libs文件夹中，右击jar文件，菜单中选择BuildPath-->Add
 to BuildPath即可。




import com.google.gson.Gson;
import com.google.gson.JsonSyntaxException;




public class WeatherResult {

    private String error; // 0
    private String status; // "success"
    private String date; // "2014-03-26"
    private List<Results> results;

    private WeatherResult() {

    }

    public static WeatherResult fromJson(String json) {
        try {
            return new Gson().fromJson(json, WeatherResult.class);
        } catch (JsonSyntaxException e) {
            return null;
        }
    }

    public class Results {

        protected String currentCity; // "北京"
        protected List<WeatherData> weather_data;

        public class WeatherData {
            protected String date; // "周三(今天, 实时：23℃)" / "周四"
            protected String weather; // "霾" / "多云转阵雨" / "阴转多云"
            protected String wind; // "微风"
            protected String temperature; // "22 ~ 10℃"
        }
    }
}

收起

展开全文

安卓json开发误区
2016-02-15 00:30:14
1、以前写Java程序时，进行json开发必须引入对应jar包，但是android环境下，java里面生成解析json串的jar包与android中自带的冲突，所以要用安卓自带的 2、 class Student { private String name; private int ...
收起
安卓Json和Gson
2016-10-27 10:53:39
JSON (官网) 是一种文本形式的数据交换格式，它比XML更轻量、比二进制容易阅读和编写，调式也更加方便。其重要性不言而喻。解析和生成的方式很多，Java中最常用的类库有：JSON-Java、Gson、Jackson、FastJson等。相...
收起
安卓 json date类型数据
2016-04-27 08:48:17
将date类型数据放入json中时出现未知缓冲区错误是为什么？ JSONObject jo = new JSONObject(); jo.put("Birthday",new Date());
收起
android 数据
安卓Json解析详解
2015-03-19 15:38:40
JSON的定义：一种轻量级的数据交换格式，具有良好的可读和便于快速编写的特性。业内主流技术为其提供了完整的解决方案（有点类似于正则表达式，获得了当今大部分语言的支持），从而可以在不同平台间进行数据...
收起
关于安卓json解析中的一个问题
2017-07-31 14:30:06
JsonParser类解析json现在开发还用么？？ ![图片说明](https://img-ask.csdn.net/upload/201707/31/1501511270_472848.jpg) 和直接 ``` ArrayList<Category> categories = (ArrayList) GsonUtil.parseJsonToList...
收起
安卓JSON解析初步探讨
2014-04-06 18:38:17
因为项目中要用到JSON解析，所以
收起
安卓Json数据的解析
2014-04-25 22:48:49
Json：一种key--Value 形式的
收起
android
安卓json解析后的数组的应用
2016-10-12 03:05:37
用json解析数据后也实现了带入数组，可是在用的时候报空指针，求大神指教应该怎么改![图片说明](https://img-ask.csdn.net/upload/201610/12/1476241534_467197.png)
收起
浅淡安卓json的三种解析
2016-12-21 23:29:19
JSON对于移动设备来说，尤其对于网络环境较差和流量限制的情况下，相对于XML格式的数据传输会更节省流量，传输效率更高。在这三种解析方式中FastJson是效率最高的，推荐使用。一、什么是JSON？ JSON是...
收起
安卓 json解析如何使用与讲解
千次阅读 2016-04-09 17:27:50
JSON的定义：一种轻量级的数据交换格式，具有良好的可读和便于快速编写的特性。业内主流技术为其提供了完整的解决方案（有点类似于正则表达式，获得了当今大部分语言的支持），从而可以在不同平台间进行数据...
收起
android
安卓Json介绍（转）。
2015-12-30 09:41:00
1、JSON(JavaScript Object Notation) 定义：一种轻量级的数据交换格式，具有良好的可读和便于快速编写的特性。业内主流技术为其提供了完整的解决方案（有点类似于正则表达式，获得了当今大部分语言的支持），...
收起
安卓JSON数据解析，求大神指教
2016-11-28 08:14:30
从后台获取一段数据后用JSONBOJECT解析成功，但数据中还有一段数据需要解析，此时应该用什么方法解析？JSONOBJECT没有解析出来，求大神指教还能用什么方法解析出来
收起
android
安卓json解析——12306查询票价的字符串解析
2016-09-01 20:28:45
突然看到群里有2个同学都在问关于json数据解析的问题，当然很多人用工具解析，都忘记是怎么解析，那我就先贴一下原始数据吧： {"reason":"查询成功","result":{"list":[{"train_no":"K599","train_type":"","start_...
收起
安卓json解析后怎么建model新人求指教
2016-04-20 17:43:22
[img=https://img-bbs.csdn.net/upload/201604/20/1461145383_720152.png][/img] 求大神帮我分析下，谢谢
收起
删除文件及文件夹,接收安卓json数据,select框函数封装
2017-07-03 11:28:35
该函数功能：1、删除目录及目录下所有的文件2、删除目录下的所有文件但目录结构保留3、删除指定文 /** +----------------------------------------------------------------------------------------- ...
收起
安卓Json请求报错java.lang.NoClassDefFoundError: Failed resolution of: Lorg/apache/...
2020-01-09 10:33:08
运行Json请求时报错如下： D/NetworkSecurityConfig: No Network Security Config specified, using platform default E/AndroidRuntime: FATAL EXCEPTION: Thread-3 Process: net.syp.demo501, PID: 14213 java....
收起
安卓解析json
2019-10-05 02:55:08
重点是开启网络权限难点是调用函数开启网络权限 </application> <uses-permission android:name="android.permission.INTERNET"> </uses-permission>...读json的函数 p...
收起

安卓JSON初学

安卓JSON初学

通过解析JSON数据来获取天气信息

安卓json解析数组后的应用

安卓Json解析

一原生解析

安卓Json操作

安卓 json解析

安卓json的解析

安卓json开发误区

安卓Json和Gson

安卓 json date类型数据

安卓Json解析详解

关于安卓json解析中的一个问题

安卓JSON解析初步探讨

安卓Json数据的解析

安卓json解析后的数组的应用

浅淡安卓json的三种解析

安卓 json解析如何使用与讲解

安卓Json介绍（转）。

安卓JSON数据解析，求大神指教

安卓json解析——12306查询票价的字符串解析

安卓json解析后怎么建model新人求指教

删除文件及文件夹,接收安卓json数据,select框函数封装

安卓Json请求报错java.lang.NoClassDefFoundError: Failed resolution of: Lorg/apache/...

安卓解析json

一个很不错的visual c++ vc内存池的源码,本人在项目中使用.很有价值.zip

浙大版《数据结构（第2版）》题目集习题2.5 两个有序链表序列的合并 (15分)

maven-3.6.0已配好国内镜像地址

2.4 LinkedList 源码解析

windows xp3 sam

flash actionscript3游戏编程之AS3 PureMVC设计模式在AS中的应用例子_详解MVC的作用.zip

360360安全卫士.e

如何实现Envoy 动态配置一个简单的控制平面

为什么PHP在很多公司遭到弃用？

pyqt5+py3.7打包ui界面

【数据分析-随到随学】Hive详解

（新）备战2021软考信息安全工程师顺利通关套餐

广州大学数值分析学习资料.zip

uni-app实战专题

python办公自动化技巧

【Andriod Studio学习】6.线程

阿里巴巴-大数据工程师必读手册.pdf

（新）备战2021软考软件设计师顺利通关套餐

三级网络未来教育2020版最新.zip

浙江、江苏移动数码SM代工M301H 不拆机room