1.map函数
（Return an Array containing the results of mapping transform）map函数对数组元素进行某种规则的转换并返回一个新的数组
let arr = [1,2,4,5]
let brr = arr.map {
"No."+String($0) 将元素转换为字符串并拼接No.
//$0+1 //将所有元素都加1
}
brr------>["No.1", "No.2", "No.4", "No.5"]
2.flatMap函数
flatMap函数有两种重载形式。这两个重载的函数都是接受一个闭包作为参数，返回一个数组。
public func flatMap<S : SequenceType>(transform: (Self.Generator.Element) throws -> S) rethrows -> [S.Generator.Element]
(Self.Generator.Element) -> S，并且这里 S 被定义成：S : SequenceType。所以它是接受数组元素，然后输出一个 SequenceType 类型的元素的闭包
let arr1 = [[1,2,3],[6,5,4]]
let frr = arr1.flatMap {$0} --->[1, 2, 3, 6, 5, 4]
let grr = Array(arr1.map { $0 }.flatten()) ---->[1, 2, 3, 6, 5, 4]
public func flatMap<T>(@noescape transform: (Self.Generator.Element) throws -> T?) rethrows -> [T]
flatMap 最终输出的数组结果，其实不是这个 T? 类型，而是这个 T? 类型解包之后，不为 .None 的元数数组：[T]
Return an `Array` containing the non-nil results of mapping 返回一个没有nil的map过的数组
let arr2:[Int?] = [1,2,nil,4,nil,5]
let hrr = arr2.flatMap {
$0
}
hrr -----> [1, 2, 4, 5]
flatMap 将数组中nil都丢弃了。只保留非空的值
3.reduce函数
来对数组元素进行某种规则的求和（不一定是加和）
Return the result of repeatedly calling combine with an
accumulated value initialized to initial and each element of self, in turn
public func reduce<T>(initial: T, @noescape combine: (T, Self.Generator.Element) throws -> T) rethrows -> T
initial:初始化的值，combine方法
let crr = arr.reduce(0) { (pre:Int, element:Int) -> Int in
return pre+element
}
上例中initial=0,也就是从0开始用某种规则求和。
pre表示：之前求和的结果 ---> 一开始是0
element：表示即将进入运算的数组中的元素 ---->第一个是 1
pre+element：表示求和的规则 ---->闭包里面的规则自己定义
其他规则的求和
let drr = arr.reduce("") {
if $0 == ""{
return String($1)
}else{
return $0+" "+String($1)
}
}
drr ------> "1 2 4 5"
4.filter函数
返回符合条件的元素的数组
public func filter(@noescape includeElement: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element]
let err = arr.filter { (num:Int) -> Bool in
num%2==0 //需要符合的条件。
}
err -----> [2, 4]
