Question

我有一个包含各种类型的List：

val data: List[(String, Int, List[String])] = List(("foo", 1, List("a", "b")), ("bar", 2, List("c", "d")), ("baz", 1, List("e", "f")))

如果Int值大于1，我试图为该范围内的每个Int复制那些项目（从1到Int） - 理想情况下它看起来像（强调Int需要是每次迭代从1增加到Int ）：

val dataExpanded: List[(String, Int, List[String])] = List(("foo", 1, List("a", "b")), ("bar", 1, List("c", "d")), ("bar", 2, List("c", "d")), ("baz", 1, List("e", "f")))

通常使用scala中的类型，尤其是嵌套结构，因为每个操作似乎都会引入越来越多的类型陷阱。

所以我在尝试的时候：

val dataExpanded = data.map{ case (s, i, l) =>

    if (i > 1) {

        List.range(1, i+1).map { n =>
            (s, n, l)
        }

    } else {
        (s, i, l)
    }
}

我得到了结果：

> dataExpanded: List[Product with java.io.Serializable] = List((foo,1,List(a, b)), List((bar,1,List(c, d)), (bar,2,List(c, d))), (baz,1,List(e, f)))

结果看起来像是在正确的路径上，但是扩展的元素嵌套在它们自己的列表中，因此，我认为，Type是错误的。没有任何flatMapping或flattening或映射for循环的输出让我摆脱了这个堵塞。

这也可能与我的案件陈述有关，而不是处理无案件，但我不知道如何处理其他案件（我知道这是不对的，但我不会有任何其他案件）在我的数据中 - 虽然这是动态类型语言谈论的醉酒）

有没有办法在从data转到dataExpanded时保持预期类型，同时避免不必要的循环？

Answer 1

考虑元组的case类，比如

case class Datum(s: String, n: Int, xs: List[String])

由此给出

val data: List[Datum] = List(Datum("foo", 1, List("a", "b")), 
                             Datum("bar", 2, List("c", "d")), 
                             Datum("baz", 1, List("e", "f")))

我们可以在案例类中使用copy方法，如下所示，

def expand(d: Datum) = (1 to d.n).map (i => d.copy(n=i))

复制字段内容并修改指定字段，在本例中为n。因此，data，

data.flatMap(expand(_))

提供所需的输出。

Answer 2

你很亲密，你可以做到

val dataExpanded = data.flatMap {
case (s, i, l) =>
  List.range(1, i + 1).map { n =>
    (s, n, l)
  }
 }                                               

//> dataExpanded  : List[(String, Int, List[String])] = List((foo,1,List(a, b)),
                        (bar,1,List(c, d)), (bar,2,List(c, d)), (baz,1,List(e, f)))

或者更整洁地

val dataExpanded = data.flatMap {
    case (s, i, l) =>
      (1 to i).map ((s, _, l))
  }

Answer 3

比@enzyme答案更冗长，但这里是一种递归，模式匹配和for表达式生成List元组的方法。

def expand(xs: List[Tuple3[String, Int, List[String]]]): List[Tuple3[String,Int, List[String]]] = xs match {
 case Nil => Nil
 case h :: t => if (h._2 == 1) 
                  h :: expand(t)
                else
                  (for(i <- 1 to h._2) yield (h._1, i, h._3)).toList ++ expand(t)
}

输出：

scala> expand(data)
List[(String, Int, List[String])] = List((foo,1,List(a, b)), (bar,1,List(c, d)), (bar,2,List(c, d)), (baz,1,List(e, f)))

Scala - 在保持相同类型的同时展开各种类型的列表

3 个答案: