Scala 快速入门

Scalable 编程语言
纯正的的面向对象语言
函数式编程语言
无缝的java互操作

scala之父 Martin Odersky

1. 函数式编程

函数式编程(functional programming) 或称函数程序设计，又称泛函编程，是一种编程范型
它将电脑运算视为数学上的函数计算，并且避免使用程序状态以及易变对象。
函数编程语言最重要的基础是λ演算（lambda calculus), 而且λ演算的函数可以接受函数当作输入（引数）和输出（传出值）。
函数式编程强调程序执行的结果而非执行的过程，倡导利用若干简单的执行单元让计算结果不断渐进，逐层推导复杂的运算，而不是设计一个复杂的执行过程。

1.1 函数式编程的重要概念

使用纯函数编程, 纯函数是没有副作用的函数

1.副作用

所谓"副作用"（side effect），指的是函数内部与外部互动（最典型的情况，就是修改全局变量的值），产生运算以外的其他结果。

函数式编程强调没有"副作用"，意味着函数要保持独立，所有功能就是返回一个新的值，没有其他行为，尤其是不得修改外部变量的值。

var x = 1
def XplusY_v1(y: Int) = x+y
def XplusY_v2(y: Int) = {x = x+y; x}

这里 XplusY_v2对 x 就有副作用, 函数执行之后 x 的状态会发生变化

而 XplusY_v1 执行之后不会改变 x 的值, XplusY_v1是纯函数

2.引用透明性

定义: 如果f(x)的参数和函数体都是引用透明的, 那么函数f是纯函数

特点: 对于相同的输入, 总是得到相同的输出.就是说，表达式的值不依赖于值可以改变的全局状态。

var x = new StringBuild("Hello")
var y = x.append("world")
var z = x.append("world")

上面形同的表达式x.append("world")得到的结果不同, 由于x是一个值可以改变的变量

3.不变性(Immutablity)

为了获得透明性, 任何值都不能改变

4.函数是一等公民

(First-class Function)

函数与其他数据类型一样，处于平等地位，可以赋值给其他变量，也可以作为参数，传入另一个函数，或者作为别的函数的返回值。

5.只有表达式

一切都是计算, 函数式编程中只有表达式, 变量, 函数都是表达式

"表达式"（expression）是一个单纯的运算过程，总是有返回值；"语句"（statement）是执行某种操作，没有返回值。也就是说，每一步都是单纯的运算，而且都有返回值。

6.闭包和高阶函数

函数编程支持函数作为第一类对象，有时称为闭包或者仿函数（functor）对象。实质上，闭包是起函数的作用并可以像对象一样操作的对象。

高阶函数(Higher order Function)可以用另一个函数（间接地，用一个表达式）作为其输入参数，在某些情况下，它甚至返回一个函数作为其输出参数。

7.表达式求值策略

严格求值
非严格求值
惰性求值

8.递归函数

递归实现循环: 尾递归

1.2 函数式编程的优势

生产效率高
易于推理
并行计算
多核计算

2. MacOS安装scala开发环境

3步走:

安装scala

brew install scala
安装sbt

brew install sbt
Intellj IDEA上scala ,sbt插件下载

3. Scala 类型体系

4. Scala求值策略

Scala有两种求值策略

－ Call By Value 对函数实参求值，且只求一次，如果作为参数值需要对表达式先进行求值

－ Call By Name 对函数实参每次在函数体内被调用时都会求值

通常使用Call By Value

如果函数形参以 => 开头，那么会使用Call By Name

def foo(x: Int) = x // call by value

def foo(x: => Int) = x //call by name

例子

def test1(x: Int, y: Int): Int = x * x
def test2(x: => Int, y: => Int): Int = x * x
计算过程:
test1(3+4, 8) | test2(3+4, 8) |  test1(7, 2 *4)  | test2(7, 2 *4)
test1(7, 8)   | (3+4)*(3+4)   |  test1(7, 8)     | 7*7
7*7           | 7*(3+4)       |  7*7             | 49
49            | 7*7           |  49              |
              | 49            |                  |

def bar1(x: Int, y: =>Int) = 1
def bar2(x: => Int, y: =>Int) = 1
def loop(): Int = loop
bar1(loop, 1) 死循环, 这里实参一直带求值loop, 一直没法拿到值
bar2(loop, 1) 表达式值为1

