Question

我们如何在scala中对类型参数进行类型转换？

def somefunction[A]():List[A] = {
  //call a webservice and some operation on response that gives list of A
  return list of A
//ex: List(Some(abc2),Some(abc3),Some(232ab))
}

val l1 : List[A] = somefunction;

我们如何将类型l1（List [A]）转换为List[String]以获得输出比如List("abc2","abc3","232ab")?

Answer 1

对于总是List[Option[String]]的内容，请尝试以下

l1.flatten

这很简单a这将剥离Some包装器，只留下包含的字符串。但是，如果最终得到None值，则会将其从列表中过滤掉，因此如果您仍需要这些值，则需要更复杂的过程。例如，如果您希望将None映射到空字符串（""）

l1.map(_.getOrElse(""))

Answer 2

你可以编写一个函数，它接受任何类型的List，并通过通用函数.toString（）返回一个String：

def somefunction[A] (as: List[A]): List[String] = as.map (_.toString) 

scala> somefunction ("foobar".toList)
res113: List[String] = List(f, o, o, b, a, r)

scala> somefunction (List ("foo", "bar"))
res115: List[String] = List(foo, bar)

scala>  somefunction (List (3, 4.4, 1))
res116: List[String] = List(3.0, 4.4, 1.0)

注意，这里常见的超类是double，所以3隐式转换为3.0然后返回String“3.0”。

你可以拿一个东西的选项列表并解开每个元素：

def somefunction[A] (as: List[Option[A]]): List[A] = as.flatten
somefunction: [A](as: List[Option[A]])List[A]

scala> somefunction (List (Some (4), None, Some (3)))
res112: List[Int] = List(4, 3)

但是返回A列表的方法有某种方法可以检测到A是什么。

你可以编写一个没有参数的函数，它只返回一个常量值：

def version () : String = "2.12"

但返回类型是预定义的，此处也是值。在下一个示例中，值不是，但返回类型为：

scala> def somefunction: Int = scala.util.Random.nextInt (42);
somefunction: Int

scala> somefunction
res117: Int = 21

scala> somefunction
res118: Int = 35

在您的示例中，有一个空参数列表

def somefunction[A]() = {
  return list of A
//ex: List(Some(abc2),Some(abc3),Some(232ab))
}

val l1 : List[A] = somefunction;

somethfunction如何知道你想要一个String选项列表？值可能来自哪里？

大A符号说，我们有一个通用类型。典型的方法如下：

def somefunction[A] (a: A) : Option[A] = {
  if (a == null) None 
  else Some (a)
}

或者，更多As：

def somefunction[A] (a: A, b: A) : List[A] = {
  List (a, b)
}

可能没有在返回类型中引用A：

def somefunction[A] (l: List[A]) : Int = {
  l.size ()
}

在somefunction (List(1, 2, 3))中，A将引用Int，somefunction (List('a', 'b')) Char等等。但是没有参数列表，参考类型A，使用A作为类型参数是没有意义的。

方法如何返回 - 让我们说一个A的列表，具有不同类型的A，具体取决于某些条件？

无法以这种方式指定随机返回类型：

scala> def somefunction[A] (): List[A] = {
     |   val ri = r.nextInt (2)
     |   if (ri == 0) List (1, 2, 3)
     |   else List ("foo", "bar")
     | }
<console>:31: error: type mismatch;
 found   : Int(1)
 required: A
         if (ri == 0) List (1, 2, 3)
                            ^

但是，A可能取决于外部类型：

scala> case class Sample [A] (a: A) {
     |   def somefunction (): List[A] = {
     |     List (a, a, a)
     |   }
     | } 
defined class Sample

请注意，A不是在这里注释方法，只是类，可以像这样使用：

scala> val sample1 = Sample (1)
sample1: Sample[Int] = Sample(1)

scala> val sample2 = Sample ("two")
sample2: Sample[String] = Sample(two)

scala> sample1.somefunction
res119: List[Int] = List(1, 1, 1)

scala> sample2.somefunction
res120: List[String] = List(two, two, two)

Answer 3

val ans =List(Some(1), None, Some(2), Some(3),None).flatten.map(_.toString)

它应该做的伎俩。

scala中String列表的选项列表

3 个答案: