fastjson（JSONObject、JSONArray）使用及相互转换

文章目录

• 一、依赖
• 二、介绍
• 三、JSONObject
• • 1、构造方法
  • 2、装入
  • 3、取出
  • 4、删除
  • 5、是否包含
  • 6、遍历
• 四、JSONArray
• • 1、构造方法
  • 2、add
  • 3、get
  • 3、是否包含
  • 4、是否空
  • 5、清空
  • 6、遍历
  • 7、获取指定范围内集合
• 五、相互转换
• • 1、javaScript
  • 2、java
  • • 1）json串 -> JSONObject
    • 2）json串 -> JSONArray
    • 3）Object -> json串
    • 4）json串 -> Map
    • 5）对象 -> json串
    • 6）json串 -> 对象
    • 7）JSONObject -> 实体类
    • 8）JSONArray -> 集合
    • 9）JsonArray -> 数组
    • 10）集合 -> JSONArray
    • 11）json串 -> 集合
    • 12）Map -> JSONObject
    • 13）JSONObject ->Map

---

一、依赖

<!-- fastjson -->
<dependency>
    <groupId></groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.47</version>
</dependency>

二、介绍

• 数据格式

  //对象
  { "name":"张三", "from":"北京", "age":25 }
  
  //对象嵌套对象
  { "name":"张三","department":{"id":"9527", "name":"RD"} }
  
  //对象嵌套数组
  { "name": "张三", "skill": ["JAVA", "HTML","CSS", "JS", "MYSQL"] }
  
  //数组
  [1, 2, 3]
  
  //对象数组
  [{"name":"kimi"}, {"name":"sally"}]
  

三、JSONObject

• extends JSON implements Map<String, Object>,Cloneable, Serializable, InvocationHandler
• 和Map的API相似

1、构造方法

//默认无序，底层构建HashMap
new JSONObject();
new JSONObject(Map<String, Object> map);

//ordered：是否有序，true-底层构建LinkedHashMap;false-底层构建HashMap
JSONObject(boolean ordered);

2、装入

//如果是新的一个key，则返回的是null
//如果已经存在一个相同的key,返回前一个key对应的value,新value覆盖旧value
Object put(String key, Object value);

void putAll(Map<String,?> m);

//如果是新的一个key，则返回的是null
//如果已经存在一个相同的key,返回前一个key对应的value,新value不覆盖旧value
V putIfAbsent(K key, V value);

//链式调用
JSONObject fluentPut(String key, Object value);
JSONObject fluentPutAll(Map<? extends String, ?> m);

3、取出

Object get(Object key);

//若key不存在，则返回给定的默认值defaultValue
V getOrDefault(Object key, V defaultValue)

//取出并转换成实体类
T getObject(String key, Class<T> clazz);

//取出并转换成JSONObject
JSONObject getJSONObject(String key);

//取出并转换成JSONArray，装入的是集合，也可以getJSONArray
JSONArray getJSONArray(String key);

//基本类型、包装类
//内部使用
//只要可转换成即可，例如put("age",18)，可以geyString("age")，因为18可转换成String

String getString(String key)

Boolean getBoolean(String key)
boolean getBooleanValue(String key)

Integer getInteger(String key)
int getIntValue(String key)

Long getLong(String key)
long getLongValue(String key)

Double getDouble(String key)
double getDoubleValue(String key)

BigDecimal getBigDecimal(String key)
BigInteger getBigInteger(String key)

//若value为UTC时间，则会自动+8
Date getDate(String key)

4、删除

//通过key，返回删除的value，若key不存在则返回null
Object remove(Object key);

//通过key、value，若key 或者 value不存在则返回false
boolean remove(Object key, Object value);

//链式调用
JSONObject fluentRemove(Object key);

5、是否包含

//key
boolean containsKey(Object key);
//value
boolean containsValue(Object value);

6、遍历

• 与Map一样

//因为JSONObject implements Map<String, Object>，所以Entry的泛型是<String, Object>
Set<Map.Entry<String, Object>> jsonObject.entrySet();

四、JSONArray

• extends JSON implements List<Object>, Cloneable, RandomAccess, Serializable
• 和List相似

1、构造方法

//默认有序，底层构建ArrayList
new JSONArray();
new JSONArray(List<Object> list);

2、add

//单个
boolean add(Object e)
void add(int index, Object element)

//集合
boolean addAll(int index, Collection<?> c)
boolean addAll(Collection<?> c)

