基於json-lib-2.2.2-jdk15.jar的JSON解析工具類大集合

　　json解析之前的必備工作：導入json解析必須的六個包

　　資源鏈接：百度雲：鏈接：https://pan.baidu.com/s/1dAEQQy 密碼：1v1z

代碼示例：

package com.sc.utils;

import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

public class JSONUtil2 {

    private static final Log log = LogFactory.getLog(JSONUtil2.class);
    
    /**
     * 向客戶端輸出JSON
     */
    public static void outputJson(HttpServletResponse response, JSONObject json)
            throws Exception {
        response.setCharacterEncoding("UTF-8");
        PrintWriter out = response.getWriter();
        out.write(json.toString());
        out.flush();
    }
    
    
    /**
     * 從一個JSON 對象字符格式中得到一個java對象
     *
     */
 
    public static Object toBean(String jsonString, Class beanClass) {
        JSONObject jsonObject = JSONObject.fromObject(jsonString);
        Object object = JSONObject.toBean(jsonObject, beanClass);
        return object;
    }
    
    public static Object toBean(String jsonString, Class beanClass,Map map) {
        JSONObject jsonObject = JSONObject.fromObject(jsonString);
        Object object = JSONObject.toBean(jsonObject, beanClass,map);
        return object;
    }
    
    
    /**
     * 從json對象集合表達式中得到一個java對象列表
     * @param jsonString:數組字符串[{key1:value1,key2:value2},{bean2},{bean3},...]
     * @param pojoClass
     * @return
     */
    public static List toList(String jsonString, Class beanClass) {
        JSONArray jsonArray = JSONArray.fromObject(jsonString);
        List list = new ArrayList();
        for (int i = 0; i < jsonArray.size(); i++) {
            JSONObject jsonObject = jsonArray.getJSONObject(i);
            Object object = JSONObject.toBean(jsonObject, beanClass);
            list.add(object);
        }
        return list;
    }
    
    public static List toList(String jsonString, Class beanClass,Map map) {
        JSONArray jsonArray = JSONArray.fromObject(jsonString);
        List list = new ArrayList();
        for (int i = 0; i < jsonArray.size(); i++) {
            JSONObject jsonObject = jsonArray.getJSONObject(i);
            Object object = JSONObject.toBean(jsonObject, beanClass,map);
            list.add(object);
        }
        return list;
    }
    
    
    
