Scala实现递归打印任意嵌套数组的泛型助手方法问询

我来帮你搞定这个递归打印嵌套数组的Scala助手方法！你的思路完全没问题——用递归+类型区分来处理基准和嵌套场景，下面是完整的实现方案，两种风格任你选：

方案一：用隐式类型约束区分场景 #

这种方式利用Scala的隐式类型<:<来自动判断数组元素是否为数组类型，实现方法重载的自动匹配：

object Helper {
  // 基准场景：处理元素为非数组类型的数组
  def print[A](arr: Array[A])(implicit ev: A <:< AnyRef, notArray: A <:< Array[Nothing] = null): Unit = {
    notArray match {
      case _: A <:< Array[Nothing] => 
        // 元素不是数组，直接打印
        println(arr.mkString("[", ", ", "]"))
      case _ => 
        // 元素是数组，转调递归处理方法
        printNested(arr.asInstanceOf[Array[Array[_]]])
    }
  }

  // 递归场景：处理元素为数组的嵌套数组
  private def printNested[A](arr: Array[Array[A]]): Unit = {
    arr.foreach(subArr => print(subArr)) // 递归调用，自动适配基准/递归场景
  }
}

调用示例 #

// 测试单层普通数组
Helper.print(Array("apple", "banana", "cherry"))
// 输出: [apple, banana, cherry]

// 测试一层嵌套数组
Helper.print(Array(Array(1, 2, 3), Array(4, 5), Array(6)))
// 输出:
// [1, 2, 3]
// [4, 5]
// [6]

// 测试多层嵌套
Helper.print(Array(Array(Array("x", "y"), Array("z")), Array(Array("m", "n"))))
// 输出:
// [x, y]
// [z]
// [m, n]

方案二：用TypeTag做直观类型检查 #

如果觉得隐式约束有点抽象，用TypeTag直接判断元素类型会更易懂：

import scala.reflect.runtime.universe._

object Helper {
  def print[A: TypeTag](arr: Array[A]): Unit = {
    if (typeOf[A] <:< typeOf[Array[_]]) {
      // 元素是数组，递归处理每个子数组
      arr.asInstanceOf[Array[Array[_]]].foreach(print)
    } else {
      // 元素不是数组，直接打印当前层
      println(arr.mkString("[", ", ", "]"))
    }
  }
}

这个版本的逻辑更直白：通过TypeTag获取元素的实际类型，判断是否为数组，是就递归，不是就打印，调用方式和上面完全一致。

核心思路说明 #

• 基准场景：当数组元素是普通类型（非数组）时，直接用mkString格式化打印；
• 递归场景：当数组元素是子数组时，遍历每个子数组并递归调用打印方法，直到处理到最底层的普通元素数组。

这样不管嵌套多少层，都能逐层拆解打印，完美满足你的需求～

内容的提问来源于stack exchange，提问作者fergdev