Scala

Scala是静态语言，支持类型推导。结合了函数式编程和面向对象的编程。

1. 变量定义有两种，val类似于Java的final变量，一旦初始化了，就不能再赋值；var如同java中的非final变量，可以被多次赋值。

2. Scala的类型标注放在名称之后，用冒号分隔。

3. 函数定义：

def max(x: Int, y: Int): Int = {
    if(x>y) x else y
}

def myPrint(s: String) {println(s)} <=> def myPrint(s: String): Unit = {println(s)}

def max(x: Int, y: Int): Int = if(x>y) x else y

4. 遍历，生成器，for

args.foreach((arg: String) => println(arg))
for(arg<-args) println(arg) //for中arg是val，因为每次for都被重新初始化，在for中没有被修改(不是赋值)
for(arg<-args if arg.length>3; if arg.length<6) println(arg) //带过滤条件的遍历
def evens=for{i <- 1 to 100 if i%2 ==0} yield i

5. 参数化数组(Array)。数组是Scala的可变同类对象序列。List是不可变的

var words = new Array[String](3)
words(0) = "Hello" //Scala 中，数组是类的特例，将()传递给对象，对调用对象的apply方法；当赋值时，则是调用对象的update方法。
words(1) = ", "
words(2) = "world!"
for(w<-words) println(w) // words.foreach(println)

6. List 不可变

val oneTwo = List(1, 2)
val threeFour: List[Int] = List(3, 4)
val oneTwoThreeFour = oneTwo ::: threeFour
val oneThreeFour = 1 :: threeFour // threeFour. ::(1)

6+. 可变参数函数

def print(words: String*){
    words.foreach(println _)  //如果只有一个参数出现在=>右侧，可以省略左侧参数列表和=>，参数用_表示
}

print(Array[String]("Hello", "Hi"):_*) // :_*将数组展开成参数列表

7. 元组，其中元素类型可以不同

val tuple = (99, "Hello")
tuple._1 //不使用tuple(1)，因为元组的每个元素类型都可以不同，但是()要求返回相同的类型。

8. Set 和Map，与List和Array类似，都定义了可变的和不可变的。以Set为例，Set实现了可变和不可变两种特质(Trait，类似于Java的接口)，分别在不同的包里。默认是不可变的Set。可变Set在scala.collection.mutable.Set，不可变Set在scala.collection.immutable.Set

var set1 = Set("Hello", "world")
set1 += "Scala"  // <=> set1 = set1 + Scala 上文中构建的Set是没有变的，只是使用上一个Set和元素"Scala" 进行拼接而返回，然后进行了重新赋值

import scala.collection.mutable.Map
var map1 = new Map[String, Int]()
map1 += ("Hello" -> 1) // Scala把"Hello" -> 1二元操作符转换为("Hello"). -> 1. Scala的任何对象都可以调用->方法，其返回是包含键值对的元组
println(map1("Hello"))

9. 从文件读取数据

import scala.io.Source
for(line <- Source.fromFile(args(0)).getLines) println(line)

10. 单例对象。如果单例对象和类同名，则称为伴生对象，伴生对象(companion object)和伴生类必须定义在同一个文件中。类和其伴生对象可以相互访问私有成员。

object Zoo{ //使用Object而不是Class定义的类
}

11. 类

class Animal(n: String, a: Int){ //主构造器
    require(a > 0)
    val name: String = n
    val age: Int = a
    override def toString(): String = name + age
    def this(name: String) = this(name, 0) //辅助构造器
}

12. case class(样本类)和模式匹配

1)样本类会生成和类名相同的工厂方法(构造对象时省略new关键字);2)构造方法中的变量省略val关键字，可以将参数名当做同名属性；3)生成toString,hashCode等方法。

case class Animal(age: Int)
val animal1 =  new Animal(3)
val animal2 = Animal(4)
animal1 equals animal2    //false

13. expr match {case }类似于haskell中的模板匹配

val defaultValue:Option[Int] => Int = {  
    case  Some(x) => x  
    case None => 0
}
defaultValue(Some(3)) // Int => 3

val second:PartialFunction[List[Int],Int] = {  
    case List(x,y,_*) => y  // <=> case x::y::_ => y
}
second(List(3,4)) // 4

 second 会被编译成如下形式。因此Actor中的receive实际上是通过以上方式定义的偏函数。

new PartialFunction[List[Int], Int] {  
    def apply(xs: List[Int]) = xs match {  
        case x :: y :: _ => y  
    }  
    def isDefinedAt(xs: List[Int]) = xs match {  
        case x :: y :: _ => true  
        case _ => false  
    }  
}  

 下面的函数定义中，case的中括号中的值不是函数原型声明，而是元组类型声明。如果返回的结果是同类型，则函数定义的返回值的该类型，否则将会以Any作为返回值类型。应该是最近公共祖先。_ 的case是默认操作。

def typerF(x: Any, y: Any) = y match { 
    case (s:String, v: Int) => s.length +v
    case s:String => s
    case _ =>
}

typerF(3,("asdf",5)) // Any = 9
typerF(3,"sdfsadf")  // Any = sdfsadf

14. Scala强制类型转换

var s: AnyRef = "Hello"
if(s.isInstanceOf[String]){
    s = s.asInstanceOf[String]
}