    /**
     * 從json字符串中獲取一個map，該map支持嵌套功能
     * @param jsonString
     * @return
     */
    public static Map toMap(String jsonString) {
        JSONObject jsonObject = JSONObject.fromObject(jsonString);
        Iterator it = jsonObject.keys();
        Map map = new HashMap();
        while (it.hasNext()) {
            String key = (String) it.next();
            Object value = jsonObject.get(key);
            map.put(key, value);
        }
        return map;
    }
    
    
    /**
     * 從json數組中得到相應java數組
     * @param jsonString
     * @return
     */
    public static Object[] toObjectArray(String jsonString) {
        JSONArray jsonArray = JSONArray.fromObject(jsonString);
        return jsonArray.toArray();
    }
    
    
    /**
     * 從json解析出java字符串數組
     * @param jsonString
     * @return
     */
    public static String[] toStringArray(String jsonString) {
        JSONArray jsonArray = JSONArray.fromObject(jsonString);
        String[] stringArray = new String[jsonArray.size()];
        for (int i = 0; i < jsonArray.size(); i++) {
            stringArray[i] = jsonArray.getString(i);
        }
        return stringArray;
    }
    
    
    /**
     * 從json解析出javaLong型對象數組
     * @param jsonString
     * @return
     */
    public static Long[] toLongArray(String jsonString) {
 
        JSONArray jsonArray = JSONArray.fromObject(jsonString);
        Long[] longArray = new Long[jsonArray.size()];
        for (int i = 0; i < jsonArray.size(); i++) {
            longArray[i] = jsonArray.getLong(i);
        }
        return longArray;
    }
    
    
    /**
     * 從json解析出java Integer型對象數組
     * @param jsonString:[1,2,3,4]
     * @return
     */
    public static Integer[] toIntegerArray(String jsonString) {
        JSONArray jsonArray = JSONArray.fromObject(jsonString);
        Integer[] integerArray = new Integer[jsonArray.size()];
        for (int i = 0; i < jsonArray.size(); i++) {
            integerArray[i] = jsonArray.getInt(i);
        }
        return integerArray;
    }
    
    
    /**
     * 從json中解析出java Double型對象數組
     * @param jsonString
     * @return
     */
    public static Double[] toDoubleArray(String jsonString) {
        JSONArray jsonArray = JSONArray.fromObject(jsonString);
        Double[] doubleArray = new Double[jsonArray.size()];
        for (int i = 0; i < jsonArray.size(); i++) {
            doubleArray[i] = jsonArray.getDouble(i);
        }
        return doubleArray;
    }
    
    
    /**
     * 將java對象轉換成json字符串
     * @param javaObj
     * @return
     */
    public static String toJsonString(Object object) {
        JSONObject json = JSONObject.fromObject(object);
        return json.toString();
    }
    
    
    /*
     * 將java對象轉化為json數組字符串
     * [{"name":"name1","id":"id1"},{"name":"name2","id":"id2"}]
     */
    public static String toJsonArrayString(List<Object> list) {
        JSONArray jsonArray = JSONArray.fromObject(list);
        return jsonArray.toString();
    }
    
}

 

package com.sc.utils;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.commons.beanutils.BeanUtils;

import com.sc.bean.MyTeam;
import com.sc.bean.OnethinkUser;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

public class JSONUtils {

