json转换及相关解析方法

一、json转换

public class Test{
  public static void main(String[] args) {


      //1.json数组转list对象存储
    jsonToListObject();

        // 2.创建json对象
        //createJSONObject();

        //3.创建 JSONArray
        //createJsonArray();
        //4.String 转换为 JSONObject 对象
        String str="{test1':'11','test2':'12','test3':'13'}";
        //StringToJson(str);

        //5.JSONObject 转换为 String
        //JsonToSTring();
    }

    private static void JsonToSTring() {
        // TJSONObject 转换为 String
        JSONObject json = new JSONObject();
        //向json中添加数据
        json.put("name", "tom");
        json.put("height", 175);
        json.put("age", 24);
        System.out.println(json);

        //创建JSONArray数组，并将json添加到数组
        JSONArray array = new JSONArray();
        array.add(json);

        //转换为字符串
        String jsonStr = array.toString();

        System.out.println(jsonStr);
    }

    private static void StringToJson(String str) {
        //（解析json） String 转换为 JSONObject 对象
        JSONObject json = (JSONObject)JSONObject.parse(str);
        //遍历jsonObject出来的是 key /value ，get(key)是value
        Iterator it = json.keySet().iterator();
        while (it.hasNext()) {
            String key = it.next().toString();
            String value = String.valueOf(json.get(key));
            System.out.println(key + ":" + value);
        }
    }

    private static void createJsonArray() {
        //  创建 JSONArray
         JSONArray jsonarray = new JSONArray();

            JSONObject node = new JSONObject();
            node.put("name","tom");
            node.put("age",20);
            jsonarray.add(node);

            node = new JSONObject();
            node.put("name","jack");
            node.put("age",15);
            jsonarray.add(node);
            System.out.println(jsonarray);
    }
    private static void jsonToListObject() {
        // json数组转list对象存储
        //JSON字符串
        String result="[{'test1':'12','test2':'13','test3':'14'}]";
         // 转换成JSON数组
       JSONArray array = JSONArray.fromObject(result);
       System.out.println(array);
         // JSON数组转换成存储对象的集合
       List<?> list2 = JSONArray.toList(array, new TestBean(), new JsonConfig());//参数1为要转换的JSONArray数据，参数2为要转换的目标数据，即List盛装的数据
          //获取集合中的第一个对象
       TestBean dzBean = (TestBean) list2.get(0);
          //测试一下属性值
         System.out.println("------------------------"+dzBean.getTestId());

       //创建json对象
       createJSONObject();

       //解析json对象
    }
    private static void createJSONObject() {
        // 创建json对象
         JSONObject jsonObject = new JSONObject();
            jsonObject.put("name", "Jason");
            jsonObject.put("id", 1);
            jsonObject.put("phone", "13566666666");
            System.out.println(jsonObject.toString());
    }
  }
 }
 class TestBean{
 	public String testId;
   public String name;
   public String age;
   public void setTestId(String testId){
   	this.testId = testId;
   }
   public String getTestId(){
   	 return testId;
   }
   public String getName() {
      return name;
   }

   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }

   public void setAge(String age) {
      this.age = age;
   }

 }

二、JSON的三种解析方式

JSON的常用两种解析方式
一、什么是JSON？
JSON是一种取代XML的数据结构,和xml相比,它更小巧但描述能力却不差,由于它的小巧所以网络传输数据将减少更多流量从而加快速度。
JSON就是一串字符串 只不过元素会使用特定的符号标注。
{} 双括号表示对象
[] 中括号表示数组
"" 双引号内是属性或值
: 冒号表示后者是前者的值(这个值可以是字符串、数字、也可以是另一个数组或对象)
所以 {"name": "Michael"} 可以理解为是一个包含name为Michael的对象
而[{"name": "Michael"},{"name": "Jerry"}]就表示包含两个对象的数组
当然了,你也可以使用{"name":["Michael","Jerry"]}来简化上面一部,这是一个拥有一个name数组的对象
二、JSON解析之传统的JSON解析
1、生成json字符串
public static String createJsonString(String key, Object value) {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put(key, value);
        return jsonObject.toString();
}
2、解析JSON字符串
分为以下三种情况，一个JavaBean，一个List数组，一个嵌套Map的List数组：
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

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

import com.android.myjson.domain.Person;

/**
 * 完成对json数据的解析
 * 
 */
public class JsonTools {


    public static Person getPerson(String key, String jsonString) {
        Person person = new Person();
        try {
            JSONObject jsonObject = new JSONObject(jsonString);
            JSONObject personObject = jsonObject.getJSONObject("person");
            person.setId(personObject.getInt("id"));
            person.setName(personObject.getString("name"));
            person.setAddress(personObject.getString("address"));
        } catch (Exception e) {
            // TODO: handle exception
        }
        return person;
    }

