FP大串烧：SQL，LINQ，F#以及STL（2）

Aggregate(Count)

聚合（计数）

• 计数操作用于统计原始集合中符合某种条件的成员的个数，结果值为整数。
  计数操作在各语言中的实现方式如下表所示：
  
  

  	Count
  SQL(SELECT)	COUNT函数
  C#(LINQ)	Count扩展方法
  F#(List)	由List.filter和List.Length函数联合实现
  C++(STL)	count, count_if等算法函数
  Haskell(Prelude)	由filter和length函数联合实现
  Java8(stream)	由filter和count方法联合实现

  
  以下示例代码功能为：统计整形集合numbers中奇数成员的个数。
• SQL(SELECT)TABLE(INPUT): NUMBERS FIELD DATA NUM 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 SELECT COUNT(*) AS ODDNUMBERS INTO RESULT FROM NUMBERS WHERE NUM MOD 2 = 1 TABLE(OUTPUT): RESULT FIELD DATA ODDNUMBERS 5
• C#(LINQ)int[] numbers = {5, 4, 1, 3, 9, 8, 6, 7, 2, 0}; int oddNumbers = numbers.Count(n => n % 2 == 1); // oddNumbers = 5
• F#(List)let numbers = [5; 4; 1; 3; 9; 8; 6; 7; 2; 0] let oddNumbers = numbers |> List.filter (fun num -> num % 2 = 1) |> List.length // oddNumbers = 5
• STL(C++)int numbers[] = {5, 4, 1, 3, 9, 8, 6, 7, 2, 0}; int oddNumbers = count_if(numbers, numbers + 10, [](int num){return num % 2 == 1;}); // oddNumbers = 5
• Haskell(Prelude) Prelude> let numbers = [5, 4, 1, 3, 9, 8, 6, 7, 2, 0] Prelude> let count f = length . filter f Prelude> let oddNumbers = count (\n -> n `mod` 2 == 1) numbers Prelude> oddNumbers 5
• Java8(stream) int[] numbers = {5, 4, 1, 3, 9, 8, 6, 7, 2, 0}; long oddNumbers = Arrays.stream(numbers).filter(num -> num % 2 == 1).count(); // oddNumbers = 5

Aggregate(Sum)

聚合（求和）

• 求和操作用于计算原始集合中各成员的总和，结果类型与原始集合成员类型相同。
  求和操作在各语言中的实现方式如下表所示：
  
  

  	Sum
  SQL(SELECT)	SUM函数
  C#(LINQ)	Sum扩展方法
  F#(List)	List.sum, List.sumBy等函数
  C++(STL)	accumulate算法函数
  Haskell(Prelude)	sum函数
  Java8(stream)	sum方法

  
  以下示例代码功能为：计算整形集合numbers中各成员的总和。
• SQL(SELECT)TABLE(INPUT): NUMBERS FIELD DATA NUM 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 SELECT SUM(NUM) AS NUMSUM INTO RESULT FROM NUMBERS TABLE(OUTPUT): RESULT FIELD DATA NUMSUM 45
• C#(LINQ)int[] numbers = {5, 4, 1, 3, 9, 8, 6, 7, 2, 0}; double numSum = numbers.Sum(); // numSum = 45
• F#(List)let numbers = [5; 4; 1; 3; 9; 8; 6; 7; 2; 0] let numSum = List.sum numbers // numSum = 45
• STL(C++)int numbers[] = {5, 4, 1, 3, 9, 8, 6, 7, 2, 0}; int numSum = accumulate(numbers, numbers + 10, 0, [](int acc, int num){return acc + num;}); // numSum = 45
• Haskell(Prelude) Prelude> let numbers = [5, 4, 1, 3, 9, 8, 6, 7, 2, 0] Prelude> let numSum = sum numbers Prelude> numSum 45
• Java8(stream) int[] numbers = {5, 4, 1, 3, 9, 8, 6, 7, 2, 0}; int numSum = Arrays.stream(numbers).sum(); // numSum = 45

Aggregate(Min)

聚合（求最小值）

• 求最小值操作用于找出原始集合中最小的成员，结果类型与原始集合成员类型相同。
  求最小值操作在各语言中的实现方式如下表所示：
  
  

  	Min
  SQL(SELECT)	MIN函数
  C#(LINQ)	Min扩展方法
  F#(List)	List.min, List.minBy等函数
  C++(STL)	min_element算法函数
  Haskell(Prelude)	minimum, minimumBy等函数
  Java8(stream)	min方法

  
  以下示例代码功能为：找出整形集合numbers中最小的成员。
• SQL(SELECT)TABLE(INPUT): NUMBERS FIELD DATA NUM 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 SELECT MIN(NUM) AS MINNUM INTO RESULT FROM NUMBERS TABLE(OUTPUT): RESULT FIELD DATA MINNUM 0
• C#(LINQ)int[] numbers = {5, 4, 1, 3, 9, 8, 6, 7, 2, 0}; int minNum = numbers.Min(); // minNum = 0
• F#(List)let numbers = [5; 4; 1; 3; 9; 8; 6; 7; 2; 0] let minNum = List.min numbers // minNum = 0
• STL(C++)int numbers[] = {5, 4, 1, 3, 9, 8, 6, 7, 2, 0}; int minNum = *min_element(numbers, numbers + 10); // minNum = 0
• Haskell(Prelude) Prelude> let numbers = [5, 4, 1, 3, 9, 8, 6, 7, 2, 0] Prelude> let minNum = minimum numbers Prelude> minNum 0
• Java8(stream) int[] numbers = {5, 4, 1, 3, 9, 8, 6, 7, 2, 0}; int minNum = Arrays.stream(numbers).min().orElse(-1); // minNum = 0

Aggregate(Max)

聚合（求最大值）

• 求最大值操作用于找出原始集合中最大的成员，结果类型与原始集合成员类型相同。
  求最大值操作在各语言中的实现方式如下表所示：
  
  

  	Max
  SQL(SELECT)	MAX函数
  C#(LINQ)	Max扩展方法
  F#(List)	List.max, List.maxBy等函数
  C++(STL)	max_element算法函数
  Haskell(Prelude)	maximum, maximumBy等函数
  Java8(stream)	max方法

  
  以下示例代码功能为：找出整形集合numbers中最大的成员。
• SQL(SELECT)TABLE(INPUT): NUMBERS FIELD DATA NUM 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 SELECT MAX(NUM) AS MAXNUM INTO RESULT FROM NUMBERS TABLE(OUTPUT): RESULT FIELD DATA MAXNUM 9
• C#(LINQ)int[] numbers = {5, 4, 1, 3, 9, 8, 6, 7, 2, 0}; int maxNum = numbers.Max(); // maxNum = 9
• F#(List)let numbers = [5; 4; 1; 3; 9; 8; 6; 7; 2; 0] let maxNum = List.max numbers // maxNum = 9
• STL(C++)int numbers[] = {5, 4, 1, 3, 9, 8, 6, 7, 2, 0}; int maxNum = *max_element(numbers, numbers + 10); // maxNum = 9
• Haskell(Prelude) Prelude> let numbers = [5, 4, 1, 3, 9, 8, 6, 7, 2, 0] Prelude> let maxNum = maximum numbers Prelude> maxNum 9
• Java8(stream) int[] numbers = {5, 4, 1, 3, 9, 8, 6, 7, 2, 0}; int maxNum = Arrays.stream(numbers).max().orElse(-1); // maxNum = 9

Aggregate(Average)

聚合（求平均值）

• 求平均值操作用于计算原始集合中各成员的平均值，结果类型与原始集合成员类型相同。
  求平均值操作在各语言中的实现方式如下表所示：
  
  

  	Average
  SQL(SELECT)	AVG函数
  C#(LINQ)	Average扩展方法
  F#(List)	List.average, List.averageBy等函数
  C++(STL)	无对应算法函数，由accumulate算法函数间接实现
  Haskell(Prelude)	由sum和genericLength函数联合实现
  Java8(stream)	average方法

  
  以下示例代码功能为：计算整形集合numbers中各成员的平均值。
• SQL(SELECT)TABLE(INPUT): NUMBERS FIELD DATA NUM 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 SELECT AVG(NUM) AS AVERAGENUM INTO RESULT FROM NUMBERS TABLE(OUTPUT): RESULT FIELD DATA AVERAGENUM 4.5
• C#(LINQ)int[] numbers = {5, 4, 1, 3, 9, 8, 6, 7, 2, 0}; double averageNum = numbers.Average(); // averageNum = 4.5
• F#(List)let numbers = [5.; 4.; 1.; 3.; 9.; 8.; 6.; 7.; 2.; 0.] let averageNum = List.average numbers // averageNum = 4.5
• STL(C++)int numbers[] = {5, 4, 1, 3, 9, 8, 6, 7, 2, 0}; double averageNum = accumulate(numbers, numbers + 10, 0, [](int acc, int num){return acc + num;}) / 10.; // averageNum = 4.5
• Haskell(Prelude) Prelude> let numbers = [5, 4, 1, 3, 9, 8, 6, 7, 2, 0] Prelude> let averageNum = sum numbers / genericLength numbers Prelude> averageNum 4.5
• Java8(stream) int[] numbers = {5, 4, 1, 3, 9, 8, 6, 7, 2, 0}; double averageNum = Arrays.stream(numbers).average().orElse(-1); // averageNum = 4.5

