隨機數

import java.util.Random
val rand = new Random()
val x = rand.nextInt()

scala 數學包

import scala.math._
sqrt(2)
pow(2,4)
min(2,4)

沒有引數且不改變當前物件的方法不帶圓括號
"hello".distinct

使用伴生物件的apply方法來構建物件（常用）,不需要new關鍵字
BigInt("123456")
條件表示式有值
val s = if(x>0) 1 else -1
如果語句很長要換行儘量用“操作符”作為第一行的結尾，
val s = s0 + (v1-v0) +
0.5*(v3-v2)

塊中最後一個表示式的值就是塊的值
{ exp1
exp2
}
迴圈
for( i <- 1 to 10)
for( i <- 1 until 10)
沒有break，需通過布林表示式或函式返回

函式

方法對物件進行操作，函式不是
def abs(x: Double) = if(x >= 0) x else -x
遞迴函式必須指出返回值型別
def fac(x:Int):Int = if( x<=0 ) 1 else x*fac(x-1)
過程
有花括號，但是沒有前面的等號，其返回值是Unit型別，這樣的函式叫過程
異常
try{}catch{}finally{}

陣列

定長陣列

val nums = new Array[Int](10)
val s =new Array[String](10)
val s2 = Array("hi","hello")
s(0) = "apple" //通過()來訪問元素

變長陣列

import scala.collection.mutable.ArrayBuffer
val b = ArrayBuffer[Int]()//空的陣列緩衝
b += 1
b += (5,6)
b ++= Array(2,3,4)
val a = b.toArray//ArrayBuffer轉Array
c = a.toBuffer//Array轉ArrayBuffer
 

遍歷陣列

0 until a.length
0 until (a.length,2)//每兩個取一個
for(elem <- a){yield elem*2}

常用操作

import scala.util.Sorting.quickSort
a.filter(_%2==0).map(2*_)
a.sum
a.max
a.min
a.sortWith(_<_)
quickSort(a)//直接改變原陣列

對映和元組

Map

import scala.collection.mutable
//不可變map
val scores = Map("Alice"->3,"Bob"->4)
//或者scores = Map(("A",1),("B",2))
val tmp = scores("Alice")//獲取值
//判斷key是否存在
scores.contains("Alice")//true
scores.contains("d")//false
//獲取value更普遍的用法
val tmp = scores.getOrElse("Alice",0)

//可變map
val scores = mutable.Map("Alice"->3,"Bob"->4)
scores("Cindy") = 5//新增鍵值
scores += (("Lemon",3),("Honey",8))//新增多個
scores += ("oo"->3,"mm"->8)//新增多個
scores -= "Alice"//刪除key
//新建空的map
val scores = new mutable.HashMap[String,Int]

//遍歷Map
for((k,v)<-scores) println(v)
for(v<-scores.values) println(v)//values方法返回一個Iterable
//調換k,v
for((k,v)<-scores) yield(v,k)

//已排序對映，按key升序排
val scores = scala.collection.immutable.SortedMap("Alice"->10,"Bob"->2)
//按插入順序訪問的對映
val scores = scala.collection.mutable.LinkedHashMap("Jan"->1,"Feb"->2,"Mar"->3)

元組

val t = (1,'A',"Apple")
//訪問元素
val tmp = t._2//元組的下標從1開始
//模式匹配
val (a,b,c) = t

zip操作

val a = Array('a','b','c')
val b = Array(1,2,3)
val c = a.zip(b)//c: Array[(Char, Int)] = Array((a,1), (b,2), (c,3))
//toMap方法將對偶集合轉為對映
val d = c.toMap//d:scala.collection.immutable.Map[Int,Char] = Map(1 -> a, 2 -> b, 3 -> c)

類

pulic是scala的預設訪問級別
scala原始檔可以包含很多個類，這些類都具有公共可見性
呼叫改值器(改變物件狀態)方法，加()，如myCounter.increment()
呼叫取值器(不改變物件狀態)方法，不加()，如myCounter.current

getter和setter方法

scala為每個欄位都提供了getter和setter方法
scala中getter和setter分別叫做age,age_

class Person{
    var age = 0
}
var fred = new Person
println(fred.age)//getter
fred.age = 20//setter

如果欄位是私有的，則getter和setter方法也是私有的
如果欄位值val，那麼只有getter方法被生成，這是一個只讀屬性

自定義getter和setter方法

