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)