scala 小结(一)

Scala 是什么?(What is scala?)

  引用百度百科对于scala的定义:

Scala是一门多范式的编程语言，一种类似java的编程语言，设计初衷是实现可伸缩的语言、并集成面向对象编程和函数式编程的各种特性。

  scala 是一种纯面向对象的编程语言，但是与java不同，其还无缝结合了命令式编程以及函数式编程。scala的出现，抹平了这些编程范式之间严格的界限。与java相比，scala更为简洁，实现一个相同的功能，也许scala的代码行数只需要java的五分之一甚至十分之一，这当然与scala和函数式编程的结合密不可分。scala基于JVM平台，这使得其与java可以无缝衔接，目前Apache Spark 等框架在大数据领域占有举足轻重的地位，工业界也已经证明了scala语言的强大。所以scala语言在近些年越来越火热了。

Scala 的安装环境配置

  由于scala基于JVM,所以首先肯定需要安装java的开发环境的，这个网上都有教程。不赘述。其次需要去下载scala的安装包，然后按照教程配置即可。我使用的IDE 是 eclipse for scala，当然使用eclipse + scala 的插件也是可以的。这些网上都有教程，这里不表。

说明: 这里的总结主要基于《Scala开发快速入门》这本书，目前国内关于Scala的中文书籍还不是很多，这本书还不错，想学Scala的同学可以看下。另外还有一些英文的参考书也是不错的。比如：

1.《Scala编程》

2. 《Beginning Scala》

3. 《Programming in Scala》

4. 《Scala CookBook》

5. 《Scala in Action》

6. 《Scala in Depth》

7. 《Steps in Scala》https://www.google.com.hk/?gws_rd=ssl

  我把上面这些书的电子版打包到百度云了， 有需要的自取。地址为:

Scala的Hello World

写一个文件名叫 HelloWorld.scala，里面的代码如下

object HelloWorld extends App{
println("Hello World!")
}

输入结果为 Hello World!

1. Scala变量和基本数据类型

  1.1 scala中有两种数据类型,一种是可变变量，一种是不可变变量。可变变量使用 var 声明,不可变变量使用 val 声明。不可变变量一旦被赋值之后,在程序运行过程中不可以更改。下面展示了var 与 val 的使用方式。

scala>var string = "HelloWorld"
string:String = HelloWorld

scala>string = "How are you?"
string:String = How are you?

scala>val newString = "hello"
newString:String = hello

scala> newString = "HELLO"
<console>:12: error: reassignment to val
       newString = "HELLO"

可以看出，声明为 val 的变量在赋值之后，如果被重新赋值，则会报错。

  1.2 需要注意的是，scala中的变量在定义时必须被初始化，否则会报错。比如:

scala> var string:String
<console>:11: error: only classes can have declared but undefined members
(Note that variables need to be initialized to be defined)
       var string:String

scala> val string:String
<console>:11: error: only classes can have declared but undefined members
       val string:String

scala> val string:String = ""
string: String = ""

   1.3 使用占位符 _ 初始化。

在对变量进行初始化时，有一种特殊的初始化方式，即使用占位符 _ 初始化。String 类型使用 _ 初始化为 null,Float ，Int，Double使用 _ 初始化为0，Char 则被初始化为 ?。例子如下:

scala> var s:String = _
s: String = null

scala> var i:Int = _
i: Int = 0

scala> var f:Float = _
f: Float = 0.0

scala> var double:Double = _
double: Double = 0.0

scala> var ch:Char = _
ch: Char = ?

   1.4 使用lazy 关键字。在scala中，使用lazy 关键字修饰 val 变量只有在变量真正使用的时候才会被赋值。举例如下:

scala> lazy val s1 = "string"
s1: String = <lazy>

scala> s1
res0: String = string

需要注意的是:lazy 关键字不能修饰 var 变量，这样做的目的是为了防止变量在被使用之前就被重新赋值。

scala> lazy var s2 = "string"
<console>:1: error: lazy not allowed here. Only vals can be lazy
lazy var s2 = "string"
     ^

   1.5 scala 的基本数据类型。scala 中的基本数据类型有 Byte、Short、Int、Long、Char、String、Float、Double、Boolean 九种。这与java中的基本数据类型是一一对应的，只不过scala中的基本数据类型首字母要大写，这是因为scala中所有的值类型都是对象。

