java基础梳理：json转化

以下针对json转化，有：

1 字符串转json数组,遍历json数组内容
2 字符串转json数组，遍历json数组内容 ,将json对象依次转化成bean形式
3 bean转换成json对象数据
4 bean转换成json字符串数据
5 json串转bean
6 json对象转bean
7 获取json字符串里嵌套的json串的一个值
8 字符串和map互转

测试demo如下：

package com.ms.ebdt.json.util;
import java.math.BigDecimal;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.json.JSONException;
import com.alibaba.fastjson.JSON;
import com.ms.ebdt.json.util.exception.PlatformException;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
/**
 * 可以参考学习的
 * https://www.cnblogs.com/wangf-keep/p/6480019.html
 * https://www.cnblogs.com/sharpest/p/7844533.html
 * https://www.cnblogs.com/yuxiaoyu/archive/2016/10/09/5941560.html
 * https://www.cnblogs.com/webwangjin/p/6170994.html
 * */
/**把我放到你的程序里吧，嘻嘻*/
public class JsonUtil {
    public static Log logger = LogFactory.getLog(PrincipalScale.class);

    public static void main(String[] args) {

        //字符串转json数组并且遍历内容 
        Str2JsonArrayAndTraversingJson1();

        //字符串转json数组并且遍历内容 ，把每条json转成实体bean
        Str2JsonArrayAndTraversingPerJsonTransBean2();

        bean2JsonObject3();

        bean2JsonStr4();

        JsonStrtoBean5();

        JsonObject2Bean6();

        catchJsonStrNestJsonStrPervalue7();

        str2MapAndMap2Str8();
    }

    /** 字符串转json数组,遍历json数组内容 
     * 注意：字符串格式为[{phaseNumber:'a',pri:'12'},{name:'b',value:'34'},{name:'c',value:'56'},{name:'d',value:'78'}]
     * */
    public static void Str2JsonArrayAndTraversingJson1() {
        logger.info("1 Str2JsonArray  AndTraversingJson  字符串转json数组,遍历json数组内容 ");
        String str = "[{phaseNumber:'1',prinScale:'0.12'},{phaseNumber:'2',prinScale:'0.34'},{phaseNumber:'3',prinScale:'0.56'},{phaseNumber:'4',prinScale:'0.78'}]";
        //字符串转成 JSONArray  对象
        net.sf.json.JSONArray json = JSONArray.fromObject(str);

        if (json.size() > 0) {
            for (int i = 0; i < json.size(); i++) {
                net.sf.json.JSONObject job = json.getJSONObject(i); // 遍历 jsonarray 数组，把每一个对象转成 json 对象
                logger.info("第" + job.get("phaseNumber") + "期，金额比例：" + job.get("prinScale")); // 得到 每个对象中的属性值
            }
        }
    }

    /** 字符串转json数组，遍历json数组内容 ,将json对象依次转化成bean形式，好处：数据结构直接能对应上 ，不用转化数据类型
     * 注意：字符串格式为[{phaseNumber:'a',pri:'12'},{name:'b',value:'34'},{name:'c',value:'56'},{name:'d',value:'78'}]
     * */
    public static void Str2JsonArrayAndTraversingPerJsonTransBean2() {
        logger.info("2 Str2JsonArray  AndTraversingPerJson2Bean   字符串转json数组，遍历json数组内容 ,将json对象依次转化成bean形式");
        String str = "[{phaseNumber:'1',prinScale:'0.12'},{phaseNumber:'2',prinScale:'0.34'},{phaseNumber:'3',prinScale:'0.56'},{phaseNumber:'4',prinScale:'0.78'}]";
        //字符串转成 JSONArray  对象
        net.sf.json.JSONArray json = JSONArray.fromObject(str);
        if (json.size() > 0) {
            for (int i = 0; i < json.size(); i++) {
                net.sf.json.JSONObject job = json.getJSONObject(i);
                PrincipalScale printScale = (PrincipalScale) JSONObject.toBean(job, PrincipalScale.class);
                logger.info("第" + printScale.getPhaseNumber() + "期，金额比例：" + printScale.getPrinScale()); // 得到 每个对象中的属性值
            }
        }
    }