Aggregate(Simple)

简单聚合

• 简单聚合操作。
  简单聚合操作在各语言中的实现方式如下表所示：
  
  

  	Aggregate(Simple)
  SQL(SELECT)	无对应函数
  C#(LINQ)	Aggregate扩展方法
  F#(List)	List.reduce, List.reduceBack等函数
  C++(STL)	accumulate算法函数
  Haskell(Prelude)	foldl1, foldr1等函数
  Java8(stream)	reduce方法

  
  以下示例代码功能为：计算双精度浮点数集合doubles中所有成员的积。
• SQL(SELECT)
• C#(LINQ)double[] doubles = {1.7, 2.3, 1.9, 4.1, 2.9}; double product = doubles.Aggregate((runningProduct, nextFactor) => runningProduct * nextFactor); // product = 88.330809999999985
• F#(List)let doubles = [1.7; 2.3; 1.9; 4.1; 2.9] let product = List.reduce (fun runningProduct nextFactor -> runningProduct * nextFactor) doubles // product = 88.33081
• C++(STL)double doubles[] = {1.7, 2.3, 1.9, 4.1, 2.9}; double product = accumulate(doubles + 1, doubles + 5, doubles[0], [](double runningProduct, double nextFactor){return runningProduct * nextFactor;}); // product = 88.330809999999985
• Haskell(Prelude) Prelude> let doubles = [1.7, 2.3, 1.9, 4.1, 2.9] Prelude> let productOfDoubles = foldl1 (\runningProduct nextFactor -> runningProduct * nextFactor) doubles Prelude> productOfDoubles 88.33080999999999
• Java8(stream) double[] doubles = {1.7, 2.3, 1.9, 4.1, 2.9}; double productOfDoubles = Arrays.stream(doubles).reduce((acc, n) -> acc * n).getAsDouble(); // productOfDoubles = 88.33080999999999

Aggregate(Seed)

带种子的聚合

• 带种子的聚合操作。
  带种子的聚合操作在各语言中的实现方式如下表所示：
  
  

  	Aggregate(Simple)
  SQL(SELECT)	无对应函数
  C#(LINQ)	Aggregate扩展方法
  F#(List)	List.fold, List.foldBack等函数
  C++(STL)	accumulate算法函数
  Haskell(Prelude)	foldl, foldr等函数
  Java8(stream)	reduce方法

  
  以下示例代码功能为：从账户中扣除提款额（忽略大于存款的提款项目），计算账户余额。
• SQL(SELECT)
• C#(LINQ)double startBalance = 100.0; int[] attemptedWithdrawals = { 20, 10, 40, 50, 10, 70, 30 }; double endBalance = attemptedWithdrawals.Aggregate(startBalance, (balance, nextWithdrawal) => ((nextWithdrawal <= balance) ? (balance - nextWithdrawal) : balance)); // endBalance = 20.0
• F#(List)let startBalance = 100.0 let attemptedWithdrawals = [20; 10; 40; 50; 10; 70; 30] let endBalance = List.fold (fun balance nextWithdrawal2 -> let nextWithdrawal = float nextWithdrawal2 if nextWithdrawal <= balance then balance - nextWithdrawal else balance) startBalance attemptedWithdrawals // endBalance = 20.0
• C++(STL)double startBalance = 100.0; int attemptedWithdrawals[] = {20, 10, 40, 50, 10, 70, 30}; double endBalance = accumulate(attemptedWithdrawals, attemptedWithdrawals + 7, startBalance, [](double balance, int nextWithdrawal){ return ((nextWithdrawal <= balance) ? (balance - nextWithdrawal) : balance);}); // endBalance = 20.000000000000000
• Haskell(Prelude) Prelude> let startBalance = 100.0 Prelude> let attemptedWithdrawals = [20, 10, 40, 50, 10, 70, 30] Prelude> let endBalance = foldl (\balance nextWithdrawal2 -> let nextWithdrawal = fromIntegral nextWithdrawal2 in if nextWithdrawal <= balance then balance - nextWithdrawal else balance) startBalance attemptedWithdrawals Prelude> endBalance 20.0
• Java8(stream) double startBalance = 100.0; int[] attemptedWithdrawals = {20, 10, 40, 50, 10, 70, 30}; double endBalance = Arrays.stream(attemptedWithdrawals).boxed() .reduce(startBalance, (balance, nextWithdrawal) -> (nextWithdrawal <= balance) ? (balance - nextWithdrawal) : balance, Double::sum); // endBalance = 20.0