• Byte Byte 为8位有符号的整数，表示的范围是:\(-2^{7}\) 到 \(2^{7}-1\)。
• Short Short 为 16位有符号的整数，表示的范围是 \(-2^{15}\) 到 \(2^{15}-1\)。
• Int Int 为 32位有符号的整数，表示的范围是 \(-2^{31}\)到 \(2^{31}-1\)。Int 类型变量的定义方式包括十进制、八进制和十六进制三种。
  
  十进制是最常用的定义Int 类型变量的方式:

scala> var a = 12
a: Int = 12

八进制使用数字0开头定义:

var b = 012
b:Int = 10

十六进制使用 0x 开头定义:

var c = 0x12
c:Int = 18

• Float 由于 scala 具有类型推导的功能，所以对于浮点数如果不明确指明，scala 会自动将它翻译为Double 类型的。如果想要声明一个Float类型，需要在浮点数后面加F或者f。比如3.13f。

scala> var f = 3.13
f: Double = 3.13
scala> var f = 3.13f
f: Float = 3.13

• Double Double 表示的是双精度的浮点数。scala中的浮点数默认就是Double类型的。Double 还可以使用指数表示法，在浮点数后面加e或者E,比如1.2e2。

scala> var double = 3.1415
double: Double = 3.1415
scala> var e = 1.2e2
e: Double = 120.0

• Char Char 表示的是字符类型，使用单引号将一个字符括起来。部分特殊字符需要使用\进行转义。

scala> var ch = 'c'
ch: Char = c
scala> var ch = '\"'
ch: Char = "
scala> var ch = '\141'
warning: there was one deprecation warning; re-run with -deprecation for details
ch: Char = a

• String String 类型表示的是字符串类型。使用双引号将字符串括起来即可。如果字符串中有特殊字符(比如双引号)需要进行转义。

scala> var str = "string"
str: String = string
scala> var str = "What's your name?"
str: String = What's your name?
scala> var str = "My name is \"lyrichu\"."
str: String = My name is "lyrichu".

scala中还提供了一种特殊的可以保证原样输出的记号,"""(三个双引号)。比如:

scala> var str = """hello,\n\n what's your name? ""\n"""
str: String = hello,\n\n what's your name? ""\n

• Boolean Boolean 表示的是布尔类型。有true和false两种。

scala> var x = true
x: Boolean = true
scala> var y = false
y: Boolean = false

2. scala 基本类型操作

   2.1 算术运算操作。基本的算数运算操作有加(+)、减(-)、乘(*)、除(/)、取余(%)。举例如下:

scala> 1 + 1
res2: Int = 2
scala> 1-10
res3: Int = -9
scala> 8*9
res4: Int = 72
scala> 1/2
res5: Int = 0
scala> 100 % 3
res6: Int = 1
scala> 1f*12
res7: Float = 12.0
scala> 2 + -3
res8: Int = -1

注意上面 res8的结果，scala中提供了 + 和 - 两个操作符，可以直接在运算中使用。

  2.2 关系运算操作 scala中的关系运算操作符包括 大于(>)、小于(<)、小于等于(<=)、大于等于(>=),使用实例如下:

scala> 1<2
res9: Boolean = true
scala> -1>3
res10: Boolean = false
scala> 2>=2
res11: Boolean = true
scala> 3<=3
res12: Boolean = true
scala> !(1>2)
res13: Boolean = true

上式中 ! 为取反操作符。

  2.3 逻辑运算操作符。scala中的逻辑运算操作符包括逻辑与(&&)和逻辑或(||)操作符。逻辑与运算符当两个条件都为真时才为真，逻辑或只要至少有一个为真就为真。举例如下:

