object sortDemo {
 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 < _))
 }

 def main(args: Array[String]): Unit = {
   println(qSort(List(6,4,5,3,1,2,9,8,0)))
 }
}

实现快速排序

Map

定义一个Map: val p = Map(1 -> "David", 9 -> "Bob")

取出值：p(key), 比如：p(1), p(9)

判断key是不是在map中： p.contains(key)

取出所有key: p.keys

取出所有值：p.values

添加一个键值： p + (8 -> "Tom")

删除一个键值： p - 1

添加多个键值对： p ++ List(2-> "Alice", 5 -> "piter")

减去多个键值对： p -- List(1, 9, 2)

Tuple（元组）：

定义2个字段的元组  （1,2） 或  1 ->2

访问元组中的元素： z._1 (z元组的第一分量)

Map[K,V]:

定义Map   val  p = Map(1  ->  "David",9   ->"Lili")

                              Map(1 -> David, 9 -> Lili) 

p(1)       David   取p Map 的值

p.contains(1)   判断key在不在  p Map中

p.keys   取所有key

p.values  取所有value

p + ( k -> v)  添加值

p -  k    删除值

p  ++ List(k -> v ,k -> v)  添加多个值

p  --  List(k,k)  减去多个值

Stream 惰性求值

Range(整数序列)：

生成Range

1 to 10     Range(1,2,3,4,5,6,7,8,9,10)

1 to 10  by 2    Range(1,3,5,7,9)

1 until 10  Range(1,2,3,4,5,6,7,8,9)

Stream(惰性求值列表)：

列表的第一个值确定，其他值在使用时才会计算

1  #::  2 #:: 3 #::  Stream.empty                Stream(1,  ?)

val  stream = (1  to  1000000).toStream     Stream(1, ?)

.head  第一个值

.tail     第一个值后面的所有值

集合的归约：

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

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

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

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

List高阶函数：

map：根据函数规则对List中的每个参数做映射

c.map(x=>x.toUpperCase) 等价于 c.map( _.toUpperCase  )

与filter不同：filter的规则是Boolean类型的

flatMap：将多层的List打平

List的高阶函数：

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

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

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

//for
for {
    x <- xs
    y= x+1
    if(y>0)
}yield y

//if
if (exp) valA else valB

函数 代码块

def function( param: ParamType): ReturenType={
    //body
}

三种变量修饰符
val 定义常量，不可修改
var 定义变量
lazy val 只要第一次使用到时候，才会运算表达式得到值
可以不显示指定变量的类型，因为Scala会自动进行类型推导

Unit类型： 类似Java的Void， 一般作为函数返回值

有Unit一般是副作用，因为函数没返回值

异常值: ()Nothiong

String
- 构建于Java的String之上
- 新增了字符串插值（interpolation）的特性

```scala
val myname = "lizhy" \\ creating a String
s"My name is ${myname}" \\ String interpolation
```

在scala语言中，所有的事物都是对象

在计算机科学领域，函数式编程是一种编程范式，它是一种构建计算机程序结构的方法和风格，它把程序当做数学函数的求值过程并且避免了改变状态和可变的数据。
二、函数式编程的重要概念：
2.1 纯函数（Pure Function），或函数的纯粹性（Purity），没有副作用（Side Effect）。
副作用是状态的变化（mutation）：例子：修改全局变量，抛出异常，IO读写，调用有副作用的函数。

2.2 引用透明（Referential Transparency）：对于相同的输入，总是得到相同的输出。
如果f（x）的参数x和函数体都是引用透明的，那么函数f是纯函数。

2.3 不变性（Immutability）为了获得引用透明性，任何值都不能变化。
2.4 函数是一等公民（First-class Function）：一切都是计算，函数式编程中只有表达式，变量、函数都是表达式。
三、高阶函数（Higher order Function）
闭包（Closure）
表达式求值策略：严格求值 和 非严格求值  Call By Value  vs.  Call By Name
惰性求值（Lazy Evaluation）：定义表达式不会立即求值，用到后才会求值。
递归函数，函数式编程没有循环，循环由递归实现。调优递归：尾递归。

Scalable编程语言。
纯正的面向对象语言。
函数式语言。
构建于jvm之上，能互相直接调用，无缝和java互操作。

JAVA和SCALA互相直接调用！

块

快排

快排

图

柯里化

高阶函数

列子2

返回1

bar(1,loop)    先1进行计算，返回1，方法体没用到loop 不被调用

bar(loop,1)一直循环         先loop进行计算，无法返回

例子

求值策略

match = java 的switch

try

for

if

unit 等于java 中的void

常用数据结构

scala中 函数可以作为变量使用 可以传参 返回值 赋值给变量 存储在数据结构里