class Person{
    private var privateAge=0
    def age = privateAge
    def age_ = (newValue:Int){ 
        if(newValue>privateAge) 
            privateAge = newValue
    }

var foo: scala自動生成getter和setter方法
val foo:scala自動生成getter方法
可以自己定義getter和setter方法

@BeanProperty

import scala.beans.BeanProperty
class Person{
    @BeanProperty var name:String = _
}
val p = new Person
p.setName("hi")
println(p.getName)

使用BeanProperty屬性後，會為欄位自動生成以下四種方法：

name
name_
getName
setName

輔助構造器

輔助構造器名稱為this
每個輔助構造器都必須以一個先前定義的輔助構造器或主構造器的呼叫開始

class Person{
    @BeanProperty var name:String = _
    var age:Int = 0
    def this(name:String){
        this()//主構造器
        this.name = name
    }
    def this(name:String,age:Int){
        this(name)//前一個輔助構造器
        this.age = age
    }
}
val p = new Person//主構造器
val p1 = new Person("le")//第一個輔助構造器
val p2 = new Person("le",10)//第二個輔助構造器

主構造器
沒有顯示定義主構造器的自動擁有一個無引數的主構造器
主構造器的引數直接放在類名之後

class MyPerson(val name:String,val age:Int){

}
object Demo{
    def main(args:Array[String]):Unit={
        val p = new MyPerson("hi",2)
        println(p.name)
        println(p.age)
    }
}

物件-object

單例物件

定義了某個類的單個例項
物件的構造器在物件第一次被使用時呼叫
物件的構造器不能有引數

object Accounts{
    private var lastNumber = 0
    def newUniqueNumber() = {lastNumber+=1;lastNumber}
}
object Demo{
    def main(args:Array[String]):Unit={
        println(Accounts.newUniqueNumber)//Accounts的構造器在Accounts.newUniqueNumber首次呼叫時執行
    }
}

伴生物件

在java中既有例項又有靜態方法的類在scala中可以通過類和與類同名的伴生物件來達到同樣目的。

類和伴生物件必須在同一個原始檔中
類和伴生物件可以相互訪問其私有屬性

class Account{
    val id = Account.newUniqueNumber()
    private var balance = 0.0
    def deposit(amount:Double){balance+=amount}
}
object Account{
    private var lastNumber = 0
    def newUniqueNumber() = {lastNumber+=1;lastNumber}
}

apply方法
呼叫形式：object(引數1,引數2,...)
例如：Array(1,2,4)
這樣就可以省去new關鍵字

apply方法返回的是伴生類的物件

class Account private(val id:Int,initialBalance:Double){
    private var balance = initialBalance
    def deposit(amount:Double){balance+=amount}
}
object Account{
    private var lastNumber = 1
    def newUniqueNumber() = {lastNumber+=1;lastNumber}
    def apply(initialBalance:Double)={
        new Account(newUniqueNumber(),initialBalance)
    }
}
object Demo{
    def main(args:Array[String]):Unit={
        val acct = Account(1000.0)//apply方法
    }
}

scala project必須從一個物件的main方法開始

object Demo{
    def main(args:Array[String]):Unit={//引數args:Array[String]，返回值Unit
        ...
    }
}

包和引入

串聯式包語句
package com.horstman.impatient
在這裡com，com.horstman是不可見的
檔案頂部標記法

package com.horstman.impatient
package people
class Person
    ...

相當於

package com.horstman.impatient{
    package people{
        class Person
            ...
    }
}

包物件
包裡面可以包含class,object,trait，但是不能包含函式或者變數的定義。包物件就可以解決這個問題。

包物件裡面可以定義一些工具函式和常量
包物件在父包中定義，與子包的名字相同
包物件被編譯為帶有靜態方法和欄位的JVM類

package com.horstman.impatient
package object people{
    val defaultName = "hello"
}
package people{
    class Person{
        var name = defaultName
    }
}

引入
import scala.collection.mutable._
“_”是萬用字元，相當於java中的”*”，表示引入包/類/物件的所有成員
選取器

import java.awt.{Color,Font}
import java.util.{HashMap => JavaHashMap}//重新命名
import java.util.{HashMap -> _, _}//隱藏HashMap

繼承

擴充套件類 extends

class Employee extends Person{
    var salary = 0.0
    ...
}

重寫 override
重寫一個非抽象方法必須用override關鍵字

class Employee extends Person{
    override def toString = ...
}

呼叫超類的方法用super關鍵字
override def toString = super.toString ...

型別檢查及轉換
isInstanceOf
asInstanceOf

if(p.isInstanceOf[Employee]{
    val s = p.asInstanceOf[Employee]
}

想確定p指向的是Employee物件而且不是其子類
if(p.getClass==classof[Employee]
更推薦模式匹配的方法

p match{
    case s: Employee=>...//
    case _: ...//不是Employee
}