Scala語法介紹

時間 2019-11-13

標籤 scala 語法介紹欄目 Scala 简体版

原文原文鏈接

Scala語法介紹

一、語法規則

1.會將方法體的最後一行代碼，看成返回值返回。java

2.scala每行後面不須要加「;」，數組

3.若是一行中須要多條語句，則須要用「;」隔開。安全

4.若是scala的方法體只有一行代碼，則方法體能夠省略。多線程

5.若是scala調用的方法只有一個參數，則.()能夠省略。併發

6.若是函數的方法體只有一行代碼，則方法體{}能夠省略。函數

7.若是函數的參數類型能夠被推斷出來，則類型能夠省略。高併發

8.若是函數的參數列表只有一個參數，則參數的括號能夠省略。spa

二、聲明標識符

1．變量

var：用來聲明一個變量，變量聲明後，在程序執行過程當中能夠被修改。.net

示例：線程

  def main(args: Array[String]): Unit = {
    //三種變量賦值方式
    var var1 = 100;
    var var2: Int = 100;
    var var3: java.lang.String = "hello";
    //變量修改
    var2 = 200;
    var3 = "world";
  }

注：scala能夠自動根據值的類型推斷變量/常量的類型，因此不寫類型聲明也能夠。

2．常量

val：用來聲明一個常量，一旦被賦值就不能再進行修改。

注：java中變量使用較多，但在scala裏，常量使用較多，由於在線程併發時能夠減小甚至杜絕多線程併發安全問題，因此scala特別適合於應用在處理高併發場景。

//聲明常量
val v2=200

3．懶值 Lazy

當val被聲明爲lazy時，它的初始化將被推遲，直到咱們首次對它取值。懶值對於開銷較大的初始化語句而言十分有用。

lazy只能用於常量（val），不能用於變量（var）。

正常狀況下經過val和var定義的量都會直接分配空間，即便這個量要在好久之後才使用，這樣就會形成內存空間白白被佔用。

這種狀況下能夠加上lazy關鍵字，延後變量/常量賦值的位置。這樣直到後續真正用到這個量時才真正開闢空間賦值，減小了內存的浪費。

val name = "zhang"//直接分配空間 即便一時半會用不到
lazy val name = "zhang"//並不會當即分配空間 直到後續用到了纔會分配

示例：

lazy val v2=100
//> v2: => Int
println(v2)
//> 100

三、數據類型

1．類型

Scala的數據類型有如下9種：

Byte、Short、Int、Long、Char、String、Float、Double、Boolean。

1>說明

其中String處於java.lang包，其餘的則處在scala包下。

因爲scala會自動導入java.lang和scala包因此這些類型能夠在程序中直接使用。

其實能夠認爲scala中並無真正意義上的基本類型(如java中的基本類型)，以上的九種基本類型其實也出在包下是一個類。

在scala中以上基本數據類型區別於其餘類的地方在於，他們的對象都已直接量的形式體現。

以上基本數據類型的直接量和java中基本徹底相同，再也不復述。

這九個類的直接量在須要時能夠自動被轉換爲其對應的富包裝類來調用，富包裝類提供的額外方法。

每種數據類型都提供了不少方法供調用，因此scala的數據類型不一樣於java的基本類型。

scala.runtime.RichByte

scala.runtime.RichShort

scala.runtime.RichInt

scala.runtime.RichLong

scala.runtime.RichChar

scala.runtime.RichString

scala.runtime.RichFloat

scala.runtime.RichDouble

scala.runtime.RichBoolean

2．字符串操做

事實上Scala的String類就是Java的String類，因此能夠直接調用Java裏String的全部方法。

因爲Scala提供了隱式轉換的方法，String類也擁有StringOps類中全部方法的訪問權限，因此能夠用這些方法作許多事情

示例：

val v3="hello"
//針對字符串作了repeat操做
v3.*(2)
v3.split("l")
//去重
v3.distinct
//去除頭n個元素
v3.drop(1)
//去除尾部n個元素
v3.dropRight(2)
//提取頭n個元素
v3.take(1)
//提取尾部n個元素
v3.takeRight(2)
//filter 根據指定的原則作過濾，其餘類型都適用
v3.filter{x=>x!='l'}
v3.contains("l")
v3.exists { x => x=='l' }
//返回頭1個元素。至關於take（1）
v3.head
v3.last
//以指定字符分割
v3.mkString(",")
//反轉
v3.reverse

3．三引號

Scala中存在一個特殊的符號——三引號，在三引號中的字符都是普通字符，不須要轉義。

當你在不肯定這個字符是否須要轉義的時候，均可以使用三引號來標註，這樣就能夠省去轉義的麻煩。

val v14="hello\t1711"
//> v14  : String = hello 1711
//三引號的使用：三引號中沒有轉義都是普通字符
val v15="""hello\t1711"""
//> v15  : String = hello\t1711

4．大數操做

針對大數的操做，Scala專門提供了一個BigInt對象。

val v3:BigInt=2
//> v3  : BigInt = 2
v3.pow(10)
//> res10: scala.math.BigInt = 1024

四、操做符

scala中操做符即方法，方法即操做符。

scala中的操做符實際上是普通方法調用的另外一種表現形式。對以上基本的運算符的使用其實就是隱含的在調用對應的方法。因此，能夠認爲scala中並無傳統意義上的操做符，全部的操做符都是方法，全部的方法也均可以像操做符同樣去使用。