5. Scala函数

scala中函数是第一等公民:

把函数作为实参传给另一个函数
把函数作为返回值
把函数赋值给变量
把函数存储在数据结构中

在Scala中函数和普通变量一样, 同样也具有函数类型

5.1 函数类型

在Scala中, 函数类型格式为 A => B

表示一个接受类型A的参数, 并返回类型B的参数, 如 Int => String

5.2 高阶函数

用函数作为形参或者返回值的函数, 称为高阶函数

def operate(f: (int, int) => Int) = {
    f(4, 4)
}
def greeting() = (name: String) => {"hello" + " " + name} // 匿名函数

5.3 匿名函数

匿名函数就是函数常量, 也称为函数文字量

scala中匿名函数的格式为:

(形参列表) => (函数体)

scala> (x: Int, y: Int) => x+y
res2: (Int, Int) => Int = $$Lambda$1209/886693791@35c8be21
scala> res2(1, 4)
res3: Int = 5

5.4 柯里化函数(curried function)

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

下面两个例子的函数定义是等价的:

def add(x: Int, y: Int) = x + y

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

def curriedAdd(x: Int)(y: Int) = x + y
curriedAdd(1)(2)    //4
val addOne = curriedAdd(1)_     // Int => Int
addOne(2)   //3

5.5 递归函数

递归函数是函数式编程中实现循环的一种技术

def factorial(n: Int): Int = {
    if (n == 0) 1 else n * factorial(n-1)
}

尾递归

@annotation.tailrec
def factorial(n: Int, m: Int): Int = {
    if (n == 0) m else factorial(n-1, n * m)
}

@annotation.tailrec 告诉 scala使用尾递归, 这里内存中开辟一个栈用来存储m的值, 而不是n个栈来存储计算中间结果

5.6 例子

def sum(f: Int => Int)(a: Int)(b: Int): Int = {
    @annotation.tailrec
    def loop(n: Int, acc: Int): Int = {
        if (n > b) acc
        else loop(n + 1, acc + f(n))
    }
    loop(a, 0)
}
sum(x => x)(1)(3) // 6
sum(x => x * x)(1)(3) //14
val s1 = sum(x => x * x)_  // 偏函数, _ 通配符用来匹配后面的参数
s1(1)(3)  //14

说明:

1.上面是个科里化函数, 有三个形式参数

函数f, 函数类型 Int > Int
形参a, 类型Int
形参b, 类型Int

2.函数中定义了一个尾递归函数 loop, 实现相加

3.sum(x => x), 其中 x => x 是一个匿名函数

6. Scala 集合

scala.collection.immutable

6.1 List[T]

T 表示泛型


// :: 连接操作符
val a = List(1, 2, 3, 4)
val b = 0 :: a
//a: List[Int] = List(1, 2, 3, 4)
//b: List[Int] = List(0, 1, 2, 3, 4)
// Nil表示一个空列表
// 先 z 连接 Nil, 然后 y 连接 z ...
val c = "x" :: "y" :: "z" :: Nil
//c: List[String] = List(x, y, z)
// Any 类型
val d = a ::: c
//d: List[Any] = List(1, 2, 3, 4, x, y, z)
// 返回List的第一个元素
a.head
c.head
d.head
//res0: Int = 1
//res1: String = x
//res2: Any = 1
// 返回除了第一个元素之外元素组成的 List
a.tail
c.tail
d.tail
//res3: List[Int] = List(2, 3, 4)
//res4: List[String] = List(y, z)
//res5: List[Any] = List(2, 3, 4, x, y, z)
a.isEmpty
Nil.isEmpty
//res6: Boolean = false
//res7: Boolean = true
def walkthru(l : List[Int]): String = {
  if (l.isEmpty) ""
  else l.head.toString + walkthru(l.tail)
}
walkthru(List(1, 3, 5, 7))
//walkthru: walkthru[](val l: List[Int]) => String
//res8: String = 1357

其他方法


