本文目录一览：

• 1、Java解析json数据问题
• 2、java中如何将数据封装为JSON包？
• 3、java 中如何引用json文件
• 4、Java解析json数据
• 5、JAVA 里面 JSON 的包有哪些?
• 6、java怎么将json文件读取进来并转成map

Java解析json数据问题

一、 JSON （JavaScript Object Notation）一种简单的数据格式，比xml更轻巧。

Json建构于两种结构：

1、“名称/值”对的集合（A collection of name/value pairs）。不同的语言中，它被理解为对象（object），纪录（record），结构（struct），字典（dictionary），哈希表（hash table），有键列表（keyed list），或者关联数组 （associative array）。 如：

{

“name”:”jackson”,

“age”:100

}

2、值的有序列表（An ordered list of values）。在大部分语言中，它被理解为数组（array）如：

{

“students”:

[

{“name”:”jackson”,“age”:100},

{“name”:”michael”,”age”:51}

]

}

二、java解析JSON步骤

A、服务器端将数据转换成json字符串

首先、服务器端项目要导入json的jar包和json所依赖的jar包至builtPath路径下（这些可以到JSON-lib官网下载：）

然后将数据转为json字符串，核心函数是：

public static String createJsonString(String key, Object value)

{

JSONObject jsonObject = new JSONObject();

jsonObject.put(key, value);

return jsonObject.toString();

}

B、客户端将json字符串转换为相应的javaBean

1、客户端获取json字符串（因为android项目中已经集成了json的jar包所以这里无需导入）

public class HttpUtil

{

public static String getJsonContent(String urlStr)

{

try

{// 获取HttpURLConnection连接对象

URL url = new URL(urlStr);

HttpURLConnection httpConn = (HttpURLConnection) url

.openConnection();

// 设置连接属性

httpConn.setConnectTimeout(3000);

httpConn.setDoInput(true);

httpConn.setRequestMethod("GET");

// 获取相应码

int respCode = httpConn.getResponseCode();

if (respCode == 200)

{

return ConvertStream2Json(httpConn.getInputStream());

}

}

catch (MalformedURLException e)

{

// TODO Auto-generated catch block

e.printStackTrace();

}

catch (IOException e)

{

// TODO Auto-generated catch block

e.printStackTrace();

}

return "";

}

private static String ConvertStream2Json(InputStream inputStream)

{

String jsonStr = "";

// ByteArrayOutputStream相当于内存输出流

ByteArrayOutputStream out = new ByteArrayOutputStream();

byte[] buffer = new byte[1024];

int len = 0;

// 将输入流转移到内存输出流中

try

{

while ((len = inputStream.read(buffer, 0, buffer.length)) != -1)

{

out.write(buffer, 0, len);

}

// 将内存流转换为字符串

jsonStr = new String(out.toByteArray());

}

catch (IOException e)

{

// TODO Auto-generated catch block

e.printStackTrace();

}

return jsonStr;

}

}

2、获取javaBean

public static Person getPerson(String jsonStr)

{

Person person = new Person();

try

{// 将json字符串转换为json对象

JSONObject jsonObj = new JSONObject(jsonStr);

// 得到指定json key对象的value对象

JSONObject personObj = jsonObj.getJSONObject("person");

// 获取之对象的所有属性

person.setId(personObj.getInt("id"));

person.setName(personObj.getString("name"));

person.setAddress(personObj.getString("address"));

}

catch (JSONException e)

{

// TODO Auto-generated catch block

e.printStackTrace();

}

return person;

}

public static ListPerson getPersons(String jsonStr)

{

ListPerson list = new ArrayListPerson();

JSONObject jsonObj;

try

{// 将json字符串转换为json对象

jsonObj = new JSONObject(jsonStr);

// 得到指定json key对象的value对象

JSONArray personList = jsonObj.getJSONArray("persons");

// 遍历jsonArray

for (int i = 0; i personList.length(); i++)

{

// 获取每一个json对象

JSONObject jsonItem = personList.getJSONObject(i);

// 获取每一个json对象的值

Person person = new Person();

person.setId(jsonItem.getInt("id"));

person.setName(jsonItem.getString("name"));

person.setAddress(jsonItem.getString("address"));

list.add(person);

}

}

catch (JSONException e)

{

// TODO Auto-generated catch block

e.printStackTrace();

}

return list;

}

java中如何将数据封装为JSON包？

java中将数据封装为JSON包，可以使用java提供的jsonArray这个工具类进行转换，代码如下：

