Question

我们有一个字符串列表，我按照以下程序对它们进行分组。输入：val k = List("a", "a", "a", "a", "b", "c", "c", "a", "a", "d", "e", "e", "e", "e")

输出：*List(List(a, a, a, a), List(b), List(c, c), List(a, a), List(d), List(e, e, e, e))*

程序：

  def pack(ls:List[String]):List[List[String]]={

    val (a,next) = ls span {_ == ls.head}

    if ((next) == Nil) List(a)
    else a :: pack(next)

  }

然而，当我做一个List cons运算符时，我得到如下所述的输出。

输入：

val a =List("a", "a", "a", "a")        
val b = List ("b")                     
val c = List ("c", "c" )               
val a1 = List("a", "a")                
val d = List("d")                      
val e = List( "e", "e", "e", "e")      

*List(a::b::c::a1::d::e)*

输出：

*List(List(List(a, a, a, a), List(b), List(c, c), List(a, a), List(d), e, e, e, e))*

有没有办法在scala的单个命令中输出如下所示？

*List(List(a, a, a, a), List(b), List(c, c), List(a, a), List(d), List(e, e, e, e))*

Answer 1

scala> a::b::c::a1::d::List(e)
res0: List[List[String]] = List(List(a, a, a, a), List(b), List(c, c), List(a, a), List(d), List(e, e, e, e))

cons运算符会将一个项目添加到列表中 - 因此如果您希望逐个添加所有其他项目，请在最后一个项目周围构建List。

考虑这一点的最简单方法是注意 types ：

要构建List[List[String]]，cons运算符期望在左侧的List[String]和右侧的List[List[String]]上运行，以生成新的List[List[String]]：左侧应为结果列表中的项，右侧为与预期结果类型相同的列表
当你写d::e时，你正在做List[String] :: List[String]，这已经意味着你不会产生List[List[String]] - 所以右边必须be＆＃34;包裹＆＃34;使用列表来获取正确的类型：d::List(e)
在其他项目前加上相同的规则 - 将List[String]添加到List[List[String]]
完成后 - 您将获得预期结果，而无需将整个结果与其他列表包装在一起

Answer 2

如果您计划使用::获得最终结果，则在cons操作的末尾添加Nil可以产生所需的结果。

a::b::c::a1::d::e::Nil

或者你可以将List中的最后一个元素包装成Zohar提到的@Tzach。

a::b::c::a1::d::List(e)

否则使用

List(a,b,c,a1,d,e)

Answer 3

是。如果你真的想使用这种语法：

List(a::b::c::a1::d::e::Nil: _*)

你最后需要: _*因为否则你将一个元素（类型为List）传递给List.apply()并且它没有将它解释为一个序列，这就是为什么你得到{{} 1}}而不是所需的List[List[List]]。

在Scala中列出[List [String]]

3 个答案: