Scala基础类型与操作

Scala基本类型及操作、程序控制结构

(一)Scala语言优势

自身语言特点：

纯面向对象编程的语言
函数式编程语言

函数式编程语言语言应该支持以下特性：
- 高阶函数
- 闭包
- 模式匹配
- 单一赋值
- 延迟计算
- 类型推导
- 尾部调用优化
- 类型推导
Scala语言具有很强的兼容性、移植性

运行于JVM上，能与JAVA相互操作
Scala语法简洁

(二)Scala基本数据类型及操作

1. 变量定义

//声明一个val变量
//与Java final关键字声明的变量一样
//一旦被赋值，就不能更改
//Scala会帮我们进行类型判断
scala> val helloString="Hello World"
hellowString: String = Hello World

//也可以进行类型指定
scala> val helloString:String="Hello World"
helloString: String =Hello World

//String其实就是java.lang.String
scala> val helloString:java.lang.String="Hello World"
helloString: String = Hello World

//不能被重新赋值，因为它是val变量
scala> hellString="Hello Crazy World"
<console>:8: error:reassignment to val
    helloString="Hello Crazy World"

下面给出的延迟加载变量：

//lazy关键字声明变量
//表示该变量不会马上赋值
//而在真正被使用时才赋值
scala> lazy val helloString="Hello Crazy World"
helloString: String = <lazy>

//在真正使用时被赋值
scala> helloString
res1: String = Hello Crazy World

scala中也存在可变变量，即随着程序的运行，变量内容可以动态变化：

//var 声明可变变量
scala> var helloString="Hello Cruel World"
helloString: String = Hello Cruel World

//重新赋值
scala> helloString="GoodBye Cruel World"
helloString: String = GoodBye Cruel World

整数类型变量定义：

//16进制定义法
scala> val x=0x29
x: Int = 41

//十进制定义法
scala> val x=41
x: Int=41

//八进制定义法
scala> 051
res0: Int = 41

浮点类型变量定义：

//Double类型定义，直接输入浮点数，编译器会将其自动推断为Double类型
scala> val doubleNumber=3.141529
doubleNumber: Double = 3.141529

//要定义Float类型浮点数，需要在浮点数后面加F或f
scala> val floatNumber=3.141529F
floatNumber: Float = 3.141529

scala> val floatNumber=3.141529f
floatNumber: Float = 3.141529

浮点类型的变量还可以采用指数表示法，如:

//浮点数指数表示法，e也可以是大写E,0.314529e1与0.314529*10等同
scala> val floatNumber=0.314529e1
floatNumber: Double = 3.14529

字符变量定义：

//字符定义，用""将字符包裹
scala> var charLiteral="A"
charLiteral: Char = A

常用特殊字符包括：

\n	换行符，其Unicode编码为(\u000A)
\b	回退符，其Unicode编码为(\u0008)
\t	tab制表符，其Unicode编码(\u0009)
\”“	双引号，其Unicode编码为(\u0022)
\”	单引号，其Unicode编码为(\u0027)
\	反斜杠，其Unicode编码为(\u005C)

字符串变量跟java类似，就是加了” “。

字符串变量定义：

//字符串变量用""包裹
scala> val helloWorld="Hello World"
helloWorld: String = Hello World

//要定义"Hello World"，可以加入转移符\
scala> val helloWorldDouble="\"Hello World\""
helloWorldDoubleQuota: String = "Hello World"

//如果希望能够原样输出字符串中的内容，则用三个引号'''符串包裹起来，如
scala> println('''hello cruel world, \n \\\\ \b \\, I am 'experienced' programmer''')
 hello cruel world, \n \\\\ \b \\, I am 'experienced' programmer

布尔类型的定义：

scala> var x=true
x: Boolean = true

基本类型操作：

在Scala中一切操作皆方法，这意味着Scala中的一切皆为对象

//整数求和，编译器会将其转换为(1).+(2)执行
scala> var sumVlaue=1+2
sumVlaue: Int = 3

//前一语句等同于下列语句
scala> var sumVlaue=(1).+(2)
sumVlaue: Int = 3

//操作符重载函数，编译器会将其转换为(1).+(2L)执行
scala> val longSum = 1+2L
longSum: Long = 3

//减法
scala>  1-3
res5: Int = -2

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

//取模
scala> 1%3
res7: Int = 1

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

//scala中可以用+ -符号来表示正负数，例如-3 +3，并且可以加入到运算符中
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
//11111110
scala> ~1
res24: Int = -2

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

//右移位(shift left)
//00000110
//00000011
scala> 6 >> 1
res26: Int = 3

对象比较：

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的使用：

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

while的使用：

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

do while的使用：

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

注意：与if不同的是，while与do while不能用作表达式，也即其返回值为Unit，在某些函数式编程语言中，删除了while与do while程序控制结构，但scala仍然保留了while与do while，可见Scala并不是纯函数式编程语言（另外一个很重要原因是，Scala函数定义时仍然可以用var指定参数）

var line = ""
while((line=readLine())!="")//在Scala中不能这么用，因为Scala中的赋值操作返回的值是Unit，而""是String类型，不能进行比较，这是函数式编程语言特有的特点
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方法将文件名称打印出来。

多重for循环的使用：

for循环同样可以有返回值：