package com.json;

import java.io.IOException;

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 javax.servlet.http.HttpServletResponse;

import net.sf.json.JSONArray;

import net.sf.json.JSONObject;

import org.apache.commons.beanutils.BeanUtils;

import org.apache.struts2.ServletActionContext;

import com.opensymphony.xwork2.ActionContext;

public class JSONUtils

{

/**

* 

* @author wangwei JSON工具类

* @param T

* 

*/

/***

* 将List对象序列化为JSON文本

*/

public static T String toJSONString(ListT list)

{

JSONArray jsonArray = JSONArray.fromObject(list);

return jsonArray.toString();

}

/***

* 将对象序列化为JSON文本

* @param object

* @return

*/

public static String toJSONString(Object object)

{

JSONArray jsonArray = JSONArray.fromObject(object);

return jsonArray.toString();

}

/***

* 将JSON对象数组序列化为JSON文本

* @param jsonArray

* @return

*/

public static String toJSONString(JSONArray jsonArray)

{

return jsonArray.toString();

}

/***

* 将JSON对象序列化为JSON文本

* @param jsonObject

* @return

*/

public static String toJSONString(JSONObject jsonObject)

{

return jsonObject.toString();

} 

/***

* 将对象转换为List对象

* @param object

* @return

*/

public static List toArrayList(Object object)

{

List arrayList = new ArrayList();

JSONArray jsonArray = JSONArray.fromObject(object);

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;

}

/***

* 将对象转换为Collection对象

* @param object

* @return

*/

public static Collection toCollection(Object object)

{

JSONArray jsonArray = JSONArray.fromObject(object);

return JSONArray.toCollection(jsonArray);

}

/***

* 将对象转换为JSON对象数组

* @param object

* @return

*/

public static JSONArray toJSONArray(Object object)

{

return JSONArray.fromObject(object);

}

/***

* 将对象转换为JSON对象

* @param object

* @return

*/

public static JSONObject toJSONObject(Object object)

{

return JSONObject.fromObject(object);

}

/***

* 将对象转换为HashMap

* @param object

* @return

*/

public static HashMap toHashMap(Object object)

{

HashMapString, Object data = new HashMapString, 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;

}

/***

* 将对象转换为ListMapString,Object

* @param object

* @return

*/

// 返回非实体类型(MapString,Object)的List

public static ListMapString, Object toList(Object object)

{

ListMapString, Object list = new ArrayListMapString, Object();

JSONArray jsonArray = JSONArray.fromObject(object);

for (Object obj : jsonArray)

{

JSONObject jsonObject = (JSONObject) obj;

MapString, Object map = new HashMapString, Object();

Iterator it = jsonObject.keys();

while (it.hasNext())

{

String key = (String) it.next();

Object value = jsonObject.get(key);

map.put((String) key, value);

}

list.add(map);

}

return list;

}

/***

* 将JSON对象数组转换为传入类型的List

* @param T

* @param jsonArray

* @param objectClass

* @return

*/

public static T ListT toList(JSONArray jsonArray, ClassT objectClass)

{

return JSONArray.toList(jsonArray, objectClass);

}

/***

* 将对象转换为传入类型的List

* @param T

* @param jsonArray

* @param objectClass

* @return

*/

public static T ListT toList(Object object, ClassT objectClass)

{

JSONArray jsonArray = JSONArray.fromObject(object);

return JSONArray.toList(jsonArray, objectClass);

}

/***

* 将JSON对象转换为传入类型的对象

* @param T

* @param jsonObject

* @param beanClass

* @return

*/

public static T T toBean(JSONObject jsonObject, ClassT beanClass)

{

return (T) JSONObject.toBean(jsonObject, beanClass);

}

/***

* 将将对象转换为传入类型的对象

* @param T

* @param object

* @param beanClass

* @return

*/

public static T T toBean(Object object, ClassT beanClass)

{

JSONObject jsonObject = JSONObject.fromObject(object);

return (T) JSONObject.toBean(jsonObject, beanClass);

}

/***

* 将JSON文本反序列化为主从关系的实体

* @param T 泛型T 代表主实体类型

* @param D 泛型D 代表从实体类型

* @param jsonString JSON文本

* @param mainClass 主实体类型

* @param detailName 从实体类在主实体类中的属性名称

* @param detailClass 从实体类型

* @return

*/

public static T, D T toBean(String jsonString, ClassT mainClass,

String detailName, ClassD detailClass)

{

JSONObject jsonObject = JSONObject.fromObject(jsonString);

JSONArray jsonArray = (JSONArray) jsonObject.get(detailName);

T mainEntity = JSONUtils.toBean(jsonObject, mainClass);

ListD detailList = JSONUtils.toList(jsonArray, detailClass);

try

{

BeanUtils.setProperty(mainEntity, detailName, detailList);

}

catch (Exception ex)

{

throw new RuntimeException("主从关系JSON反序列化实体失败！");

}

return mainEntity;

}

/***

* 将JSON文本反序列化为主从关系的实体

* @param T泛型T 代表主实体类型

* @param D1泛型D1 代表从实体类型

* @param D2泛型D2 代表从实体类型

* @param jsonString JSON文本

* @param mainClass 主实体类型

* @param detailName1 从实体类在主实体类中的属性

* @param detailClass1 从实体类型

* @param detailName2 从实体类在主实体类中的属性

* @param detailClass2 从实体类型

* @return

*/

public static T, D1, D2 T toBean(String jsonString, ClassT mainClass,

String detailName1, ClassD1 detailClass1, String detailName2,

ClassD2 detailClass2)

{

JSONObject jsonObject = JSONObject.fromObject(jsonString);

JSONArray jsonArray1 = (JSONArray) jsonObject.get(detailName1);

JSONArray jsonArray2 = (JSONArray) jsonObject.get(detailName2);

T mainEntity = JSONUtils.toBean(jsonObject, mainClass);

ListD1 detailList1 = JSONUtils.toList(jsonArray1, detailClass1);

ListD2 detailList2 = JSONUtils.toList(jsonArray2, detailClass2);

try

{

BeanUtils.setProperty(mainEntity, detailName1, detailList1);

BeanUtils.setProperty(mainEntity, detailName2, detailList2);

}

catch (Exception ex)

{

throw new RuntimeException("主从关系JSON反序列化实体失败！");

}

return mainEntity;

}

/***

* 将JSON文本反序列化为主从关系的实体

* @param T泛型T 代表主实体类型

* @param D1泛型D1 代表从实体类型

* @param D2泛型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,

ClassT mainClass, String detailName1, ClassD1 detailClass1,

String detailName2, ClassD2 detailClass2, String detailName3,

ClassD3 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);

ListD1 detailList1 = JSONUtils.toList(jsonArray1, detailClass1);

ListD2 detailList2 = JSONUtils.toList(jsonArray2, detailClass2);

ListD3 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;

}

/***

* 将JSON文本反序列化为主从关系的实体

* @param T 主实体类型

* @param jsonString JSON文本

* @param mainClass 主实体类型

* @param detailClass 存放了多个从实体在主实体中属性名称和类型

* @return

*/

public static T T toBean(String jsonString, ClassT mainClass,

HashMapString, 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;

}

/**

* 封装json数据从后台传输

* @param obj

*/

public static void outPutJson(Object obj){

ActionContext context = ActionContext.getContext();

HttpServletResponse response = (HttpServletResponse) context.get(ServletActionContext.HTTP_RESPONSE);

try {

response.getWriter().print(obj);

} catch (IOException e) {

e.printStackTrace();

}

}

}

