==> 常用函数讲解

        ---> map   作用于列表中的每一个元素

1
2
3
4
5
6
7
8
// 定义一个列表 
val  list =  List( 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 )
 
// list 列表中的所有元素乘以2
list.map((i : Int)  = > i* 2 )
 
// 使用 foreach 做相同的操作，foreach 不会返回值
list.foreach((i : Int)  = > i* 2 )


        ---> filter    过滤返回值为 False 的元素

1
2
3
4
5
6
val  list  =  List( 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 )
 
list.filter((i : Int)  = > i % 2 == 0 )
// 返回结果为：List[Int] = List(2, 4, 6, 8)
// 还可写作
num.filter( _% 2 == 0 )


        ---> zip 将两个数组合并

1
2
3
List( 1 , 2 , 3 ).zip(List( 4 , 5 , 6 ))
// 输出结果为
List[(Int, Int)]  =  List(( 1 , 4 ), ( 2 , 5 ), ( 3 , 6 ))


        ---> partition    将符合过滤规则的元素放在一个分区，将不符合过滤规则的放在别一个分区

1
2
List( 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ).partition((i : Int)  = > i % 2 == 0 )
// 输出结果为：(List[Int], List[Int]) = (List(2, 4, 6, 8),List(1, 3, 5, 7, 9))


        ---> find   找到列表中第一个符合规则的元素

        ---> flatten  压平操作，将三维数组转化成二维数组或将二维数组转化为一维数组，需要注意的是，转化时必须保证每个元素还能够再进行提取，否则会报错

1
2
3
4
5
6
7
8
9
10
11
12
13
List(List( 1 ,List( 2 , 3 , 4 )), List(List( 5 , 6 , 7 ),List( 8 , 9 ))).flatten
 
 
// 如果要继续进行压平操作，刚会报错
List(List( 1 ,List( 2 , 3 , 4 )), List(List( 5 , 6 , 7 ),List( 8 , 9 ))).flatten.flatten
error :
<console> : 12 :  error :  No  implicit  view available from Any  = > scala.collection.GenTraversableOnce[B].
List(List( 1 ,List( 2 , 3 , 4 )), List(List( 5 , 6 , 7 ),List( 8 , 9 ))).flatten.flatten
 
// 若要继续压平操作，需将处理处理修改一下
List(List(List( 1 ),List( 2 , 3 , 4 )), List(List( 5 , 6 , 7 ),List( 8 , 9 ))).flatten.flatten
 
// 结果为：List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)


        ---> flatMap    相当于 Map 与 flatten 两个功能的结合体

1
2
3
4
5
6
val  list  =  List(List( 1 , 2 , 3 ),List( 4 , 5 , 6 ))
// 此处的 x 相当于将源数据 flatten 压平后得到的结果，然后对每个元素进行操作
list.flatMap(x = >x.map( _ * 2 ))
// 此条语句等价于以下两步操作
val  x  =  list.flatten
x.map( _ * 2 )



==> 闭包    函数的嵌套

        ---> 定义普通函数： 

1
def  myfun(x : Int, y : Int) : Int  =  x * y


        ---> 采用闭包

1
2
3
4
5
6
7
8
// 定义一个闭包函数，其中，x 为乘数因子，即：乘以的倍数（我自己理解为被乘数），y 是使用函数传入的参数
def  myfun(x : Int) = (y : Int)  = > x * y
 
// 第一步先定义自己函数的模型
val  mytest  =  myfun( 2 )
 
// 使用自己定义好的函数模型，传入参数
mytest( 20 )


==> 柯里化  一个数学家的名子，其本质是将一个多参数函数转换成函数链，每个节点上都有一个单一参数的函数

        举例：

1
2
3
def  add(x : Int, y : Int) : Int  =  x + y
 
def  add(x : Int)(y : Int)  =  x + y