    /**
     * @author 16616
     * @date 2018-01-13
     */
    
    
    /**
     * （1）將list對象序列化為JSON文本
     * @param list：list對象
     * @return
     */
    public static <T> String toJSONString(List<T> list){
        JSONArray jsonArray=JSONArray.fromObject(list);
        return jsonArray.toString();
    }
    
    
    /**
     * （2）將對象序列化為JSON文本
     * @param object:對象
     * @return
     */
    public static String toJSONString(Object object){
        JSONArray jsonArray=JSONArray.fromObject(object);
        return jsonArray.toString();
    }
    
    
    /**
     * （3）將JSON對象數組序列化為JSON文本
     * @param jsonArray：json對象數組
     * @return
     */
    public static String toJSONString(JSONArray jsonArray){
        return jsonArray.toString();
    }
    
    
    /**
     * （4）將JSON對象序列化為JSON文本
     * @param jsonObject
     * @return
     */
    public static String toJSONString(JSONObject jsonObject){
        return jsonObject.toString();
    }
    
    
    /**
     * (5)將對象轉換為List對象（先將對象序列化為JSON對象數組，再將json對象數組轉換為List對象）
     * @param object：對象
     * @return
     */
    public static List toArrayList(Object object){
        List arrayList=new ArrayList();
        //將對象序列化為JSON對象數組
        JSONArray jsonArray=JSONArray.fromObject(object);
        //將json對象數組轉換為List對象
        Iterator it=jsonArray.iterator();
        while(it.hasNext()){
            JSONObject jsonObject=(JSONObject) it.next();
            Iterator keys=jsonObject.keys();
            while(keys.hasNext()){
                Object key=keys.next();
                Object value=jsonObject.get(key);
                arrayList.add(value);
            }
        }
        return arrayList;
    }
    
    
    /**
     * （6）將對象轉換為Collection對象（先將對象序列化為JSON對象數組，再將json對象數組轉換為Collection對象）
     * @param object：對象
     * @return
     */
    public static Collection toCollection(Object object){
        //將對象序列化為JSON對象數組
        JSONArray jsonArray=JSONArray.fromObject(object);
        return JSONArray.toCollection(jsonArray);
    }
    
    
    /**
     * （7）將對象轉換為JSON對象數組
     * @param object：對象
     * @return
     */
    public static JSONArray toJSONArray(Object object){
        return JSONArray.fromObject(object);
    }
    
    
    /**
     * （8）將對象轉換為JSON對象
     * @param object：對象
     * @return
     */
    public static JSONObject toJSONObject(Object object){
        return JSONObject.fromObject(object);
    }
    
    
    /**
     * （9）將對象轉換為HashMap
     * @param object：對象
     * @return
     */
    public static HashMap toHashMap(Object object){
        HashMap<String, Object> data=new HashMap<String, Object>();
        /*JSONObject jsonObject=JSONObject.fromObject(object);*/
        JSONObject jsonObject=JSONUtils.toJSONObject(object);
        Iterator it=jsonObject.keys();
        while(it.hasNext()){
            String key=String.valueOf(it.next());
            Object value=jsonObject.get(key);
            data.put(key, value);
        }
        return data;
    }
    
    
    /**
     * （10）將對象轉換為List（返回非實體類型（Map）的List
     * @param object：對象
     * @return
     */
    public static List<Map<String,Object>> toList(Object object){
        List<Map<String,Object>> list=new ArrayList<Map<String,Object>>();
        JSONArray jsonArray=JSONArray.fromObject(object);
        for(Object obj:jsonArray){
            JSONObject jsonObject=(JSONObject) obj;
            Map<String, Object> map=new HashMap<String, Object>();
            Iterator it=jsonObject.keys();
            while(it.hasNext()){
                String key=(String) it.next();
                Object value=jsonObject.get(key);
                map.put(key, value);
            }
            list.add(map);
        }
        return list;
    }
    
    
    /**
     * （11）將JSON對象數組轉換為傳入類型的List
     * @param jsonArray：json對象數組
     * @param objectClass：要轉換成的list類型
     * @return
     */
    public static <T> List<T> toList(JSONArray jsonArray,Class<T> objectClass){
        return JSONArray.toList(jsonArray, objectClass);
    }
    
    
    /**
     * （12）將對象轉換為傳入類型的List（先將對象轉換為JSON對象，再按照上面的方法轉換）
     * @param object：對象
     * @param objectClass：要轉換成的list類型
     * @return
     */
    public static <T> List<T> toList(Object object,Class<T> objectClass){
        JSONArray jsonArray=JSONArray.fromObject(object);
        return JSONArray.toList(jsonArray, objectClass);
    }
    
    
    /**
     * （13）將JSON對象轉換為傳入類型的對象
     * @param jsonObject：json對象
     * @param beanClass：要轉換成的對象的類型
     * @return
     */
    public static <T> T toBean(JSONObject jsonObject,Class<T> beanClass){
        return (T) JSONObject.toBean(jsonObject, beanClass);
    }
    
    
    /**
     * （14）將對象轉換為傳入類型的對象（先將對象轉換為JSON對象，再按照上面的方法）
     * @param object：對象
     * @param beanClass：要轉換成的對象的類型
     * @return
     */
    public static <T> T toBean(Object object,Class<T> beanClass){
        JSONObject jsonObject=JSONObject.fromObject(object);
        return (T) JSONObject.toBean(jsonObject, beanClass);
    }
    
    
    
