Scala學習筆記之二--基本數據類型

前言

本篇主要講Scala的基本數據類型，更多教程請參考： Scala教程

基本數據類型

Scala一共提供了9中數據類型，Scala的基本數據類型與java中的基本數據類型是一一對應的，這是Scala的數據類型全是類，而且頭字母大寫

整數類型變量定義：

//16進制
scala> val x = 0x29
x:Int = 41

//10進制
scala> val x = 41
x:Int = 41

//8進制
scala>051
res0:Int = 41

浮點型變量定義：

//Double類型定義，直接輸入浮點數，編譯器會將其自動推斷爲Double類型
scala> val doubleNumber = 3.1415
doubleNumber:Double = 3.1415

//要定義Float類型浮點數，須要浮點數後面加F或者f
scala> val floatNumber = 3.1415f
floatNumber:Float = 3.1415

//浮點型變量還能夠用指數表示
scala>val floatNumber = 0.1314e1
floatNumber:Double = 1.314

字符變量定義：

//字符定義，用''將字符包裹
scala>var charLiteral='A'
charLiteral:Char='A'

經常使用特殊字符包括

\n換行符，其Unicode編碼爲(\u000A)
\b回退符，其Unicode編碼爲(\u0008)
\t tab製表符，其Unicode編碼爲(\u0009)
\" 雙引號，其Unicode編碼爲(\u0022)
\' 單引號，其Unicode編碼爲(\u0027)
\反斜槓，其Unicode編碼爲(\u005C)

字符串變量定義：

//字符串變量用""包裹
scala> val helloWorld = "HelloWorld"
helloWorld:String = HelloWorld

//要定義"Hello World",須要加上轉義符
scala> val helloWorldDoubleQuote = "\"Hello World\""
helloWorldDoubleQuote:String = "Hello World"

//若是但願可以原樣輸出字符串總的內容，則用三個引號"""將字符包裹
scala>println(""" hello cruel world, \n \\\ \b \\, I an""")
 hello cruel world, \n \\\ \b \\, I an

布爾類型定義：

scala>var x = true
x:Boolean = true

Scala基本類型操做

由於Scala中一切皆對象，這意味着Scala中的一切操做都是對象的方法，包括基本的算術操做

算術操做：

//整數求和
scala> var sumValue = 1+2
sumValue: Int = 3

//等價於下面這句話
scala> var sumValue = (1).+(2)
sumValue:Int = 3

//操做符重載，編譯器將會將其轉換爲(1).+(2L)執行
scala> val longSum = 1 + 2L
longSum: Long = 3

//減法
scala>1-3
res2:Int = -2

//除法
scala>1 / 3
res3:Int = 0

//取餘
scala>1%3
res4:Int = 1

//乘法
scala>1*3L
res5:Long=3

//Scala中能夠用+ -符號表示正負數，而且能夠用來算術運算
scala>var y =1 + -3
y:Int = -2

關係運算：

//>運算符
scala> 3 > -3
res12: Boolean = true
//<運算符
scala> 3 < -3
res13: Boolean = false
//<=運算符
scala> 3 <= -3
res14: Boolean = false
//<=運算符
scala> 3 <=3
res15: Boolean = true
//<=運算符
scala> !(3<= -3)
res16: Boolean = true

邏輯運算

//邏輯與：&&
scala> val bool=true
bool: Boolean = true

scala> bool && bool
res17: Boolean = true
//邏輯或：||
scala> bool || bool
res18: Boolean = true


scala> bool || !bool
res20: Boolean = true

位運算：

// 00000001
// 00000010
// 00000000
scala> 1 & 2
res24: Int = 0

// 00000001
// 00000010
// 00000011
scala> 1 | 2
res24: Int = 3

// 00000001
// 00000011
// 00000010
scala> 1 ^ 3
res24: Int =2

//00000001
//11111110
scala> ~1
res24: Int =-2

//左移位（shift left）
//00000110
//00001100
scala> 6 << 1
res29: Int = 12

//右移位（shift left）
//00000110
//00000011
scala> 6 >> 1
res28: Int = 3

//無符號右移（shift left）
//11111111111111111111111111111111
//00000000000000000000000000000001
scala> -1 >>> 31
res32: Int = 1

對象比較：

scala> 1==1
res34: Boolean = true

scala> 1==1.0
res35: Boolean = true

scala> val x="Hello"
x: String = Hello

scala> val y="Hello"
y: String = Hello

//Scala中的對象比較不一樣於Java中的對象比較
//Scala基於內容比較，而java中比較的是引用，進行內容比較時須定義比較方法
scala> x==y
res36: Boolean = true

Scala程序控制結構

一、if的使用：
Scala的if/else語法結構和Java或C++同樣。不過，在Scala中if/else表達式有值，這個值就是跟在if或者else以後的表達式的值。

val x =  if("hello" == "hell") 1 else 0
x:Int = 0