//测试类

String s1 = "[{id:1, pId:0, name:\"test1\" , open:true}]"; 

String s2 = "{id:2, pId:1, name:\"test211\" , open:true}"; 

String s3 = "{id:3, pId:2, name:\"test311\" , open:true}"; 

String s4 = "{id:4, pId:1, name:\"test411\" , open:true}";

ListString listZtree = new ArrayListString();

listZtree.add(s1);

listZtree.add(s2);

listZtree.add(s3);

listZtree.add(s4);

System.out.println(JSONUtils.toJSONString(listZtree));

}

java 中如何引用json文件

引用json文件？这个说法够奇怪的。

JSON格式对象的操作可以借助于第三方包JSON-lib（需要其他依赖包）或者org.json（不需要其他依赖包）来操作。

你所说的引用JSON文件，是对json格式的文件进行操作么？如果是那样的话可以利用IO流，读取文件中的字符串，再利用JSON-lib或者org.json进行处理。

Java解析json数据

一、 JSON （JavaScript Object Notation）一种简单的数据格式，比xml更轻巧。

Json建构于两种结构：

1、“名称/值”对的集合（A collection of name/value pairs）。不同的语言中，它被理解为对象（object），纪录（record），结构（struct），字典（dictionary），哈希表（hash table），有键列表（keyed list），或者关联数组 （associative array）。 如：

