Scala中如何直接将Gson的JsonObject转为Map、JsonArray转为Seq？

你可以直接遍历Gson的JsonObject和JsonArray内部结构完成转换，无需先序列化为字符串再用Jackson反序列化，这种方式更高效，也能直接满足你遍历JSON结构的需求。

一、核心转换工具函数 #

利用Gson提供的API，结合Scala的集合操作，我们可以写出递归转换的工具函数，覆盖所有JSON元素类型（对象、数组、基本类型）：

import com.google.gson.{JsonArray, JsonElement, JsonObject, JsonPrimitive}
import scala.collection.JavaConverters._

// 递归将JsonElement转换为对应Scala类型
def jsonElementToScala(element: JsonElement): Any = element match {
  case obj: JsonObject => jsonObjectToMap(obj)
  case arr: JsonArray => jsonArrayToSeq(arr)
  case prim: JsonPrimitive => 
    if (prim.isBoolean) prim.getAsBoolean
    else if (prim.isNumber) prim.getAsNumber
    else prim.getAsString
  case _ => null
}

// JsonObject转Scala Map[String, Any]
def jsonObjectToMap(jsonObj: JsonObject): Map[String, Any] = {
  jsonObj.entrySet().asScala.map { entry =>
    entry.getKey -> jsonElementToScala(entry.getValue)
  }.toMap
}

// JsonArray转Scala Seq[Any]
def jsonArrayToSeq(jsonArr: JsonArray): Seq[Any] = {
  jsonArr.iterator().asScala.map(jsonElementToScala).toSeq
}

二、替换原有代码的完整示例 #

将你原来的转换逻辑替换为上述工具函数，完整可运行代码如下：

import com.google.gson.{Gson, JsonObject, JsonArray}
import scala.collection.JavaConverters._

object Test {
  // 核心转换工具函数
  def jsonElementToScala(element: JsonElement): Any = element match {
    case obj: JsonObject => jsonObjectToMap(obj)
    case arr: JsonArray => jsonArrayToSeq(arr)
    case prim: JsonPrimitive => 
      if (prim.isBoolean) prim.getAsBoolean
      else if (prim.isNumber) prim.getAsNumber
      else prim.getAsString
    case _ => null
  }

  def jsonObjectToMap(jsonObj: JsonObject): Map[String, Any] = {
    jsonObj.entrySet().asScala.map { entry =>
      entry.getKey -> jsonElementToScala(entry.getValue)
    }.toMap
  }

  def jsonArrayToSeq(jsonArr: JsonArray): Seq[Any] = {
    jsonArr.iterator().asScala.map(jsonElementToScala).toSeq
  }

  def main(args: Array[String]): Unit = {
    val json: String = "{\"itemScores\":[{\"item\":\"37064\",\"score\":0.0},{\"item\":\"1365\",\"score\":0.0}]}"
    val jsonObject = new Gson().fromJson(json, classOf[JsonObject])
    
    val list1 = jsonObject.get("itemScores").getAsJsonArray

    // 直接完成转换
    val mapConvert: Map[String, Seq[Any]] = jsonObjectToMap(jsonObject).asInstanceOf[Map[String, Seq[Any]]]
    val listConvert: Seq[Map[String, Any]] = jsonArrayToSeq(list1).asInstanceOf[Seq[Map[String, Any]]]

    println(mapConvert) // Map(itemScores -> List(Map(item -> 37064, score -> 0.0), Map(item -> 1365, score -> 0.0)))
    println(listConvert) // List(Map(item -> 37064, score -> 0.0), Map(item -> 1365, score -> 0.0))
    
    // 遍历转换后的Seq
    for (i <- listConvert) {
      println(i.get("item"))
    }

    // 更高效的方式：直接遍历Gson的JsonArray，无需转换
    println("--- 直接遍历JsonArray ---")
    for (elem <- list1.iterator().asScala) {
      val itemObj = elem.getAsJsonObject
      println(itemObj.get("item").getAsString)
    }
  }
}

三、关键说明 #

1. 避免序列化开销：直接操作Gson的对象结构，省去了字符串序列化和反序列化的额外性能消耗。
2. 支持嵌套结构：工具函数递归处理嵌套的JSON对象和数组，能适配更复杂的JSON格式。
3. 直接遍历选项：如果你的最终目的只是遍历JSON结构，甚至可以跳过转换步骤，直接通过JavaConverters将Gson的Java迭代器转为Scala可遍历结构，进一步简化逻辑。

内容的提问来源于stack exchange，提问作者Hoang Minh Quang FX15045