Scala入门学习笔记二-基本数据类型、程序控制结构

前言

本篇主要讲Scala的基本数据类型，更多教程请参考：Scala教程

基本知识点概括

• 9种基本数据类型的讲解
• 程序控制语句if、while、for的使用

基本数据类型

Scala一共提供了9中数据类型，Scala的基本数据类型与java中的基本数据类型是一一对应的，这是Scala的数据类型全是类，并且头字母大写

类型.jpg)
整数类型变量定义：

//16进制scala> val x = 0x29x:Int = 41//10进制scala> val x = 41x:Int = 41//8进制scala>051res0:Int = 41

浮点型变量定义：

//Double类型定义，直接输入浮点数，编译器会将其自动推断为Double类型scala> val doubleNumber = 3.1415doubleNumber:Double = 3.1415//要定义Float类型浮点数，需要浮点数后面加F或者fscala> val floatNumber = 3.1415ffloatNumber:Float = 3.1415//浮点型变量还可以用指数表示scala>val floatNumber = 0.1314e1floatNumber: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 = truex:Boolean = true

##Scala基本类型操作因为Scala中一切皆对象，这意味着Scala中的一切操作都是对象的方法，包括基本的算术操作 算术操作：

//整数求和scala> var sumValue = 1+2sumValue: Int = 3//等价于下面这句话scala> var sumValue = (1).+(2)sumValue:Int = 3//操作符重载，编译器将会将其转换为(1).+(2L)执行scala> val longSum = 1 + 2LlongSum: Long = 3//减法scala>1-3res2:Int = -2//除法scala>1 / 3res3:Int = 0//取余scala>1%3res4:Int = 1//乘法scala>1*3Lres5:Long=3//Scala中可以用+ -符号表示正负数，并且可以用来算术运算scala>var y =1 + -3y:Int = -2

关系运算：

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

逻辑运算

//逻辑与：&&scala> val bool=truebool: Boolean = truescala> bool && boolres17: Boolean = true//逻辑或：||scala> bool || boolres18: Boolean = truescala> bool || !boolres20: Boolean = true

位运算：

// 00000001// 00000010// 00000000scala> 1 & 2res24: Int = 0// 00000001// 00000010// 00000011scala> 1 | 2res24: Int = 3// 00000001// 00000011// 00000010scala> 1 ^ 3res24: Int =2//00000001//11111110scala> ~1res24: Int =-2//左移位（shift left）//00000110//00001100scala> 6 << 1res29: Int = 12//右移位（shift left）//00000110//00000011scala> 6 >> 1res28: Int = 3//无符号右移（shift left）//11111111111111111111111111111111//00000000000000000000000000000001scala> -1 >>> 31res32: Int = 1

对象比较：

scala> 1==1res34: Boolean = truescala> 1==1.0res35: Boolean = truescala> val x="Hello"x: String = Helloscala> val y="Hello"y: String = Hello//Scala中的对象比较不同于Java中的对象比较//Scala基于内容比较，而java中比较的是引用，进行内容比较时须定义比较方法scala> x==yres36: Boolean = true

##Scala程序控制结构1、if的使用：Scala的if/else语法结构和Java或C++一样。不过，在Scala中if/else表达式有值，这个值就是跟在if或者else之后的表达式的值。

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

注意点: 1、Scala的表达式都有类型，比如上面的if/else，类型为Int,因为if和else分之的类型都是Int2、假如上面的类型不一样，比如： val x = if(x > 0) “positive” else -1 此时这两个类型就不一样了，其中一个分之是Int,而另一个分之是java.lang.String。此时这个表达式的类型是公共超类型Any。3、如果else缺失了，比如：if(x > 0) 1 那么很可能if语句没有输出值，但是在Scala中，每个表达式都有值，此时，Scala提供了一个Unit类，写作()，上面的语句等价于: if(x > 0) 1 else ()4、赋值语句的值是Unit类型的，所以 x = y = 1 //这样是错的

2、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中的赋值语句操作返回Unitprintln("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 5res10:scala.collection.immutable.Range,Inclusive = Range(1, 2, 3, 4, 5)scala>for(i<- res10) println("Iteration: "+i)Iteration: 1Iteration: 2Iteration: 3Iteration: 4Iteration: 5//也可以直接写成scala>for(i <- 1 to 5) println("Iteration: " +i)Iteration: 1Iteration: 2Iteration: 3Iteration: 4Iteration: 5//如果不包括5scala>for(i <- 1 until 5) println("Iteration: "+i)Iteration: 1Iteration: 2Iteration: 3Iteration: 4

在for循环中还可以加入if进行过滤操作

val filesHere = (new java.io.File(".")).listFilesfor (file <- filesHere if file.getName.endsWith(".scala"))println(file)//还可以加入多个过滤条件，用;隔开for (file <- filesHereif 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 % 3Vector(1, 2, 0, 1, 2, 0, 1, 2, 0, 1)

这类循环叫做for推导式
for推导式生成的集合与它的第一个生成器是类型兼容的。

def fileLines(file: java.io.File) =scala.io.Source.fromFile(file).getLines.toListdef grep(pattern: String) =for (file <- filesHereif 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 <- filesHereif 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 filescalaFiles: 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.lengthforLineLengths: Array[Int] = Array()