Scala学习

Scala使用fastJson整理

2020-07-06  本文已影响0人  xiaogp

内容整理

字符串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
上一篇下一篇

猜你喜欢

热点阅读