Scala aggregate()用法及代码示例

aggregate()函数用于组合结果。最初，应用顺序运算，因为它是aggregate()函数的第一个参数，然后进行组合运算，该组合运算用于组合由执行的顺序运算生成的解。此函数可以在Scala中的所有集合数据结构上强制执行，并且可以在Scala的Mutable和Immutable集合数据结构上实践。它属于Scala中的TraversableOnce特性。句法：

def aggregate[B](z:=> B)(seqop:(B, A) => B, combop:(B, B) => B):B

其中，

• B是汇总结果的类型，z是汇总结果的初始值。
• 顺序是序列操作的运算符，用于计算指定集合中每个元素的总和，并枚举集合中元素的总数。
• 组合是一个合并运算符，用于合并通过并行计算集合获得的结果。

• 并行计算：
  让，列表=(2、3、4、5、6、7、8)
  假设您具有上述列表中的三个线程，其中，第一个线程为(2，3，4)，第二个线程为(5，6)，第三个线程为(7，8)。
  现在，让我们执行并行计算。

• First thread = (2, 3, 4) = (2+3+4, 3) = (9, 3)
  // It is evaluated like below,
  // (sum of all the elements, total number of elements)
  

• Second thread = (5, 6) = (5+6, 2) = (11, 2)
  

• Third thread = (7, 8) = (7+8, 2) = (15, 2)
  

  最后，经过并行计算后，我们得到了(9，3)，(11，2)和(15，2)，现在应用此Combine运算符组合每个线程的结果，即

• (9+11+15, 3+2+2) = (35, 7)

现在来看一个例子。
例：

// Scala program of aggregate() 
// function 
  
// Creating an object 
object GfG 
{ 
  
    // Main method 
    def main(args: Array[String])  
    { 
  
        // Creating a list of numbers 
        val s = List(1, 2, 3, 4) 
  
        // Applying aggregate function 
        val r = s.par.aggregate((0, 0))((s, r) =>(s._1 + r, s._2 + 1),  
                                (s,r) => (s._1 + r._1, s._2 + r._2)) 
  
        // Displays summation of all the  
        // elements in the list and also 
        // total number of elements 
        println("(Sum of all the elements , total number of elements) = "+r) 
    } 
}

(Sum of all the elements, total number of elements) = (10, 4)

在这里，par表示并行，该并行用于列表的并行计算。我们将详细讨论三个部分。

aggregate(0, 0)

这是aggregate()函数具有两个零的第一部分，这两个零是寄存器s的初始值，因此s._1是第一个零，用于计算列表中所有元素的总和，而s._2也是开头为零，这有助于枚举列表中元素的总数。

(s._1 + r, s._2 + 1)

这是第二部分，它对上述列表执行序列操作。该代码的第一部分评估总和，第二部分用于计算总元素。现在，让我们逐步查看评估。
在此，列表=(1、2、3、4)

(s._1 + r, s._2 + 1) // (Initially, s._1 and s._2 = 0) 
= (0+1, 0+1) = (1, 1) // r is the initial value of the list
= (1+2, 1+1) = (3, 2)
= (3+3, 2+1) = (6, 3)
= (6+4, 3+1) = (10, 4)

这说明了评估是如何精确完成的。

(s._1 + r._1, s._2 + r._2)

这是最后一部分，如上面在并行计算中所述，它用于合并操作。假设在对列表(1、2、3、4)进行并行计算期间，将其分为两个线程，即(1、2)和(3、4)，然后逐步对其进行评估。第一个线程：

(1, 2) = (1+2, 2) = (3, 2)

第二个线程：

(3,  4) = (3+4, 2) = (7, 2)

现在，让我们使用如上所述的合并运算符来合并两个线程，即(3，2)和(7，2)。

(s._1 + r._1, s._2 + r._2) // s._1 and s._2 = 0
= (0+3, 0+2) = (3, 2)       // r._1 = 3 and r._2 = 2
= (3+7, 2+2) = (10, 4)        // r._1 = 7 and r._2 = 2

因此，该部分的工作方式如下。

让我们来看另一个例子。
例：

// Scala program of aggregate() 
// function 
  
// Creating an object 
object GfG 
{ 
  
    // Main method 
    def main(args: Array[String])  
    { 
  
        // Creating a sequence of strings 
        val seq = Seq("nidhi", "yes", "sonu", "Geeks") 
  
        // Applying aggregate function 
        val result = seq.par.aggregate(0)(_ + _.length, _ + _) 
  
        // Displays total number of 
        // letters used 
        println("The total number of letters used are:"+result) 
    } 
}

The total number of letters used are:17

此处，聚合函数的初始值为零，用于计算此处使用的字符串中字母的总数。方法的长度用于枚举每个字符串的长度。让我们详细讨论以上程序中使用的以下代码。

(_ + _.length, _ + _)

在此，Seq =(“nidhi”，“yes”，“sonu”，“Geeks”)

让我们先执行序列操作。

 (0 + "nidhi".length ) // (0+5) = 5
 (0 + "yes".length)     // (0+3) = 3
 (0 + "sonu".length)       // (0+4) = 4
 (0 + "Geeks".length)        // (0+5) = 5

因此，我们从序列运算中得到(5)，(3)，(4)，(5)。
现在，让我们执行合并操作。

(5+3) = 8 
(4+5) = 9
// Now lets combine it again
(8+9) = 17

因此，字母总数为17。