    /**
     * （15）將JSON文本反序列化為主從關系的實體 
     * @param 泛型T 代表主實體類型
     * @param 泛型D 代表從實體類型
     * @param jsonString：JSON文本
     * @param mainClass：主實體類型
     * @param detailName：從實體類在主實體類中的屬性名稱
     * @param detailClass：從實體類型
     * @return
     */
    public static <T,D> T toBean(String jsonString,Class<T> mainClass,
            String detailName,Class<D> detailClass){
        //將json文本轉換成json對象
        JSONObject jsonObject=JSONObject.fromObject(jsonString);
        //獲得json對象中從實體類的json對象
        JSONArray jsonArray=(JSONArray) jsonObject.get(detailName);
        //將JSON對象轉換為主實體類型
        T mainEntity=JSONUtils.toBean(jsonObject, mainClass);
        //將JSON對象數組轉換為從實體類型的list
        List<D> detailList=JSONUtils.toList(jsonArray, detailClass);
        //利用BeanUtils，放入對象中
        try {
            BeanUtils.setProperty(mainEntity, detailName, detailList);
        } catch (Exception  e) {
            throw new RuntimeException("主從關系JSON反序列化實體失敗！");
        }
        return mainEntity;
    }
    
    
    /**（16）將JSON文本反序列化為主從關系的實體
     * @param 泛型T 代表主實體類型
     * @param 泛型D1 代表從實體類型
     * @param 泛型D2 代表從實體類型
     * @param jsonString：json文本
     * @param mainClass：主實體類性
     * @param detailName1：從實體類在主實體類中的屬性
     * @param detailClass1：從實體類型
     * @param detailName2：從實體類在主實體類中的屬性
     * @param detailClass2：從實體類型
     * @return
     */
    public static <T,D1,D2> T toBean(String jsonString,Class<T> mainClass,
            String detailName1,Class<D1> detailClass1,String detailName2,
            Class<D2> detailClass2){
        JSONObject jsonObject=JSONObject.fromObject(jsonString);
        JSONArray jsonArray1=(JSONArray) jsonObject.get(detailName1);
        JSONArray jsonArray2=(JSONArray) jsonObject.get(detailName2);
        
        T mainEntity=JSONUtils.toBean(jsonObject, mainClass);
        List<D1> detailList1=JSONUtils.toList(jsonArray1, detailClass1);
        List<D2> detailList2=JSONUtils.toList(jsonArray1, detailClass2);
        
        try {
            BeanUtils.setProperty(mainEntity, detailName1, detailList1);
            BeanUtils.setProperty(mainEntity, detailName2, detailList2);
        } catch (Exception ex){
            throw new RuntimeException("主從關系JSON反序列化實體失敗！");
        }
        return mainEntity;
    }
    
    
    /**
     * （17）將JSON文本反序列化為主從關系的實體
     * @param 泛型T 代表主實體類型
     * @param 泛型D1 代表從實體類型
     * @param 泛型D2 代表從實體類型
     * @param jsonString：json文本
     * @param mainClass：主實體類型
     * @param detailName1：從實體類在主實體類中的屬性
     * @param detailClass1：從實體類型
     * @param detailName2：從實體類在主實體類中的屬性
     * @param detailClass2：從實體類型
     * @param detailName3：從實體類在主實體類中的屬性
     * @param detailClass3：從實體類型
     * @return
     */
    public static <T,D1,D2,D3> T toBean(String jsonString,Class<T> mainClass, String detailName1, Class<D1> detailClass1,
            String detailName2, Class<D2> detailClass2, String detailName3,
            Class<D3> detailClass3){
        JSONObject jsonObject = JSONObject.fromObject(jsonString);
        JSONArray jsonArray1 = (JSONArray) jsonObject.get(detailName1);
        JSONArray jsonArray2 = (JSONArray) jsonObject.get(detailName2);
        JSONArray jsonArray3 = (JSONArray) jsonObject.get(detailName3);
        
        T mainEntity = JSONUtils.toBean(jsonObject, mainClass);
        List<D1> detailList1 = JSONUtils.toList(jsonArray1, detailClass1);
        List<D2> detailList2 = JSONUtils.toList(jsonArray2, detailClass2);
        List<D3> detailList3 = JSONUtils.toList(jsonArray3, detailClass3);
        try
        {
            BeanUtils.setProperty(mainEntity, detailName1, detailList1);
            BeanUtils.setProperty(mainEntity, detailName2, detailList2);
            BeanUtils.setProperty(mainEntity, detailName3, detailList3);
        }
        catch (Exception ex)
        {
            throw new RuntimeException("主從關系JSON反序列化實體失敗！");
        }

        return mainEntity;
    }
    
    
    /**
     * （18）將JSON文本反序列化為主從關系的實體
     * @param jsonString：json文本
     * @param mainClass：主實體類型
     * @param detailClass：存放了多個從實體在主實體中屬性名稱和類型
     * @return
     */
    public static <T> T toBean(String jsonString, Class<T> mainClass,
            HashMap<String, Class> detailClass)
    {
        JSONObject jsonObject = JSONObject.fromObject(jsonString);
        T mainEntity = JSONUtils.toBean(jsonObject, mainClass);
        for (Object key : detailClass.keySet())
        {
            try
            {
                Class value = (Class) detailClass.get(key);
                BeanUtils.setProperty(mainEntity, key.toString(), value);
            }
            catch (Exception ex)
            {
                throw new RuntimeException("主從關系JSON反序列化實體失敗！");
            }
        }
        return mainEntity;
    }
    
    
    public static List<MyTeam> jsonToObjectList(String jsonString){
        List<MyTeam> myTeamList=new ArrayList<MyTeam>();
         JSONObject jsonObject = JSONObject.fromObject(jsonString);
         //取出json中的data數據
         JSONObject data = jsonObject.getJSONObject("data");
         JSONObject dataJsonObject=JSONObject.fromObject(data);  
         Map<String, Object> map =dataJsonObject;  
         for (Entry<String, Object> entry : map.entrySet()) {  
             MyTeam myTeam=new MyTeam();
             myTeam.setDaiShu(Integer.parseInt(entry.getKey()));
             //將其轉換為對象
             OnethinkUser onethinkUser=(OnethinkUser)JSONObject.toBean((JSONObject) entry.getValue(), OnethinkUser.class);
             myTeam.setOnethinkUser(onethinkUser);
             myTeamList.add(myTeam);
         } 
        return myTeamList;
        
    }   
    
}

 

