精华内容
参与话题
问答
  • 安卓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 .运行程序
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 安卓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官网



    展开全文
  • 安卓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);
    	}
    	
    }
    
    

    展开全文
  • 安卓 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());
  • 安卓Json解析详解

    2015-03-19 15:38:40
    JSON的定义:  一种轻量级的数据交换格式,具有良好的可读和便于快速编写的特性。业内主流技术为其提供了完整的解决方案(有点类似于正则表达式 ,获得了当今大部分语言的支持),从而可以在不同平台间进行数据...
  • 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 形式的
  • json解析数据后也实现了带入数组,可是在用的时候报空指针,求大神指教应该怎么改![图片说明](https://img-ask.csdn.net/upload/201610/12/1476241534_467197.png)
  • JSON对于移动设备来说,尤其对于网络环境较差和流量限制的情况下,相对于XML格式的数据传输会更节省流量,传输效率更高。在这三种解析方式中FastJson是效率最高的,推荐使用。 一、什么是JSONJSON是...
  • 安卓 json解析如何使用与讲解

    千次阅读 2016-04-09 17:27:50
    JSON的定义:  一种轻量级的数据交换格式,具有良好的可读和便于快速编写的特性。业内主流技术为其提供了完整的解决方案(有点类似于正则表达式 ,获得了当今大部分语言的支持),从而可以在不同平台间进行数据...
  • 安卓Json介绍(转)。

    2015-12-30 09:41:00
    1、JSON(JavaScript Object Notation) 定义: 一种轻量级的数据交换格式,具有良好的可读和便于快速编写的特性。业内主流技术为其提供了完整的解决方案(有点类似于正则表达式,获得了当今大部分语言的支持),...
  • 从后台获取一段数据后用JSONBOJECT解析成功,但数据中还有一段数据需要解析,此时应该用什么方法解析?JSONOBJECT没有解析出来,求大神指教还能用什么方法解析出来
  • 突然看到群里有2个同学都在问关于json数据解析的问题,当然很多人用工具解析,都忘记是怎么解析,那我就先贴一下原始数据吧: {"reason":"查询成功","result":{"list":[{"train_no":"K599","train_type":"","start_...
  • [img=https://img-bbs.csdn.net/upload/201604/20/1461145383_720152.png][/img] 求大神帮我分析下,谢谢
  • 该函数功能:1、删除目录及目录下所有的文件2、删除目录下的所有文件但目录结构保留3、删除指定文 /** +----------------------------------------------------------------------------------------- ...
  • 运行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...

空空如也

1 2 3 4 5 ... 20
收藏数 1,896
精华内容 758
关键字:

安卓json