2 Scala基本語法

1 變量和函數

變量：

Scala 有兩種變量， val 和 var。

val：常量，相似於 Java 裏的 final 變量。一旦初始化了， val 就不能再賦值了。

va： 如同 Java 裏面的非 final 變量。var在生命週期中能夠被屢次賦值。

下面是一個 val 的定義：

eg:

val x:T val x:T=e

var x:T var x:T=e

函數：定義 def

2 結構控制語句

判斷語句 if：

if(A)

    B

else

    C

eg:

def min(x:Int,y:Int):Int={

    var a=x

if(x>y)

    a=y

return a

}

循環(while/do語句)

while(A) B

或者：

do B while(A)

（先執行一次循環體）

枚舉(for表達式)

For表達式能用任意條件進行各類形式的枚舉：

for(i<- e)

E(i) //表達式

注：發生器遍歷e中的元素，每一次枚舉運行表達式E(i)

e能夠是各類集合，包括數組、列、表達式等，或是有上下界的數值範圍：

1 to 4 （1=<i<=4)

1 until 4 (1=1=<i<=4-1)(不包含上界）

yield關鍵字：

for(i <- e)

yeild E(i)  //用於賦值，即把每一次枚舉的值記錄在集合中

若E(i)由花括號括起，yield必須在花括號外，即：

for(i <- e)

yeild {E(i)}

匹配(match表達式)

相似於switch：

a match{

case e1=> E1

case e2=> E2

....    ....

case_=>...

}

若a匹配e1則執行E1，若a匹配e2，則執行E2 ，以此類推

在case後接_表明任意，

match表達式能夠直接賦值：

eg:

val sign=a match{

case e1=> 123;

case e2=>"123";

}

異常處理(throw/try)

try{函數體}

catch{

case....;

case....;

}

finally{

    A.close()

}

輸出(print/println)

print(A)/println(A):A能夠是值或者表達式，當A是表達式時，則輸出表達式的值

println 輸出時自動換行

輸入(readLine)

輸入一般使用read函數，readLine是從控制檯讀取一行輸入，指定類型時爲readT，T是所指定的類型，如

val age=readInt()

在控制檯輸入：zhangsan

其餘語句

return 語句表示返回某個值，可是Scala事實上無須使用return語句

聲明函數時使用return語句，必須聲明返回值的類型，如def abd():T={return}

break/continue在C++中很是常見的控制結構語句，但在Scala中是沒必要要的，能夠

使用布爾值類型的量經過IF語句進行控制

3 數組

定長數組聲明：

val A=new Array[T](N)   eg  val A=new Array[Int](10)

數組成員默認初始化：Int初始化爲0，String默認初始化爲Null

也能夠新建數組時給出值：

val B=Array(N1,N2)

數組初始化後能賦值：或是對指定的數組成員賦值：

val G=B+Array(1,2)   val G=B-Array(1,2)

變長數組：

import scala.collection.mutable.ArrayBuffer

val C=new ArrayBuffer[T]() //聲明一個空數組，此時C是一個全空數組，數組元素爲0

變長數組操做：

在數組尾部加一個類型爲T的元素e1，e二、e3：

C+=e1

C+=(e2,e3)

在數組尾部增長數組Array(e2,e3)

C++=Array(e2,e3)

移除最後一個元素

C.timEnd(1)

在第二個元素後插入e3：

C.insert(2,e3)

在第二個元素後插入e2,e3,e4：

C.insert(2,e2,e3,e4)

移除第3個元素後的一個元素：

C.remove(3)

移除第3個元素後的2個元素：

C.remove(3,2)

D=C.toArray  //把變長數組轉爲定長數組D

E=A.toBuffer // 把定長數組轉爲變長數組

數組遍歷：

for(i < - C) println(i)  直接遍歷數組的成員

for(i < - 0 to （ C.length-1） )println(C(i)) 經過遍歷數組的下標得到成員  遍歷數組C中的全部成員並輸出

額外的，有

for(i < - 0 to (C.length,2) ) println(C(i))  每兩個元素一條進行遍歷

for(i < - (0 to C.length).reverse) println(C(i))   倒序遍歷

同過for語句枚舉數組成員，能夠實現多種數組控制，如把數組成員各加1並生成新數

組： val NEW=for(i < - C) yield i+1 這種數組生成是對應原數組類型的(定長/變長)

4 映射

    數組時包含一組元素的集合，映射是包含一組鍵值對應元素的集合

    不可變映射：

        val Z=Map(a1 -> b1,a2->b2,a3->b3)

        val Z=Map((a1,b1),(a2,b2),(a3,b3))

        注：an  與bn 的類型能夠不一致，an是鍵，bn是值，an互不相同，bn能夠相同

    

    獲取映射對應鍵的值：

    val a=Z(an）或val b=Z.get(an)

        當映射中不含對應的鍵時拋出異常，

        能夠利用contains方法檢查映射中是否含有某個鍵

    val c=Z.contains(an)  //返回布爾值

    

        組合調用：

        val d=Z.getOrElse(an,0)

    可變映射

        val Y=scala.collection.mutable.Map((a1,b1),(a2,b2),(a3,b3))

        val X=new scala.collection.mutable.Map[T1,T2]

    

    

    可變長映射的鍵值操做跟變長數組相似：

    Y(an)=bn  //有這個值則更新，無則新建對應的值

    Y+=(a4->b4,a5->b5)  //增長鍵值對

    Y-=(a4)    //刪除鍵值對

 

    對於不可變映射能夠經過構造新的映射來增刪其鍵值

    val W=Z+(a4->b4,a5->b5)   //新建了新的映射

    val V=W- (a4->b4,a5->b5)

    映射枚舉：

        for((i,j)<-Z)

            E(i,j)

        

    互換映射的鍵值：

        for((i,j)<-Z)

            yield(j,i)

    

    獲取映射內鍵的集合或值的集合：

        val e=Z.keySet

        val f=Z.values

    

 

5 元組

    若干個單個的值包含在圓括號便構成元組

    val g=(1 , 1.2，‘A’) //(Int,Double,Char)類型的元組

    利用方法_一、 _二、 _3訪問元組的組元

    val h=g._1 或 val h=g _1

    

    

    元組把多個值捆綁在一塊兒，使他們能同時被處理

    zip方法：

     zip方法能把幾個集合結合起來

val one=Array(‘a’，‘b’，‘c’ )

val two=Array（ 1， 2， 3）

val three=one.zip(two） 或 val three=one zip two  // 對應的就生成一個元素是二元的數組

val four=one.zip(two).toMap 或 val four = one zip two toMap  // 對應的生成一個以數組one爲鍵，數組two爲值的映射

6 包的引用

  Scala經過不一樣的包能使用不少類型的表達式，而包的引入在Scala中至關靈活

 包是用來管理名稱的，包括該名稱的聲明、定義等
 能給已有的包增長名稱，或者建立新的包
 包是能互相嵌套的如： scala.collection.mutable的結構以下
 package scala { package collection { package mutable {……} } }
 包聲明鏈scala.collection.mutable並不使scala與scala.collection可見
 包聲明鏈亦不對包含的包進行聲明
 即聲明scala.collection並不意味着聲明scala.collection.mutable

 

{……}號之間聲明的量只有在{}內是有意義的
 {val a=0... {...val b=a}...} 內層能調用外層聲明的量
{val a=b...{val b=0...}...} 外層不能調用內層聲明的量
 內層聲明與外層聲明相同時，內層使用的是內層的聲明，外層使用的是外層的聲明
 如： val x=2 for（ i < - 1 to 4） print(x+i)
 val x=2 for(x < - 1 to 4) print(x+x)

 {val a=0... {...val b=a}...} 內層能調用外層聲明的量
{val a=b...{val b=0...}...} 外層不能調用內層聲明的量
 內層聲明與外層聲明相同時，內層使用的是內層的聲明，外層使用的是外層的聲明
 如： val x=2 for（ i < - 1 to 4） print(x+i)
 val x=2 for(x < - 1 to 4) print(x+x)

{val a=b...{val b=0...}...} 外層不能調用內層聲明的量
 內層聲明與外層聲明相同時，內層使用的是內層的聲明，外層使用的是外層的聲明
 如： val x=2 for（ i < - 1 to 4） print(x+i)
 val x=2 for(x < - 1 to 4) print(x+x)

 內層聲明與外層聲明相同時，內層使用的是內層的聲明，外層使用的是外層的聲明
 如： val x=2 for（ i < - 1 to 4） print(x+i)
 val x=2 for(x < - 1 to 4) print(x+x)

 如： val x=2 for（ i < - 1 to 4） print(x+i)
 val x=2 for(x < - 1 to 4) print(x+x)

 val x=2 for(x < - 1 to 4) print(x+x)

 

 

 

 

 

 

來自爲知筆記(Wiz)

附件列表

• 6ba7d4a6-8650-4708-b0da-41f63665ae25.png