注意點:
一、Scala的表達式都有類型，好比上面的if/else，類型爲Int,由於if和else分之的類型都是Int
二、假如上面的類型不同，好比： val x = if(x > 0) "positive" else -1 此時這兩個類型就不同了，其中一個分之是Int,而另外一個分之是java.lang.String。此時這個表達式的類型是公共超類型Any。
三、若是else缺失了，好比：if(x > 0) 1 那麼極可能if語句沒有輸出值，可是在Scala中，每一個表達式都有值，此時，Scala提供了一個Unit類，寫做()，上面的語句等價於: if(x > 0) 1 else () 四、賦值語句的值是Unit類型的，因此 x = y = 1 //這樣是錯的

二、while的使用：

def gcbLoop(x:Long, y:Long):Long = {
    var a = x
    var b = y
    while(a != 0){
        val temp = a
        a = b % a
        b = tmep
    }
    b
}

do while的使用

var line = ""
do{
    line = readLine()
    println("Read: "+line)
}while(line != "")

注意點：與if不用的是，while與do while不能做爲表達式，也即其返回值爲Unit

利用if替代while控制結構
//這樣作能夠減小var變量的使用，程序結構也更簡單，表達能力更強
def gcb(x:Long, y:Long):Long = 
if(y == 0) x else gcb(y, x % y)

var line = ""
while((line = readLine()) != "") //在Scala中不能這麼用，由於Scala中的賦值語句操做返回Unit
println("Read: "+line)

for循環的使用:

scala>val filesHere = (new java.io.File(".")).listFiles
//集合操做方式
scala>for(file <- filesHere)
    | println(file)

//簡介調用方式
for(i <- 0 to filesHere.length - 1)
println(filesHere(i))

程序中的<-被稱爲(generator),在執行過程當中，集合filesHere(Array[File])的元素將依次賦給file,file類型爲File，打印將調用其toString()方法將文件名打印出來。
<-生成器對其類型的集合也使用

scala>1 to 5
res10:scala.collection.immutable.Range,Inclusive = Range(1, 2, 3, 4, 5)

scala>for(i<- res10) println("Iteration: "+i)
Iteration: 1
Iteration: 2
Iteration: 3
Iteration: 4
Iteration: 5

//也能夠直接寫成
scala>for(i <- 1 to 5) println("Iteration: " +i)
Iteration: 1
Iteration: 2
Iteration: 3
Iteration: 4
Iteration: 5

//若是不包括5
scala>for(i <- 1 until 5) println("Iteration: "+i)
Iteration: 1
Iteration: 2
Iteration: 3
Iteration: 4

在for循環中還能夠加入if進行過濾操做

val filesHere = (new java.io.File(".")).listFiles
for (file <- filesHere if file.getName.endsWith(".scala"))
println(file)
//還能夠加入多個過濾條件，用;隔開
for (
file <- filesHere
if file.isFile;
if file.getName.endsWith(".scala")
) println(file)

多重循環的實現
可使用多個變量 <- 表達式的形式提供多個生成器，用分號將他們隔開

for(i <- 1 to 3; j <- 1 to 3) print((10 * i +j) + " ")
11 12 13 21 22 23 31 32 33

還可使用if

for(i <- 1 to 3; j <- 1 to 3 if  i!= j) print((10 * i +j) + " ")
12 13 21 23 31 32

可使用任意多的定義，引入能夠再循環中使用

for(i <- 1 to 3; from = 4 - i; j <- from to 3) print((10 * i) +j)
13 22 23 31 32 33

若是循環體以yield開始，則該循環體會構造一個集合，每次迭代生成集合中的一個值

for(i <- 1 to 10) yield i % 3
Vector(1, 2, 0, 1, 2, 0, 1, 2, 0, 1)

這類循環叫作for推導式
for推導式生成的集合與它的第一個生成器是類型兼容的。

def fileLines(file: java.io.File) =
scala.io.Source.fromFile(file).getLines.toList
def grep(pattern: String) =
for (
file <- filesHere
if file.getName.endsWith(".scala");
line <- fileLines(file)
if line.trim.matches(pattern)
) println(file +": "+ line.trim)
grep(".*gcd.*")

//前一個for至關於下列語句
def grep(pattern: String) =
for (
file <- filesHere
if file.getName.endsWith(".scala")
) 
for(
line <- fileLines(file)
if line.trim.matches(pattern)
)
println(file +": "+ line.trim)
grep(".*gcd.*")

生成返回結果

//每次循環將結果保留，當整個循環執行完畢，全部保留的值將會生成一個集合並返回
scala> def scalaFiles =
     | for {
     | file <- filesHere
     | if file.getName.endsWith(".scala")
     | } yield file
scalaFiles: Array[java.io.File]

//Array[File]到Array[Int]的轉換
scala> val forLineLengths =
     | for {
     | file <- filesHere
     | if file.getName.endsWith(".scala")
     | line <- fileLines(file)
     | trimmed = line.trim
     | if trimmed.matches(".*for.*")
     | } yield trimmed.length
forLineLengths: Array[Int] = Array()