foldLeft

Question

我在输入中有以下列表：

val listInput1 = 
  List(
    "itemA,CATs,2,4",
    "itemA,CATS,3,1",
    "itemB,CATQ,4,5",
    "itemB,CATQ,4,6",
    "itemC,CARC,5,10")

并且我想使用groupBy和foldleft（只是一个函数）在scala中编写一个函数，以便为具有相同标题的行（此处第一列）总结第三和第四列，所需输出为：

val listOutput1 = 
      List(
         "itemA,CATS,5,5",
         "itemB,CATQ,8,11",
         "itemC,CARC,5,10"

       )


 def sumIndex (listIn:List[String]):List[String]={

 listIn.map(_.split(",")).groupBy(_(0)).map{ 
  case (title, label) => 
       "%s,%s,%d,%d".format(
         title,
         label.head.apply(1),
         label.map(_(2).toInt).sum,
         label.map(_(3).toInt).sum)}.toList

}

亲切的问候

Answer 1

您可以使用单个foldLeft解决它，只迭代输入列表一次。使用Map聚合结果。

listInput1.map(_.split(",")).foldLeft(Map.empty[String, Int]) {
  (acc: Map[String, Int], curr: Array[String]) =>
    val label: String = curr(0)
    val oldValue: Int = acc.getOrElse(label, 0)
    val newValue: Int = oldValue + curr(2).toInt + curr(3).toInt
    acc.updated(label, newValue)
}

结果：地图（itemA - ＆gt; 10，itemB - ＆gt; 19，itemC - ＆gt; 15）

Answer 2

如果您有列表为

val listInput1 =
  List(
    "itemA,CATs,2,4",
    "itemA,CATS,3,1",
    "itemB,CATQ,4,5",
    "itemB,CATQ,4,6",
    "itemC,CARC,5,10")

然后你可以编写一个可以与foldLeft和reduceLeft一起使用的常规函数

def accumulateLeft(x: Map[String, Tuple3[String, Int, Int]], y: Map[String, Tuple3[String, Int, Int]]): Map[String, Tuple3[String, Int, Int]] ={
  val key = y.keySet.toList(0)
  if(x.keySet.contains(key)){
    val oldTuple = x(key)
    x.updated(key, (y(key)._1, oldTuple._2+y(key)._2, oldTuple._3+y(key)._3))
  }
  else{
    x.updated(key, (y(key)._1, y(key)._2, y(key)._3))
  }
}

您可以将其称为

foldLeft

listInput1
  .map(_.split(","))
  .map(array => Map(array(0) -> (array(1), array(2).toInt, array(3).toInt)))
  .foldLeft(Map.empty[String, Tuple3[String, Int, Int]])(accumulateLeft)
  .map(x => x._1+","+x._2._1+","+x._2._2+","+x._2._3)
  .toList
//res0: List[String] = List(itemA,CATS,5,5, itemB,CATQ,8,11, itemC,CARC,5,10)

reduceLeft

listInput1
  .map(_.split(","))
  .map(array => Map(array(0) -> (array(1), array(2).toInt, array(3).toInt)))
  .reduceLeft(accumulateLeft)
  .map(x => x._1+","+x._2._1+","+x._2._2+","+x._2._3)
  .toList
//res1: List[String] = List(itemA,CATS,5,5, itemB,CATQ,8,11, itemC,CARC,5,10)

同样，您可以只交换常规函数中的变量，以便它可以与foldRight和reduceRight一起使用

def accumulateRight(y: Map[String, Tuple3[String, Int, Int]], x: Map[String, Tuple3[String, Int, Int]]): Map[String, Tuple3[String, Int, Int]] ={
  val key = y.keySet.toList(0)
  if(x.keySet.contains(key)){
    val oldTuple = x(key)
    x.updated(key, (y(key)._1, oldTuple._2+y(key)._2, oldTuple._3+y(key)._3))
  }
  else{
    x.updated(key, (y(key)._1, y(key)._2, y(key)._3))
  }
}

并且调用该函数会给你

foldRight

listInput1
  .map(_.split(","))
  .map(array => Map(array(0) -> (array(1), array(2).toInt, array(3).toInt)))
  .foldRight(Map.empty[String, Tuple3[String, Int, Int]])(accumulateRight)
  .map(x => x._1+","+x._2._1+","+x._2._2+","+x._2._3)
  .toList
//res2: List[String] = List(itemC,CARC,5,10, itemB,CATQ,8,11, itemA,CATs,5,5)

reduceRight

listInput1
  .map(_.split(","))
  .map(array => Map(array(0) -> (array(1), array(2).toInt, array(3).toInt)))
  .reduceRight(accumulateRight)
  .map(x => x._1+","+x._2._1+","+x._2._2+","+x._2._3)
  .toList
//res3: List[String] = List(itemC,CARC,5,10, itemB,CATQ,8,11, itemA,CATs,5,5)

因此，您确实不需要groupBy ，并且可以使用foldLeft，foldRight，reduceLeft或{ {1}}用于获得所需的输出。

Answer 3

代码中的逻辑看起来很合理，这里实现了case class，因为它可以更清晰地处理边缘情况：

// represents a 'row' in the original list
case class Item(
                 name: String,
                 category: String,
                 amount: Int,
                 price: Int
               )

// safely converts the row of strings into case class, throws exception otherwise
def stringsToItem(strings: Array[String]): Item = {
  if (strings.length != 4) {
    throw new Exception(s"Invalid row: ${strings.foreach(print)}; must contain only 4 entries!")
  } else {
    val n = strings.headOption.getOrElse("N/A")
    val cat = strings.lift(1).getOrElse("N/A")
    val amt = strings.lift(2).filter(_.matches("^[0-9]*$")).map(_.toInt).getOrElse(0)
    val p = strings.lastOption.filter(_.matches("^[0-9]*$")).map(_.toInt).getOrElse(0)

    Item(n, cat, amt, p)
  }
}

// original code with case class and method above used
listInput1.map(_.split(","))
  .map(stringsToItem)
  .groupBy(_.name)
  .map { case (name, items) =>
    Item(
      name,
      category = items.head.category,
      amount = items.map(_.amount).sum,
      price = items.map(_.price).sum
    )
  }.toList

与foldleft scala分组

3 个答案:

foldLeft

reduceLeft

foldRight

reduceRight