scala> var b1 = 1<2
b1: Boolean = true
scala> var b2 = 2>3
b2: Boolean = false
scala> b1 && b2
res14: Boolean = false
scala> b1 || b2
res15: Boolean = true

  2.4 位运算操作符 scala中的位运算符包括按位与(&)、按位或(|)、按位异或(^)、按位取反(~),左移位(<<)、右移位(>>)、无符号左移位(<<<)、无符号右移位(>>>)。按位与只有当某一位两个数都为1时才为1，否则为0；按位或只要至少有一个1就为1；按位异或当一个0一个1时为1，否则为0；按位取反将原本的1变为0,0变为1；左移位将所有位的数字左移，左移一位相当于原数字乘以2；右移位将所有的数字右移，右移一位相当于原来的数字除以2；无符号左移，是将所有位数字左移，低位补0，高位舍弃；无符号右移，是将各位所有数字右移，高位补0，低位舍弃。实例如下

scala> 3&5 // 3->00000011,5->00000101, 3&5 -> 00000001
res16: Int = 1
scala> 3|5 // 3->00000011,5->00000101, 3|5 -> 00000111
res17: Int = 7
scala> 3^5 // 3->00000011,5->00000101,3^5 -> 00000110
res18: Int = 6
scala> ~3 // 3->00000011 ~3 -> 11111100->-4
res19: Int = -4
scala> 3>>2
res20: Int = 0
scala> 3<<2
res21: Int = 12
scala> -1>>>31
res22: Int = 1

   2.5 对象比较运算符。 这里需要注意的是，在java中的对象比较是基于引用的，即比较两个对象实际的物理地址是否一样，而scala是基于内容比较的，不管两个对象地址是否一样。

scala> 1.0==1
res26: Boolean = true
scala> var x = "string"
x: String = string
scala> var y = "string"
y: String = string
scala> x==y
res27: Boolean = true
scala> y.equals(x)
res28: Boolean = true
scala> var z = new String("string")
z: String = string
scala> z == x
res29: Boolean = true
scala> z.eq(x)
res30: Boolean = false

注意如果要是想比较两个对象的引用是否一样，需要调用对象的eq方法。

   2.6 字符串运算操作 scala 中的String 类型实际上就是 java中的 java.lang.String 类型，因此是可以调用java中的所有String类的方法。举例如下:

scala> str.indexOf("e")  // 找到e的索引
res31: Int = 1
scala> str.toUpperCase() // 把所有字符变大写
res32: String = HELLO
scala> str.reverse  // 翻转字符串
res34: String = olleh
scala> str.toLowerCase // 变小写
res35: String = hello
scala> str.drop(3)  // 丢弃前3前位字符
res36: String = lo
scala> str.slice(1,4) // 取第1到第3位的字符(从0开始)
res37: String = ell

  2.7 元组类型。scala中元组是一种特殊的类型,可以将不同类型的值放在一个变量中保存。元组的定义如下：

scala> var tuple = ("hello","world",1.0)
tuple: (String, String, Double) = (hello,world,1.0)

在使用的时候还可以将元组的内容提取，对多个变量进行初始化，比如:

scala> val (first,second,third) = tuple
first: String = hello
second: String = world
third: Double = 1.0

上面的代码将元组tuple中的三个元素分别赋值给了first、second、third变量。如果要想访问元组中的内容，可以使用 tuple变量._N的形式来进行，其中N表示元组元素的索引号(从1开始计数)。比如下面的代码:

scala> tuple._1
res0: String = hello

scala> tuple._2
res1: String = world

scala> tuple._3
res2: Double = 1.0

   2.8 符号类型。scala中还有一种特殊的类型为符号类型(Symbol)，使用 ' 符号进行标识。举例如下:

scala> val s = 'hello
s: Symbol = 'hello

scala> val s1:Symbol = 'world
s1: Symbol = 'world

符号类型在输出时会原样输出(带有'符号)

scala> println(s)
'hello

符号类型主要起标识作用，在模式匹配和内容判断中比较常见，比如:

scala> if(s == 'hello) println("hello") else println("others")
hello

与String等类型一样，scala在使用 == 符号进行比较时，比较的是变量的内容而不是引用。比如:

scala> val s2 = 'hello
s2: Symbol = 'hello

scala> s2 == s1
res5: Boolean = false

scala> s2 == s
res6: Boolean = true