scala在作運算時，若是以方法形式調用，則以方法順序來執行。若是以操做符的形式來調用，則以操做符優先級的順序調用，優先級同Java。

1．類型

算數運算：+、-、*、/。

關係運算：>、<、>=、<=。

邏輯運算：&&、||、!。

位運算：>>、>>>、<<、~、&、|、^。

比較運算：==、!=。

示例：

val v4=2.+(3).*(5)
//> v4  : Int = 25
val v5=2+3*5
//> v5  : Int = 17

2．優先級

scala中，符號優先級從高到底：（*、/、%）、（+、-）、:、=!、（<、>）、&、^、|。

3．前綴操做符

前綴操做符一共有4種，分別是：+（正）、-（負）、!（非）、~（反）。

1>使用方法

①直接使用

在須要是用前綴操做符的直接量前面加(空格)(符號)便可。

示例：

//使用時須要前面加空格
val v6= -2
//> v6  : Int = -2
val v7= +2
//> v7  : Int = 2
val v8= !false
//> v8  : Boolean = true
val v9= ~0XFF
//> v9  : Int = -256

②調用方法

爲了不產生歧義，能夠經過unary方法來使用。

示例：

//爲了不歧義能夠經過如下形式來使用
val v10=2.unary_-
//> v10  : Int = -2
val v11=2.unary_+
//> v11  : Int = 2
val v12=false.unary_!
//> v12  : Boolean = true
val v13=0XFF.unary_~
//> v13  : Int = -256

五、條件判斷

1．if else

if……else 判斷

if是具備返回值的，if判斷後，將執行代碼的最後一個表達式的值返回做爲整個if執行後的結果。

示例：

val a=5
//> a  : Int = 5
if(a>5){
  //println("big")
  "big"
}else{
  //println("small")
  "small"
}
//> res0: String = small
if(a>5)
  "big"
else
  "small"
//> res1: String = small
  val r2=if(a>5)"big"else"small"
//> r2  : String = small

2．match

scala中的match相似於其餘語言的switch。

match case語句是有返回值。

示例：

  val v1="bbb"
  v1 match{
   case "aaa"=>{println("1")}
   case "bbb"=>{println("2")}
   case _=>{println("3")}
  }
  val result=v1 match{
   case "aaa"=>{println("1");"1"}
   case "bbb"=>{println("2");"2"}
   case _=>{println("3");"3"}
  }

六、循環語句

1．while

和java中用法相同，while沒法控制返回值，或者說返回值是Unit，寫成()，在scala中while比較少使用。

示例：

val a1=Array(1,2,3,4,5)
var index=0
while(index<a1.length){
  println(a1(index))
  index+=1
}

2．for

scala中的for要比java的for強大，使用很頻繁，須要熟練掌握。

for同while同樣，沒法控制返回值，或者說返回值是Unit，寫成()。可是for()能夠和yield{}配合使用，將for()每次循環結果存到一個Vector()中。

示例：

for(i<-a1){
		println(i)
	}
	for(i<-a1)println(i)
	1.to(5)
	for(i<-1.to(5)){
		println(i)
	}
	for(i<-1.to(5))println(i)
	1 to 5
	for(i<-1 to 5)println(i)
	for(i<-1 to 5 by 2)println(i)
//scala的for循環裏能夠寫條件判斷語句
	for(i<-1 to 5;if i>3)println(i)
	//多個條件之間用;隔開
	for(i<-1 to 5;if i>3;if i%2==0)println(i)
	//打印99乘法表
	for(i<-1 to 9){
		for(j<-1 to i)print(i+"*"+j+"="+i*j+"\t")
		println()
	}
	for(a<-1 to 9;b<-1 to a;val s=if(b==a)"\r\n"else"\t")print(b+"*"+a+"="+a*b+s)
	//s函數搭配$能夠實現拼接打印的效果
	for(a<-1 to 9;b<-1 to a;val s=if(b==a)"\r\n"else"\t")print(s"$b*$a=${b*a}$s")
//for yield能夠返回一個新的集合
//scala的集合類型涵蓋數組、鏈表、set、Map、Range、Tuple等
//for yield for循環遍歷的是什麼類型，返回的就是什麼類型
	val a2=for(i<-a1)yield{i*2}	
	val l1=List(1,2,3)
	val l2=for(i<-l1)yield{i+1}	
	val m1=Map("k1"->1,"k2"->2)
	for(i<-m1)println(i)
	for((k,v)<-m1)println(v)
	for((m,n)<-m1)println(m)
	for((k,v)<-m1)println(s"$k:$v")
	for(i<-Array(1,2,3))yield i*2
	Array(1,2,3).map(_*2)	val nums=List(1,2,3,4).filter(_<4)

3．跳出循環

scala中沒有break和continue語句，須要經過另外的形式來實現。想要使用break，須要先導包。

import util.control.Breaks._

示例：

import util.control.Breaks._

  //實現break效果，須要將for循環體寫到breakable()裏
  breakable(
	for(i<-1 to 10){
		if(i>8)break
		println(i)
	}
  )
  //實現continue
  for(i<-1 to 10){
  	breakable(
  		if(i==8)break
  		else println(i)
  	)
}

七、異常

1．try catch finally

scala中繼承了java的異常機制。

示例：

try{
		throw new RuntimeException("error")
	}catch{
		case t: NullPointerException =>{t.printStackTrace();println("null")}
		case t: Exception=>{t.printStackTrace();println("other")}
	}finally{
		println("end")
	}

上一篇：Scala簡介和安裝

下一篇：Scala的函數