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》

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

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 = HelloWorldscala>string = "How are you?"string:String = How are you?scala>val newString = "hello"newString:String = helloscala> newString = "HELLO"
    
     :12: error: reassignment to val       newString = "HELLO"
    

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

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

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

   1.3 使用占位符 _ 初始化。

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

scala> var s:String = _s: String = nullscala> var i:Int = _i: Int = 0scala> var f:Float = _f: Float = 0.0scala> var double:Double = _double: Double = 0.0scala> var ch:Char = _ch: Char = ?

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

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

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

scala> lazy var s2 = "string"
    
     :1: error: lazy not allowed here. Only vals can be lazylazy 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 = 12a: Int = 12

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

var b = 012b:Int = 10

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

var c = 0x12c:Int = 18

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

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

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

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

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

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

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

scala> var str = "string"str: String = stringscala> 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 = truex: Boolean = truescala> var y = falsey: Boolean = false

2. scala 基本类型操作

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

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

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

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

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

上式中 ! 为取反操作符。

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

scala> var b1 = 1<2b1: Boolean = truescala> var b2 = 2>3b2: Boolean = falsescala> b1 && b2res14: Boolean = falsescala> b1 || b2res15: 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 -> 00000001res16: Int = 1scala> 3|5 // 3->00000011,5->00000101, 3|5 -> 00000111res17: Int = 7scala> 3^5 // 3->00000011,5->00000101,3^5 -> 00000110res18: Int = 6scala> ~3 // 3->00000011 ~3 -> 11111100->-4res19: Int = -4scala> 3>>2res20: Int = 0scala> 3<<2res21: Int = 12scala> -1>>>31res22: Int = 1

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

scala> 1.0==1res26: Boolean = truescala> var x = "string"x: String = stringscala> var y = "string"y: String = stringscala> x==yres27: Boolean = truescala> y.equals(x)res28: Boolean = truescala> var z = new String("string")z: String = stringscala> z == xres29: Boolean = truescala> z.eq(x)res30: Boolean = false

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

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

scala> str.indexOf("e")  // 找到e的索引res31: Int = 1scala> str.toUpperCase() // 把所有字符变大写res32: String = HELLOscala> str.reverse  // 翻转字符串res34: String = ollehscala> str.toLowerCase // 变小写res35: String = helloscala> str.drop(3)  // 丢弃前3前位字符res36: String = loscala> 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) = tuplefirst: String = hellosecond: String = worldthird: Double = 1.0

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

scala> tuple._1res0: String = helloscala> tuple._2res1: String = worldscala> tuple._3res2: Double = 1.0

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

scala> val s = 'hellos: Symbol = 'helloscala> val s1:Symbol = 'worlds1: Symbol = 'world

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

scala> println(s)'hello

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

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

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

scala> val s2 = 'hellos2: Symbol = 'helloscala> s2 == s1res5: Boolean = falsescala> s2 == sres6: Boolean = true

热爱编程，热爱机器学习！ github:http://www.github.com/Lyrichu github blog:http://Lyrichu.github.io 个人博客站点:http://www.movieb2b.com(不再维护)