    public static List getPersons(String key, String jsonString) {
        List list = new ArrayList();
        try {
            JSONObject jsonObject = new JSONObject(jsonString);
            // 返回json的数组
            JSONArray jsonArray = jsonObject.getJSONArray(key);
            for (int i = 0; i < jsonArray.length(); i++) {
                JSONObject jsonObject2 = jsonArray.getJSONObject(i);
                Person person = new Person();
                person.setId(jsonObject2.getInt("id"));
                person.setName(jsonObject2.getString("name"));
                person.setAddress(jsonObject2.getString("address"));
                list.add(person);
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
        return list;
    }

    public static List getList(String key, String jsonString) {
        List list = new ArrayList();
        try {
            JSONObject jsonObject = new JSONObject(jsonString);
            JSONArray jsonArray = jsonObject.getJSONArray(key);
            for (int i = 0; i < jsonArray.length(); i++) {
                String msg = jsonArray.getString(i);
                list.add(msg);
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
        return list;
    }

    public static List> listKeyMaps(String key,
            String jsonString) {
        List> list = new ArrayList>();
        try {
            JSONObject jsonObject = new JSONObject(jsonString);
            JSONArray jsonArray = jsonObject.getJSONArray(key);
            for (int i = 0; i < jsonArray.length(); i++) {
                JSONObject jsonObject2 = jsonArray.getJSONObject(i);
                Map map = new HashMap();
                Iterator iterator = jsonObject2.keys();
                while (iterator.hasNext()) {
                    String json_key = iterator.next();
                    Object json_value = jsonObject2.get(json_key);
                    if (json_value == null) {
                        json_value = "";
                    }
                    map.put(json_key, json_value);
                }
                list.add(map);
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
        return list;
    }
}
FastJSON
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;

public class JsonTool {

    public static  T getPerson(String jsonstring, Class cls) {
        T t = null;
        try {
            t = JSON.parseObject(jsonstring, cls);
        } catch (Exception e) {
            // TODO: handle exception
        }
        return t;
    }

    public static  List getPersonList(String jsonstring, Class cls) {
        List list = new ArrayList();
        try {
            list = JSON.parseArray(jsonstring, cls);
        } catch (Exception e) {
            // TODO: handle exception
        }
        return list;
    }

    public static  List> getPersonListMap1(
            String jsonstring) {
        List> list = new ArrayList>();
        try {
            list = JSON.parseObject(jsonstring,
                    new TypeReference>>() {
                    }.getType());

        } catch (Exception e) {
            // TODO: handle exception
        }

        return list;
    }
}

JSON对于移动设备来说，尤其对于网络环境较差和流量限制的情况下，相对于XML格式的数据传输会更节省流量，传输效率更高。在这三种解析方式中FastJson是效率最高的，推荐使用。
JSONObject、JSONArray区别
　json，就是一个键对应一个值，超级简单的一对一关系。现在用到的json那可以层层嵌套啊，刚开始接触的时候，确实有种崩溃的赶脚，不想去理，取个数据还那么麻烦。其实，就跟if else语句一样，如果if中套if，if中再套if，写的规范了还行，要是代码格式不规范，那我们肯定也看着麻烦。所以啊，对于json嵌套，只要记住符号“：”前是键，符号后是值大括号成对找，一层层剥开，就清楚了。 举个例子说明，如下：
[{name1:{name2:{name3:‘value1’,name4:‘value2’}}},{}]
　　从外到里看，例子中就是一个数组，数组里面是两个json格式的字符串。这样分析思路就清晰多了。
     工作中需要取出name4的值，你们会怎么取呢？。最初我都想过字符串截取，那时还不了解JSONArray，现在知道了，取出来也就相当容易了。
     取出name4值过程步骤：1，将以上字符串转换为JSONArray对象；2，取出对象的第一项，JSONObject对象；3，取出name1的值JSONObject对象；4，取出name2的值JSONObject对象；5，取出name4的值value2。
    示例中json数组格式的字符串可以通过方法直接转换为JSONArray的格式:
　　JSONArray.fromObject(String)
JSONArray getJsonArray=JSONArray.fromObject(arrayStr);//将结果转换成JSONArray对象的形式  
JSONObject getJsonObj = getJsonArray.getJSONObject(0);//获取json数组中的第一项  
String result=getJsonObj.getJSONObject(“name1”).getJSONObject(“name2”).getJSONObject(“name4”); 
好了我们说说这两个对象。
1，JSONObject
  json对象，就是一个键对应一个值，使用的是大括号{ }，如：{key:value}
2，JSONArray
  json数组，使用中括号[ ],只不过数组里面的项也是json键值对格式的
  Json对象中添加的是键值对，JSONArray中添加的是Json对象
JSONObject Json = new JSONObject();  
JSONArray JsonArray = new JSONArray();  
  
Json.put(“key”, “value”);//JSONObject对象中添加键值对  
JsonArray.add(Json);//将JSONObject对象添加到Json数组中  
3，JSONObject与Map
    Map map和json都是键值对，不同的是map中键值对中间用等号分开，json中键值对中间用冒号分开。其实json就是一种特殊形式的map。
Map<String,String> strmap=new JSONObject();  
    这里的需求是：request对象获取的map