package com.sc.utils;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

public class JSONUtils1 {

    /** 
     * 將string轉換成listBean 
     * @param jsonArrStr 需要反序列化的字符串 
     * @param clazz 被反序列化之后的類 
     * @return 實體list 
     */  
    public static List getListFromJsonArrStr(String jsonArrStr, Class clazz) {    
        JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);    
        List list = new ArrayList();    
        for (int i = 0; i < jsonArr.size(); i++)   
        {    
           list.add(JSONObject.toBean(jsonArr.getJSONObject(i), clazz));    
        }    
         return list;    
     }
    
    
    /** 
     * 將string轉換成listBean 屬性中包含實體類等 如List<Student> 而Student中含有屬性List<Teacher> 
     * @param jsonArrStr 需要反序列化的字符串 
     * @param clazz 反序列化后的類 
     * @param classMap 將屬性中包含的如Teacher加入到一個Map中，格式如map.put("teacher",Teacher.class) 
     * @return 反序列化后的字符串 
     * 使用示例： 
        Map classMap = new HashMap(); 
        //必須要對Parent進行初始化 否則不識別 
        Teacher p = new Teacher(); 
        classMap.put("teacher", p.getClass()); 
        List mlist = JSONTransfer.getListFromJsonArrStr(resultStr, Student.class, classMap); 
     */  
    @SuppressWarnings("unchecked")  
    public static List getListFromJsonArrStr(String jsonArrStr, Class clazz, Map classMap)   
    {    
          JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);    
          List list = new ArrayList();    
          for (int i = 0; i < jsonArr.size(); i++)   
          {              
              list.add(JSONObject.toBean(jsonArr.getJSONObject(i), clazz, classMap));    
          }    
          return list;    
    }  
}

 

資源鏈接：鏈接：https://pan.baidu.com/s/1nw6UEuP 密碼：uj4v