    /**一般放在实体bean内部 定义
     *  dto转换成json对象数据
     * @return
     */
    public static void bean2JsonObject3() {
        logger.info("3 bean  toJsonObject ，dto转换成json对象数据");
        PrincipalScale dto = new PrincipalScale();
        dto.setPhaseNumber(1);
        dto.setPrinScale(new BigDecimal("0.56"));
        String str = JSON.toJSONString(dto);
        org.json.JSONObject jsonObj;
        try {
            jsonObj = new org.json.JSONObject(str);
            logger.info(jsonObj.get("phaseNumber") + ":" + jsonObj.get("prinScale"));
        } catch (JSONException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /** 一般放在实体bean内部 定义
     *  dto转换成json字符串数据
     */
    public static String bean2JsonStr4() {
        logger.info("4 dto转换成json字符串数据");
        PrincipalScale dto = new PrincipalScale();
        dto.setPhaseNumber(1);
        dto.setPrinScale(new BigDecimal("0.35"));
        String str = JSON.toJSONString(dto);
        logger.info(str);
        return str;
    }

    /**
     * 一般放在实体bean内部 定义  
     *  好处：数据结构直接能对应上 ，不用转化数据类型
     * 注意：字符串格式为{phaseNumber:'a',pri:'12'}
     * 将json字符串数据转换成 bean
     */
    public static PrincipalScale JsonStrtoBean5() {
        logger.info("5 JsonStr to Bean，json串转bean");
        String jsonStr = "{'phaseNumber':'1','prinScale':'0.12'}";
        try {
            if (jsonStr == null) {
                throw new PlatformException("参数为空");
            }
            PrincipalScale dto = com.alibaba.fastjson.JSONObject.parseObject(jsonStr, PrincipalScale.class);
            logger.info("第" + dto.getPhaseNumber() + "期，金额比例：" + dto.getPrinScale()); // 得到 每个对象中的属性值
            return dto;
        } catch (Exception e) {
            logger.info("获取数据出现异常：" + e.getMessage() + ";" + jsonStr);
            return null;
        }
    }

    /**
     * 一般放在实体bean内部 定义
     * 将json对象数据转换成 bean
     * @param json
     * @return
     * @throws PhaseException 
     */
    public static PrincipalScale JsonObject2Bean6() {
        logger.info("6 JsonObject2Bean，json对象转bean");
        JSONObject json = new JSONObject();
        json.put("phaseNumber", 1);
        json.put("prinScale", 12);
        try {
            if (json == null) {
                throw new PlatformException("参数为空");
            }
            PrincipalScale dto = (PrincipalScale) net.sf.json.JSONObject.toBean(json, PrincipalScale.class);
            logger.info("第" + dto.getPhaseNumber() + "期，金额比例：" + dto.getPrinScale()); // 得到 每个对象中的属性值
            return dto;
        } catch (Exception e) {
            logger.info("获取数据出现异常：" + e.getMessage() + ";" + json);
            return null;
        }
    }

    /**
     * 获取json串里的json串某个key对应的value值
     * 获取json里嵌套的json里的一个值*/
    public static void catchJsonStrNestJsonStrPervalue7() {
        logger.info("7 获取json字符串里嵌套的json串的一个值");
        String jsonStr = "{'id':'11','parentId':'root','refObj':{'existType':'exist','deptType':'emp','treeNodeType':'dept'}}";
        JSONObject jsonObject = JSONObject.fromObject(jsonStr);
        try {
            JSONObject refObj = (JSONObject) jsonObject.get("refObj");
            String existType = refObj.getString("deptType");
            logger.info(existType);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**字符串和map互转*/
    public static void str2MapAndMap2Str8() {
        logger.info("str2MapAndMap2Str8 ，字符串和map互转");
        String json = "{'name':'张三','age':'20','xb':'男','zzmm':'newValue'}";
        //json转成Map
        Map<String, String> value = JSON.parseObject(json, Map.class);
        logger.info("name=" + value.get("name"));

        //map转json
        String toJson = JSON.toJSONString(value);//重新转成json字符串，｛“name”:"张三","age":"20","xb":“男”,"zzmm":"newValue"｝
        logger.info("map转json串===" + toJson);
    }
}

以及bean:

package com.ms.ebdt.json.util;
import java.math.BigDecimal;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.ms.ebdt.json.util.exception.PlatformException;
import net.sf.json.JSONArray;

public class PrincipalScale {
    public static Log logger = LogFactory.getLog(PrincipalScale.class);

    /**
     * 期数
     */
    private int phaseNumber;

    /**
     * 本金百分比
     */
    private BigDecimal prinScale;

    public int getPhaseNumber() {
        return phaseNumber;
    }

    public void setPhaseNumber(int phaseNumber) {
        this.phaseNumber = phaseNumber;
    }

    public BigDecimal getPrinScale() {
        return prinScale;
    }

    public void setPrinScale(BigDecimal prinScale) {
        this.prinScale = prinScale;
    }

    @Override
    public String toString() {
        return "PrincipalScale [phaseNumber=" + phaseNumber + ", prinScale=" + prinScale + "]";
    }

    /**
     *  dto转换成json数据
     * @param protocol
     * @return
     */
    public static String toJson(PrincipalScale dto) {

        return JSON.toJSONString(dto);
    }

    /**
     * 将json数据转换成 bean
     * @param json
     * @return
     * @throws PhaseException 
     */
    public static PrincipalScale JsonStrtoBean(String jsonStr) {
        try {
            if (jsonStr == null) {
                throw new PlatformException("参数为空");
            }
            /*PrincipalScale printScale = (PrincipalScale) net.sf.json.JSONObject.toBean(jsonObject,
                    PrincipalScale.class);*/
            PrincipalScale dto = JSONObject.parseObject(jsonStr, PrincipalScale.class);
            return dto;
        } catch (Exception e) {
            logger.info("获取数据出现异常：" + e.getMessage() + ";" + jsonStr);
            return null;
        }
    }

    /**
     * 将json数据转换成 bean
     * @param json
     * @return
     * @throws PhaseException 
     */
    public static PrincipalScale JsonObject2toBean(net.sf.json.JSONObject jsonObject) {
        try {
            if (jsonObject == null) {
                throw new PlatformException("参数为空");
            }
            PrincipalScale dto = (PrincipalScale) net.sf.json.JSONObject.toBean(jsonObject, PrincipalScale.class);
            return dto;
        } catch (Exception e) {
            logger.info("获取数据出现异常：" + e.getMessage() + ";" + jsonObject);
            return null;
        }
    }
    /*java 字符串转成 json 数组并且遍历
    当需要把一串字符串转成一个json 数组 ，并遍历其中的内容时。

    首先要导入 net.sf.json.JSONArray和net.sf.json.JSONObject 两个jar 包*/

    public static void main(String[] args) {
        PrincipalScale dto = new PrincipalScale();
        dto.setPhaseNumber(1);
        dto.setPrinScale(new BigDecimal("0.34567"));
        System.out.println(dto.getPrinScale());
        String tostr = toJson(dto);
        System.out.println(tostr);
        PrincipalScale a = JsonStrtoBean(tostr);
        System.out.println(a.getPhaseNumber() + "," + a.getPrinScale() + "***************************");

        String str = "[{name:'a',value:'aa'},{name:'b',value:'bb'},{name:'c',value:'cc'},{name:'d',value:'dd'}]"; // 一个未转化的字符串

        JSONArray json = JSONArray.fromObject(str); // 首先把字符串转成 JSONArray  对象

        if (json.size() > 0) {
            for (int i = 0; i < json.size(); i++) {
                net.sf.json.JSONObject job = json.getJSONObject(i); // 遍历 jsonarray 数组，把每一个对象转成 json 对象
                System.out.println(job.get("name") + "=" + job.get("value")); // 得到 每个对象中的属性值
            }
        }
    }
}