= 和=>
- 函数类型推断
此时没有写返回值,但是有等号,函数会自己推断返回值,此时的返回值是Int
def add(x:Int, y:Int) = {
x+y
}此时没有写返回值,也没有等号,无论函数内部有没有返回值,返回值都是Unit
def add(x:Int, y:Int){
x+y
}- 如果函数仅包含一条语句，那么连花括号都可以选择不写
def add(x:Int, y:Int) = x+y =>在匿名函数中，用于分隔入参和函数体， 例如：val f = (x: Int) => x + 1
小括号和花括号
- 当方法的参数只有一个时，两个是等价的。例如
List(10)等价于List{10} - 花括号可以完成部分数据的初始化
例如：
val l = List {
val x = 10
x + 20
}
可变长参数
def echo(args: String*)
Lazy
lazy val property = initProperty() lazy关键字修饰变量后，只有在使用该变量时，才会调用其实例化方法。在实例化时，还会加锁，多线程安全。
Implict
参考：
http://blog.csdn.net/jameshadoop/article/details/52337949
泛型
override def apply[A](xs: A*): List[A] = xs.toList
class List[+A]
def ::[B >: A] (x: B): List[B] =
new scala.collection.immutable.::(x, this)
Partial Functions(偏函数)
- 只接受和处理其参数定义域范围内的子集，对于这个参数范围外的参数则抛出异常的函数
例如：PartialFunction[A,B],其中接收一个类型为A的参数，返回一个类型为B的结果
* def isDefinedAt(x: A): Boolean 判断传入来的参数是否在这个偏函数所处理的范围内
完整偏函数例子
val divide = new PartialFunction[Int,Int] {
def isDefinedAt(x: Int): Boolean = x != 0 //判断x是否等于0，当x = 0时抛出异常
def apply(x: Int): Int = 100/x
} 结合case语句
val divide1 : PartialFunction[Int,Int] = {
case d : Int if d != 0 => 100/d //功能和上面的代码一样，这就是偏函数的强大之处，方便，简洁！！
} 多个case使用
val rs : PartialFunction[Int , String] = {
case 1 => "One"
case 2 => "Two"
case _ => "Other"
}如果使用匿名函数，还可以使用case 语句中输入的变量类型来进行数据过滤
List(1, 3, 5, "seven") collect { case i: Int => i + 1 }List 的map 和 collect
def map[B](f: (A) ⇒ B): List[B] : 接收的是一个函数类型的参数
def collect[B](pf: PartialFunction[A, B]): List[B] 接收的是一个偏函数（partial function）类型的参数
- Case 语句声明的变量就是偏函数的参数，case语句只接受一个参数，则偏函数的类型声明自然就只有一个参数
Apply
对于函数来说该方法意味着调用function本身
例如：
val f = (x: Int) => x + 1
我们可以通过调用函数 f 的apply方法来调用函数本身，即f.apply(3)，scala提供更简单的调用方式f(3)作为工厂方法
对于Object 对象来说，我们可以显示调用apply方法，例如List.apply(1,2,3),等价于List(1,2,3)，如果方法只有一个参数，等价于使用花括号List {1}
Future
- 使用前导入类
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global使用示例：
Future {
...
}在执行Future.apply{异步代码块}时，主线程将异步代码块交给新的线程，新起的线程负责异步代码块的计算，而主线程则解放出来，执行下一步。