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。