a.filter(x => x%2 == 1)
//res9: List[Int] = List(1, 3)
"hello life".toList
//res10: List[Char] = List(h, e, l, l, o,  , l, i, f, e)
"hel 89 life".toList.filter(x => Character.isDigit(x))
//res11: List[Char] = List(8, 9)
"hel 89 life".toList.takeWhile(x=>x!='9')
//res12: List[Char] = List(h, e, l,  , 8)
// _ 通配符
c
c.map(x => x.toUpperCase)
c.map(_.toLowerCase)
//res13: List[String] = List(x, y, z)
//res14: List[String] = List(X, Y, Z)
//res15: List[String] = List(x, y, z)
a
a.filter(_ % 2 == 1).map(_ + 10)
//res16: List[Int] = List(1, 2, 3, 4)
//res17: List[Int] = List(11, 13)
val q = List(a, List(5, 6, 7))
q.map(_.filter(_%2 == 0))
q.flatMap(_.filter(_%2 == 0))
//q: List[List[Int]] = List(List(1, 2, 3, 4), List(5, 6, 7))
//res18: List[List[Int]] = List(List(2, 4), List(6))
//res19: List[Int] = List(2, 4, 6)

6.2 归约操作

6.2.1 reduceleft

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

a
a.reduceLeft((x, y) => x+y)
a.reduce(_ + _)
// res20: List[Int] = List(1, 2, 3, 4)
// res21: Int = 10
// res22: Int = 10

6.2.2 foldLeft

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

a.foldLeft(1)(_ + _)

a
a.foldLeft(1)(_ + _)
// res20: List[Int] = List(1, 2, 3, 4)
// res23: Int = 11

7. Range & Stream & tuple & Map

7.1 Range & Stream

1 to 4
(1 to 7 by 2).toList
1 until 6
//res24: scala.collection.immutable.Range.Inclusive = Range 1 to 4
// res25: List[Int] = List(1, 3, 5, 7)
// res26: scala.collection.immutable.Range = Range 1 until 6
// Stream 惰性求值
1 #:: 2  #:: 3  #:: Stream.empty
//scala.collection.immutable.Stream[Int] = Stream(1, ?)
val stream = (1 to 1000000).toStream
//res28: scala.collection.immutable.Stream[Int] = Stream(1,?)
stream.tail
stream.head
//res28: scala.collection.immutable.Stream[Int] = Stream(2, ?)
//res29: Int = 1

7.2 tuple

(1, 2)
val tuple1 = (3, "hello", (1, "we"))
tuple1._1
tuple1._3._1
// res30: (Int, Int) = (1,2)
// tuple1: (Int, String, (Int, String)) = (3,hello,(1,we))
// res31: Int = 3
// res32: Int = 1
def sumSq(in: List[Int]): (Int, Int, Int) = {
  in.foldLeft((0,0,0))((t,v) => (t._1 + 1, t._2 + v, t._3 + v*v))
}
a
sumSq(a)
//sumSq: sumSq[](val in: List[Int]) => (Int, Int, Int)
// res33: List[Int] = List(1, 2, 3, 4)
// res34: (Int, Int, Int) = (4,10,30)

7.3 Map(K, V)

// 键的类型要一致, 值得类型可以不一致
val map = Map(1 -> "david", 9 -> "ds")
map(9)
map.contains(1)
map.contains(2)
//scala.collection.immutable.Map[Int,String] = Map(1 -> david, 9 -> ds)
// String = ds
// Boolean = true
// Boolean = false
map.keys
map.values
// 下列操作map自身是不变的
map + (8 -> 3)
map
map - 1
map
//scala.collection.immutable.Map[Int,Any] = Map(1 -> david, 9 -> ds, 8 -> 3)
// Map(1 -> david, 9 -> ds)
// scala.collection.immutable.Map[Int,String] = Map(9 -> ds)
// scala.collection.immutable.Map[Int,String] = Map(1 -> david, 9 -> ds)
// 添加多个元素, 如果添加的key已经存在, 则更新
map ++ List(2 -> "Alice", 1-> "Hello")
//Map(1 -> Hello, 9 -> ds, 2 -> Alice)
map -- List(2, 1, 9)
// Map()
// 如果key不存在则忽略

7.4 快排

def qSort(a: List[Int]): List[Int] = {
  if (a.length < 2) a
  else qSort(a.filter(a.head > _)) ++
  a.filter(a.head == _) ++
  qSort(a.filter(a.head < _))
}
qSort(List(1, 4, 2, 3, 9, 5))
//res46: List[Int] = List(1, 2, 3, 4, 5, 9)