内容整理
- 字符串Map => JSONObject => Scala Map
- Scala Map => JSONObject / JSONString
- JSONObject => Scala Map
- Scala 嵌套 Map => 嵌套JSONObject
- 获取JSONObject中的值
- 从复杂JSONObject中获取值和JSONArray
- JSONObject的增删改
- JSONArray的解析和操作
- JSONObject的循环
- JSONArray的循环
- 判断JSONObject / JSONArray是否相等
字符串Map => JSONObject
def JSONStringToJSONObject(): Unit = {
val a = "{'a':1, 'b':2, 'c':3}"
val aJSON = JSON.parse(a).asInstanceOf[JSONObject]
println(aJSON.toString()) // {"a":1,"b":2,"c":3}
println(aJSON.toJSONString) // toString调用toJSONString
val aJson2 = JSON.parseObject(a)
println(aJson2.getClass) // class com.alibaba.fastjson.JSONObject
JSONObject => Scala Map
创建一个Map，循环JSONObject填充Map，或者JSONObject转Scala集合调用toMap刚发。
// json转Map
import scala.collection.JavaConverters._
val b = scala.collection.mutable.HashMap[String, Int]()
aJSON.entrySet().asScala.foreach(x => b.put(x.getKey, x.getValue.asInstanceOf[Int]))
println(b)
println(b("c"))
val c = aJSON.asScala.toMap // Map[String, AnyRef]
println(c)
println(c("c"))
// value默认是AnyRef， 使用类型强转
val d = aJSON.asScala.toMap.asInstanceOf[mutable.Map[String, Int]] // Map[String, Int]
println(d)
}
Scala Map => JSONObject以及Scala 嵌套 Map => 嵌套JSONString
/*
scala map => JSONObject
*/
def MapToJSONObject(): Unit = {
// 方法1
val json = new JSONObject()
val map = Map("a" -> 1, "b" -> 2, "c" -> 3)
map.foreach(kv => json.put(kv._1, kv._2))
println(json.getClass)
println(json.toJSONString)
// 嵌套Json
val json2 = new JSONObject()
val map2 = Map("a" -> Map("aa" -> 1), "b" -> Map("bb" -> 2), "c" -> Map("cc" -> 3))
for ((k, v) <- map2) {
for ((kk, vv) <- v) {
val tmpJSON = new JSONObject()
tmpJSON.put(kk, vv)
json2.put(k, tmpJSON)
}
}
println(json2)
println(json2.getJSONObject("a").getString("aa")) // 嵌套JSONObject取值
// 使用JSON.toJSONString, scala集合转java, 加SerializerFeature.EMPTY: _* 防止序列化错误
import scala.collection.JavaConverters._
val json3 = JSON.toJSONString(map.asJava, SerializerFeature.EMPTY: _*)
println(json3)
// 嵌套Map不能JSON.toJSONString
}
获取JSONObject中的值
/*
获取JSONObject中的值
*/
def getValueFromJSONObject(): Unit = {
val a = "{'a':1, 'b':2, 'c':3, 'd':''}"
val aJSON = JSON.parse(a).asInstanceOf[JSONObject]
val b = aJSON.getString("a")
println(b)
println(b + 1) // 11 , b是String类型
val c = aJSON.getInteger("b")
println(c + 1) // 3
// 取不到是null
val d = aJSON.getString("d")
println(d)
println(d == null) // true
// 取空字符串
val e = aJSON.getString("d")
println(e)
println(e.isEmpty) // true
// 判断取到的值不是空
if (!(e == null || e.length == 0)) {
println("do")
} else {
println("为空")
}
}
从复杂JSONObject中获取值和JSONArray
/*
从复杂JSONObject中获取值
*/
def getValueFromNestingJSONObject(): Unit = {
val str1 =
"""{
| "dataId":123,
| "dataType":"mysql",
| "resultData":[
| {"binlog":"mysql_binlog.000","column":[{"name":"single","type":"int(5)"},{"name":"single3","type":"int(5)"} ]},
| {"binlog1":"redis_binlog.000","column":[{"name":"single3","type":"int(5)"},{"name":"single3","type":"int(5)"} ]},
| ]
|}
""".stripMargin
println(str1)
val jsonObect: JSONObject = JSON.parseObject(str1)
println(jsonObect)
// 获取JSONArray
val resultDataObject = jsonObect.getJSONArray("resultData")
println(resultDataObject)
// 在JSONArray中通过索引值获取JSONObject
val binlogObject = resultDataObject.getJSONObject(0)
println(binlogObject)
// 获取column
val columnObject = binlogObject.getJSONArray("column")
println(columnObject)
// 获取name
val nameObject = columnObject.getJSONObject(0)
val name = nameObject.getString("name")
println(name)
}
JSONObject的增删改
/*
JSONObject的增删改
*/
def updateJSONObject(): Unit = {
val a = "{'a':1, 'b':2, 'c':3}"
val aJSON = JSON.parse(a).asInstanceOf[JSONObject]
// 增
aJSON.put("newFeature", "4")
println(aJSON)
// 删除
aJSON.remove("newFeature")
println(aJSON)
// 覆盖
aJSON.put("b", "4")
println(aJSON)
}
JSONArray的解析和操作
/*
JSONArray的解析和操作
*/
def ListToJSONArray(): Unit = {
val a = "['a','b', 'c']"
// 解析JSONArray
val b = JSON.parse(a).asInstanceOf[JSONArray]
println(b)
// 通过索引获得JSONArray元素
println(b.get(0))
// 增加元素
b.add("d")
println(b) // ["a","b","c","d"]
// scala集合转JSONArray
import scala.collection.JavaConverters._
val c = List(1, 2, 3)
val d = c.mkString(",")
// scala集合转java集合，SerializerFeature
val e = JSON.toJSONString(c.asJava, SerializerFeature.EMPTY: _*)
println(d) // 1,2,3
println(e)
// 另一种 初始化JSONArray 再 add
val f = new JSONArray()
c.foreach(x => f.add(x))
println(f)
}
JSONObject的循环
JSONObject先要转Scala集合，默认key是String，value是AnyRef，需要强转mutable.Map转化类型mutable.Map <=> java.util.Map。
val json2 = JSON.parse("{\"a\":1,\"b\":2,\"c\":3}").asInstanceOf[JSONObject]
import scala.collection.JavaConverters._
for ((k: String, v: Int) <- json2.asScala.asInstanceOf[mutable.Map[String, Int]]) {
// TODO
}
或者循环key调用JSONObject的get方法
val json2 = JSON.parse("{\"a\":1,\"b\":2,\"c\":3}").asInstanceOf[JSONObject]
import scala.collection.JavaConverters._
val map = mutable.HashMap[String, Int]()
for (key: String <- json2.keySet().asScala) {
map.put(key, json2.getIntValue(key))
}
如果是value是JSONArray，JSONObject，不需要强转直接指定类型。
val json3 = JSON.parse("{\"a\":[1,2,3],\"b\":[2,3,4]}").asInstanceOf[JSONObject]
import scala.collection.JavaConverters._
val map = mutable.HashMap[String, JSONArray]()
for ((key: String, value: JSONArray) <- json3.asScala) {
map.put(key, value)
}
val json4 = JSON.parse("{\"a\":{\"a\":1},\"b\":{\"b\":1}}").asInstanceOf[JSONObject]
import scala.collection.JavaConverters._
val map = mutable.HashMap[String, JSONObject]()
for ((key: String, value: JSONObject) <- json4.asScala) {
map.put(key, value)
}
也可以使用entrySet()转化为映射再循环，调用getKey，getValue。
val json2 = JSON.parse("{\"a\":1,\"b\":2,\"c\":3}").asInstanceOf[JSONObject]
import scala.collection.JavaConverters._
val map = mutable.HashMap[String, Int]()
for (ent <- json2.entrySet().asScala) {
map.put(ent.getKey, ent.getValue.asInstanceOf[Int])
}
JSONArray的循环
对元素是String的JSONArray，遍历需要先转Scala集合，默认每个元素是AnyRef，需要强转String，或者使用Buffer[String]强转整个集合，mutable.Buffer <=> java.util.List。
val json1 = JSON.parse("[\"1\",\"2\",\"3\"]").asInstanceOf[JSONArray]
import scala.collection.JavaConverters._
val list = mutable.ListBuffer[String]()
for (ent <- json1.asScala) {
list.append(ent.asInstanceOf[String]) // 默认是Object，需要类型强转
}
for (ent <- json1.asScala.asInstanceOf[mutable.Buffer[String]]) { // 强转为mutable.Buffer[String]
list.append(ent)
}
也可以使用下标循环，世界调用getString方法，不需要类型强转。
val list = mutable.ListBuffer[String]()
for (i <- 0 until json1.size()) {
list.append(json1.getString(i))
}
判断JSONObject / JSONArray是否相等
使用equals护着=判断是否相等。
val json5 = JSON.parse("{\"a\":1,\"b\":2,\"c\":3}").asInstanceOf[JSONObject]
val json6 = JSON.parse("{\"a\":1,\"b\":2,\"c\":3}").asInstanceOf[JSONObject]
val json7 = JSON.parse("{\"a\":1,\"c\":3,\"b\":2}").asInstanceOf[JSONObject]
println(json5 == json6) // true
println(json5.equals(json6)) // true
println(json5 == json7) // true
println(json5.equals(json7)) // true
网友评论