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

val addOne = curriedAdd(1)_
addOne(2)

在Scala里面，函数是第一等公民。

随堂笔记--

val result_try = try {
    Integer.parseInt("dog")
    } catch {
        case _ => 0
    } finally {
        println("always be printed")
    }
    
val code = 1
val result_match = code match {
    case 1 => "one"
    case 2 => "two"
    case _ => "others"
}

object worksheet{
    val l = List("aaaa", "bbb", "cccc")
    
    for (
        s <- l
        ) println(s)
        
    for {
        s <- l 
        if (s.length > 3)
        } println(s)
        
    val result_for = for {
        s <- l
        s1 = s.toUpperCase()
        if (s1 != "")
        } yield(s1)
}

object func_examples {
    def hello(name:String): String={
        s"Hello, ${name}"
    }
    
    hello("xx")
    
    def hello2(name:String) = {
        s"Hello, ${name}"
    }
    
    hello2("yy")
    
    def add(x:Int, y:Int) = x+y
    
    add(1,2)
}
//随堂笔记

map 参数 指的是对每个元素, 执行, 并又返回值

Scala中的String跟Java中的相同。

新增了字符串插值interpolation的特性。

对于一个函数，如果返回值是Nothing，那么就是有异常出现。

Any是Scala所有类的父类。

Any下有两个子类，一个是AnyVal，另一个是AnyRef。

Unit相当于Java中的void，往往作为函数的返回类型。

所有引用的java类型都是AnyRef的子类，所有自定义的scala类也都是AnyRef的子类。

Null是引用类型的最后一个子类，Nothing是所有类型的最后一个子类

scala爸爸

三种变量修饰符:

1. val 定义immutable variable （定义常量）

   被val定义的变量的值不能更改

2. var 定义mutable variable（变量）

3. lazy val
   

lazy val 定义的变量不会第一时间赋值 ，求值，会在他第一次被用到的时候进行赋值或者求值。通常用于程序中不一定用到的变量。

scala是构建于JVM之上的，可以跟Java进行互操作。

也就是说可以直接调用java包，或者在java中调用scala程序。

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)  减去多个值

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     第一个值后面的所有值