//链式调用-单个
JSONArray fluentAdd(Object e)
JSONArray fluentAdd(int index, Object element)

//链式调用-集合
JSONArray fluentAddAll(Collection<?> c)
JSONArray fluentAddAll(int index, Collection<?> c)

3、get

Object get(int index)

//实体类
T getObject(int index, Class<T> clazz);

//JSONObject
JSONObject getJSONObject(int index);

//JSONArray
JSONArray getJSONArray(int index);

//基本类型、包装类
String getString(int index)

Boolean getBoolean(int index)
boolean getBooleanValue(int index)

Integer getInteger(int index)
int getIntValue(int index)

Long getLong(int index)
long getLongValue(int index)

Double getDouble(int index)
double getDoubleValue(int index)

BigDecimal getBigDecimal(int index)
BigInteger getBigInteger(int index)

Date getDate(int index)
//若value为UTC时间，则会自动+8

3、是否包含

boolean contains(Object o);

boolean containsAll(Collection<?> c);

4、是否空

boolean isEmpty();

5、清空

void clear();

6、遍历

for(int i=0;i<arr.size();i++) {
 	JSONObject json=arr.getJSONObject(i);
 	String str=json.getString(i);
}

arr.foreach(obj->{
    
})

7、获取指定范围内集合

List<E> subList(int fromIndex, int toIndex);

五、相互转换

1、javaScript

//将一个javaScript对象/数组转换为一个json串
let str = (obj)

//将json串转换为javaScript对象/数组
let obj = (str)

2、java

1）json串 -> JSONObject

//当前端提交的是对象类型的json串："val":"{'name':1,'age':2}"，这种直接可以用转成JSONObject
//若再用(val)处理会变成""{'name':1,'age':2}""，此时用转换会: can not cast to JSONObject
JSONObject JSONObject.parseObject(String str);

2）json串 -> JSONArray

JSONArray JSONArray.parseArray(String str);

3）Object -> json串

//前端提交的对象类型的json串{}，后端使用该方法可以转json串；前端提交的数组类型的son串['kimi']，后端使用该方法则会异常
String JSON.toJSONString(Object obj);

4）json串 -> Map

Map<String,Object> JSON.parseObject(jsonStr);

5）对象 -> json串

String JSON.toJSONString(students);

/**
 *  指定转换策略
 *      features转换策略：
 *          ：key、value都加单引号
 *          ：null值也转换
 *          ：List字段为null,输出为[]
 *          ：String类型为null,输出空串
 *          ：数值类型为null，输出0
 *          ：boolean类型为null,输出false
 */
String JSON.toJSONString(Object object, SerializerFeature... features);

//转换时忽略某属性
//第一种：属性上添加@JSONField(serialize = false)
//第二种：属性前添加transient：private transient Integer age;

6）json串 -> 对象

T JSON.parseObject(String json, Class<T> clazz);

//属性指定json中key，该属性必须有set、get
@JSONField(name="es_id");
private String esId;

//时间字段指定转换格式
@JSONField(name="time",format="yyyyMMdd")

//json字段是UTC时区ZonedDateTime, 对应的 对象字段是LocalDateTime会自动加8小时：2021-02-19T03:25:05.562Z -> 2021-02-19T11:25:05.562

//json字段是日期、时间格式的字符串，会自动转换成LocalDateTime、LocalDate：2021-03-03T11:11:11、2021-03-03 11:11:11、2021-03-03T11:11:11+0800

7）JSONObject -> 实体类

T  toJavaObject(JSON json, Class<T> clazz);

8）JSONArray -> 集合

List<T> toJavaList(Class<T> clazz);

9）JsonArray -> 数组

String[] jsonArray.toArray(new String[jsonArray.size()]);

10）集合 -> JSONArray

JSONArray JSONArray.parseArray(JSON.toJSONString(list));

11）json串 -> 集合

List<Integer> JSONObject.parseArray("[12,13]", Integer.class);

//通用JSONObject集合
List<JSONObject> JSONObject.parseArray("[{name:'kimi',age:18},{name:'sally',age:20}]",JSONObject.class)

//对象集合
List<User> JSONObject.parseArray("[{name:'kimi',age:18},{name:'sally',age:20}]",User.class)

//对象数组字符串转Map集合
List<Map<String,String>> JSON.parseObject(str, new TypeReference<ArrayList<Map<String,String>>>(){});

12）Map -> JSONObject

JSONObject new JSONObject(Map<String, Object> map);

13）JSONObject ->Map

Map<String, Object> jsonobject.getInnerMap();