集合的归约：

reduceLeft(匿名函数)：将集合中的元素，按匿名函数的规则进行处理，处理的结果的类型和集合元素的类型一致

reduceLeft（op:  (T,T)  => T）

foldLeft(初始值)(匿名函数)：将集合中的元素与初始值，按匿名函数的规则进行处理，处理的结果类型与初始值类型一致。

foldLeft(z  : U)(op: (U,  T) =>U)

list-map高阶函数：

map(匿名函数)：映射出新的集合

flatMap(匿名函数)：将元素为集合的集合，转换为普通元素的集合

List的高阶函数：

filter(判断函数)：遍历集合，保留符合判断函数的元素

toList:将字符串变成List[Char]集合

takeWhile(判断函数)：遍历集合，根据判断函数截取集合元素

scala中数据集合类型：

Set ：无序元素

Seq : 有序元素

Map：键值对

val  a = List (1,2,3,4,5)

val b = 0 :: a        ::  元素和集合连接，元素只能在前

结果  val b = List (0,1,2,3,4,5)

::: 集合和集合连接

head   取集合的第一个元素

tail      生成伪列表（去除第一个元素，输出含有剩余元素的集合）

isEmpty 判断集合是否为空（不为空false，为空true）

def sum(f: Int => Int)(a: Int)(b: Int): Int = {

    @annotation.tailrec
    def loop(n: Int, acc: Int): Int = {
      if (n < a) {
        println(s"n=${n},acc=${acc}")
        acc
      } else {
        println(s"n=${n},acc=${acc}")
        loop(n - 1, acc + f(n))
      }
    }
    loop(b, 0)
  }                                               //> sum: (f: Int => Int)(a: Int)(b: Int)Int

  sum(x => x)(1)(5)                               //> n=5,acc=0
                                                  //| n=4,acc=5
                                                  //| n=3,acc=9
                                                  //| n=2,acc=12
                                                  //| n=1,acc=14
                                                  //| n=0,acc=15
                                                  //| res0: Int = 15

  sum(x => x * x)(1)(5)                           //> n=5,acc=0
                                                  //| n=4,acc=25
                                                  //| n=3,acc=41
                                                  //| n=2,acc=50
                                                  //| n=1,acc=54
                                                  //| n=0,acc=55
                                                  //| res1: Int = 55

  def sum2(f: Int => Int)(a: Int)(b: Int): Int = {
    @annotation.tailrec
    def loop(n: Int, acc: Int): Int = {
      if (n > b) {
        println(s"n=${n},acc=${acc}")
        acc
      } else {
        println(s"n=${n},acc=${acc}")
        loop(n + 1, acc + f(n))
      }

    }
    loop(a, 0)
  }                                               //> sum2: (f: Int => Int)(a: Int)(b: Int)Int
  sum2(x => x)(1)(5)                              //> n=1,acc=0
                                                  //| n=2,acc=1
                                                  //| n=3,acc=3
                                                  //| n=4,acc=6
                                                  //| n=5,acc=10
                                                  //| n=6,acc=15
                                                  //| res2: Int = 15

  sum2(x => x * x)(1)(5)                          //> n=1,acc=0
                                                  //| n=2,acc=1
                                                  //| n=3,acc=5
                                                  //| n=4,acc=14
                                                  //| n=5,acc=30
                                                  //| n=6,acc=55
                                                  //| res3: Int = 55

递归函数：n!

def factorial(n: Int): Int =

    if (n <= 0) 1

    else n * factorial(n - 1)

尾递归函数：对递归函数的优化

  def factorial(n: Int, m: Int): Int =
    if (n <= 0) m
    else factorial(n - 1, m * n)                  //> factorial: (n: Int, m: Int)Int

  factorial(5, 1)                                 //> res0: Int = 120

  factorial(5,1)的计算逻辑：

  (5,1)=>(5-1,5*1)=>(4-1,5*1*4)=>(3-1,5*1*4*3)=>(2-1,5*1*4*3*2)=>(1-1,5*1*4*3*2*1)=>5*1*4*3*2*1

注：scala中也有while，do ...  while，for循环语法,但其运行逻辑不符合函数式编程思想，所以不建议使用，而建议使用递归实现循环

柯里化语法：把方法的参数列表中的参数，分别取出，单独放到小括号中。

例如：def  add(x: Int, y: Int) = x + y     正常方法定义

          def  add(x: Int)(y: Int) = x + y     柯里化语法

在开发中可以利用柯里化方法基础，简单实现新方法功能，而不需要重新完全定义一个新函数

def  greeting() =(name : String) => {s"Hello  $name"}

与

def  greeting() =(name : String) => {"Hello"+" "+name}

为相同返回值的函数

高阶函数：

函数作为参数或者返回值的函数

匿名函数：

（形参） => {函数}

try 表达式： 基本和java中try catch 相似

_ 下划线代表通配符，也就是代表任何输出

match 表达式：类似java中的switch

exp  match {

 case p1 => val1

 case p2 => val2

 ...

 case _ => valn

}

for comprehension  循环

for{

     x <- xs   // 遍历 xs ,每循环一次将xs中的一个值赋给x

     y = x + 1

     if （y > 0）

} yield y 

yield 输出一个List

println 一个一个输出

代码块Block：{表达式；表达式}

或者

{

表达式

表达式

}

代码块也是一个表达式，其最终求得的值是最后一个表达式的值。

scala中函数的定义：

def    函数名 （参数：参数类型，参数：参数类型）：返回值类型={

函数的表达式

}

Scala里有2种求值策略：

Call by Value    对函数实参求值，且仅求值一次 如：   def foo(x: Int) = x

Call by Name   函数实参每次在函数体内被用到时都会求值  如：

def foo(x: => Int) = x

恰当的运用这2中求值策略，会提高代码的运行效率

柯里化函数：把具有多个参数的函数转换成一条函数链，每个节点上是单一参数

def curriedAdd(a: Int)(b: Int) = a + b

val addOne = curriedAdd(1)_ // 偏应用函数，只有b是灵活可变的。

//1传给变量a，_为通配符，

addOne(2) //3     2将传递给b