{

“name”:”jackson”,

“age”:100

}

2、值的有序列表（An ordered list of values）。在大部分语言中，它被理解为数组（array）如：

{

“students”:

[

{“name”:”jackson”,“age”:100},

{“name”:”michael”,”age”:51}

]

}

二、java解析JSON步骤

A、服务器端将数据转换成json字符串

首先、服务器端项目要导入json的jar包和json所依赖的jar包至builtPath路径下（这些可以到JSON-lib官网下载：）

然后将数据转为json字符串，核心函数是：

public static String createJsonString(String key, Object value)

{

JSONObject jsonObject = new JSONObject();

jsonObject.put(key, value);

return jsonObject.toString();

}

B、客户端将json字符串转换为相应的javaBean

1、客户端获取json字符串（因为android项目中已经集成了json的jar包所以这里无需导入）

public class HttpUtil

{

public static String getJsonContent(String urlStr)

{

try

{// 获取HttpURLConnection连接对象

URL url = new URL(urlStr);

HttpURLConnection httpConn = (HttpURLConnection) url

.openConnection();

// 设置连接属性

httpConn.setConnectTimeout(3000);

httpConn.setDoInput(true);

httpConn.setRequestMethod("GET");

// 获取相应码

int respCode = httpConn.getResponseCode();

if (respCode == 200)

{

return ConvertStream2Json(httpConn.getInputStream());

}

}

catch (MalformedURLException e)

{

// TODO Auto-generated catch block

e.printStackTrace();

}

catch (IOException e)

{

// TODO Auto-generated catch block

e.printStackTrace();

}

return "";

}

private static String ConvertStream2Json(InputStream inputStream)

{

String jsonStr = "";

// ByteArrayOutputStream相当于内存输出流

ByteArrayOutputStream out = new ByteArrayOutputStream();

byte[] buffer = new byte[1024];

int len = 0;

// 将输入流转移到内存输出流中

try

{

while ((len = inputStream.read(buffer, 0, buffer.length)) != -1)

{

out.write(buffer, 0, len);

}

// 将内存流转换为字符串

jsonStr = new String(out.toByteArray());

}

catch (IOException e)

{

// TODO Auto-generated catch block

e.printStackTrace();

}

return jsonStr;

}

}

2、获取javaBean

public static Person getPerson(String jsonStr)

{

Person person = new Person();

try

{// 将json字符串转换为json对象

JSONObject jsonObj = new JSONObject(jsonStr);

// 得到指定json key对象的value对象

JSONObject personObj = jsonObj.getJSONObject("person");

// 获取之对象的所有属性

person.setId(personObj.getInt("id"));

person.setName(personObj.getString("name"));

person.setAddress(personObj.getString("address"));

}

catch (JSONException e)

{

// TODO Auto-generated catch block

e.printStackTrace();

}

return person;

}

public static ListPerson getPersons(String jsonStr)

{

ListPerson list = new ArrayListPerson();

JSONObject jsonObj;

try

{// 将json字符串转换为json对象

jsonObj = new JSONObject(jsonStr);

// 得到指定json key对象的value对象

JSONArray personList = jsonObj.getJSONArray("persons");

// 遍历jsonArray

for (int i = 0; i personList.length(); i++)

{

// 获取每一个json对象

JSONObject jsonItem = personList.getJSONObject(i);

// 获取每一个json对象的值

Person person = new Person();

person.setId(jsonItem.getInt("id"));

person.setName(jsonItem.getString("name"));

person.setAddress(jsonItem.getString("address"));

list.add(person);

}

}

catch (JSONException e)

{

// TODO Auto-generated catch block

e.printStackTrace();

}

return list;

}

JAVA 里面 JSON 的包有哪些?

最常用的是这个

json-lib-2.4-jdk15.jar

也有用这个的，功能比较落后

json.jar

java怎么将json文件读取进来并转成map

java中解析json文件，需要下载json解析包，用JSONUtil.deserialize()就可以了，范例：

import org.apache.struts2.json.JSONUtil;

 

public class JsonToJava {

   public static void main(String[] args) {

       try {

           String s = JSONObject.toString();

           Object o = JSONUtil.deserialize(s);

           Object o1 = ((HashMap)o).get("DATA");//此举将DATA作为对象，得到。

           Map map = (Map)o1;//然后强转o1         

 

       } catch (Exception e) {

           e.printStackTrace(System.out);

       }

   }

}