Scala通用数组元素

Question

我正在尝试编写一个函数来计算T类型元素数组中通过T=>Boolean类型测试的元素数。

到目前为止，我得到的是：

     def countPass[T](elem: Array[T]) = {
        var count = 0
        for(x <- elem) 
            x match { 
                case x: T => count += 1
            }
        count
    }

    //TEST
    println(countPass[Boolean](Array(true, 52, "test")))

我有几个错误，第一个是：

combinators.scala:45: warning: abstract type pattern T is unchecked since
it is eliminated by erasure
                        case x: T => count += 1
                                ^

下一个错误是：

combinators.scala:54: error: type mismatch;
 found   : Int(52)
 required: Boolean
    println(countPass[Boolean](Array(true, 52, "test")))
                                           ^
combinators.scala:54: error: type mismatch;
 found   : String("test")
 required: Boolean
    println(countPass[Boolean](Array(true, 52, "test")))
                                               ^

我不确定第一个错误会发生什么，但是对于第二个错误，它会在任何时候抛出异常，而不是布尔值。我不希望这种情况发生，因为我只是在计算数组中T类型元素的数量。

问题：如何重构我的代码以修复这两个错误？

Answer 1

诀窍是使用ClassTag。完成您的请求的更好方法如下：

import scala.reflect.ClassTag

object Main extends App {

  val array: Array[Any] = Array("string1", "string2", "string3", true, false, 13)

  def countPass[Other: ClassTag](array: Array[Any]): Int = {
    array.collect { case x: Other => x }.length
  }

  println(s"countPass String = ${countPass[String](array)}")
  println(s"countPass Boolean = ${countPass[Boolean](array)}")
  println(s"countPass Int = ${countPass[Int](array)}")
}

您可以阅读这来了解有关ClassTag和TypeTag的更多信息。

Answer 2

所以我找到了一种可行的方法，但不是我想要的。

     def countPass[T](elem: Array[T]) = {
        var count = 0
        for(x <- elem) 
            x match { 
                case _: Boolean => count += 1
                case _ => None
            }
        count
    }

    //TEST
    println(countPass[Any](Array(true, 5, "test", false, false)))

问题是我需要将任何信息传递到数组中，因为其中有不同的类型。此外，我需要稍微修改我的案例，并添加默认的情况。

这个很好，但我更想要这样的东西。由于上面指定的相同错误，这不起作用。

    def countPass[T](elem: Array[Any]) = {
        var count = 0
        for(x <- elem) 
            x match { 
                case _: T => count += 1   //Here is the error
                case _ => None
            }
        count
    }

    //TEST
    println(countPass[Boolean](Array(true, 5, "test", false, false)))

由于某些原因，我不能将_：t作为我的情况，或者我得到了以下错误：

combinators.scala:44: warning: abstract type pattern T is unchecked since 
it is eliminated by erasure
                case _: T => count += 1

Answer 3

可以直接使用方法计数。

def countPass[T: ClassTag](elem: Array[Any]): Int = elem.count{
    case _ : T => true
    case _ => false
}