斯卡拉 |聚合()函数

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

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

在哪里，

B是聚合结果的类型， z是聚合结果的初始值。
seqop是用于序列操作的运算符，用于计算所述集合中每个元素的总和，并枚举集合中元素的总数。
combop是一个组合运算符，用于组合集合的并行计算获得的结果。

并行计算：
让，列表 = (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)，现在这个组合运算符用于组合每个线程的结果，即，
```
(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)

这是最后一部分，它用于组合操作，如上文在并行计算中所述。假设在 list(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用于枚举每个字符串的长度。
让我们详细讨论上述程序中使用的以下代码。

(_ + _.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。