【scala 笔记（1）】 基础

简介

Scala是一门多范式的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种特性。Scala运行于Java平台（Java虚拟机），并兼容现有的Java程序。

Scala 解释器

启动Scala解释器的步骤如下：
- 安装Scala （Linux 环境下先安装个Java环境， 再去官网下载个scala Unix版本，解压即可）
- 确保 scala/bin 目录位于系统PATH中(修改 .profile 文件配置, 添加scala 运行目录到PATH中)。

prod@AWS-TEST-DT:~/borey_zhu/scala$ cat ~/.profile 
 ....

JAVA_HOME=/home/prod/softwares/jdk1.8.0_60
export PATH=$JAVA_HOME/bin:$PATH

SCALA_HOME=/home/prod/softwares/scala/scala-2.12.2
export PATH=$SCALA_HOME/bin:$PATH

• 重新加载下环境变量运行 scala 命令即可进入Scala 解释器中

prod@AWS-TEST-DT:~/borey_zhu/scala$ scala
Welcome to Scala 2.12.2 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_60).
Type in expressions for evaluation. Or try :help.

scala> println("hello scala")
hello scala

ok, scala 环境搞定！

编写一个简单的Scala程序

// Hello.scala
object Hello{
  def main(args: Array[String]){
    println("hello borey")
  }
}

编译&运行

prod@AWS-TEST-DT:~/borey_zhu/scala$ scalac Hello.scala 
prod@AWS-TEST-DT:~/borey_zhu/scala$ scala Hello
hello borey

变量定义

Scala 有两种变量, val 和 var 。 val 类似于Java 中的final 变量。 一旦初始化了， val就不能再被赋值。 var 如同 Java 里 非final变量， 可以在它的生命周期中被对次赋值：

scala> val a = 1
a: Int = 1

scala> a =2  // error
<console>:12: error: reassignment to val
       a =2
         ^

scala> var b = 1
b: Int = 1

scala> b =3 // ok
b: Int = 3

scala 具备 类型推导 能力, 不必像 Java/C++ 必须进行类型声明 （C++ 11 开始也具备了类型推导的能力 ）。

基本类型

Scala 中有如下几种基本类型， 除了String 归于 java.lang包之外， 其余所有的基本类型都是包 scala的成员。 如： Int => scala.Int 。 由于包scala 和java.lang 的所有成员都被每个scala 源文件自动引用， 因此可以在任何地方使用简化名。

值类型	范围
Byte	8 位有符号补码整数 ( $-2^7$ ~ $2^7 -1$)
Short	16 位有符号补码整数 ( $-2^{15}$ ~ $2^{15} -1$)
Int	32 位有符号补码整数 ( $-2^{31}$ ~ $2^{31} -1$)
Long	64 位有符号补码整数 ( $-2^{63}$ ~ $2^{63} -1$)
Char	16 位无符号Unicode字符( 0 ~ $2^{16} -1$)
String	char 序列
Float	32位 IEEE754单精度浮点数
Double	64位 IEEE754单精度浮点数
Boolean	true or false

操作符和方法

Scala 为基本类型提供了丰富的操作符集（其实操作符实际只是普通方法调用的另一种表现形式）：

scala> val (a, b) = (1, 2)
a: Int = 1
b: Int = 2

scala> a+b
res0: Int = 3

scala> a.+(b)  // 方法调用
res1: Int = 3

此符号 + 是操作符， 更明确的说，是中缀操作符。 操作符标注不仅限于像 + 这种其他语言里看上去像操作符的东西， 在Scala 中任何方法都可以被当做操作符来标注 。

例如：java.lang.String

scala> val s: java.lang.String = "abc"
s: String = abc

scala> s split 'b'
res4: Array[String] = Array(a, c)

函数调用

除了方法之外， Scala 还提供函数。 使用也更为简单
例如：

scala> import math._ // _ 字符是 通配符， 类似Java 中的 *
import math._

scala> abs(-1)
res5: Int = 1

scala> sqrt(4)
res6: Double = 2.0

Scala 没有静态方法， 不过他有个类似的特性：单例对象（后续会了解到）。 通常一个类对应有一个伴生对象， 其方法就和Java中的静态方法一样。

常用的控制结构

• 条件表达式 if {} else {}

scala> val a = if (b > 1) 10 else 20 // 等效 Java/C++  b > 1? 10:20
a: Int = 10

• 块表达式 {}

scala> val a = { val x=10; val y=100; x*y}
a: Int = 1000

• 循环 while(condition) { ... } , for (range){...}
  后续会更深入了解

scala> while(a>0) {println(a); a-=1;}
2
1

scala> for( i <- 1 to 3){println(i)}
1
2
3

• 懒值 lazy

  使用lazy声明的变量会被推迟初始化， 直到我们首次使用

scala> lazy val a = { val x=10; val y=100; println(x + ", " + y); x*y} //这里未必初始化
a: Int = <lazy>

scala> println(a)
10, 100     // 初次使用进行初始化 打印输出
1000

scala> println(a)
1000

• 异常 try {} catch {}

// 异常捕获的语法使用的是模式匹配语法，后续会了解到
scala> try{
     |     1/0
     |   }catch {
     |     case ex: ArithmeticException =>  
     |       println("除0 ... " + ex)
     |     case _ : Exception =>
     |       println("ignore")
     |   }
除0 ... java.lang.ArithmeticException: / by zero
res15: AnyVal = ()

// 抛出异常采用 throw new ExceptionClass( ... )

常用的集合

简单介绍下常用的集合使用：

• 元组 Tuple

scala> val a = (1,2)
a: (Int, Int) = (1,2)

scala> a.getClass
res21: Class[_ <: (Int, Int)] = class scala.Tuple2$mcII$sp

scala> val b = (1,"2", 3.0)
b: (Int, String, Double) = (1,2,3.0)

scala> b.getClass
res22: Class[_ <: (Int, String, Double)] = class scala.Tuple3

scala> a._1
res28: Int = 1

scala> b._3
res27: Double = 3.0

• 数组 Array

scala> val a = Array(1,2)
a: Array[Int] = Array(1, 2)

scala> a.foreach(println)
1
2

• 列表 List

scala> var a = 1::2::Nil  // Nil 结束符
a: List[Int] = List(1, 2)

scala> var b = 3::4::Nil
b: List[Int] = List(3, 4)

scala> a::b  //  理解为 a.::(b) 就可了
res42: List[Any] = List(List(1, 2), 3, 4)

scala> b::a
res43: List[Any] = List(List(3, 4), 1, 2)

scala> a++b // 合并
res45: List[Int] = List(1, 2, 3, 4)

scala> a:::b
res46: List[Int] = List(1, 2, 3, 4)

scala> a(1)
res48: Int = 2

• 映射 Map

scala> var d = Map(1->2 , 3->4)
d: scala.collection.immutable.Map[Int,Int] = Map(1 -> 2, 3 -> 4)

scala> d.get(1)  // 取值
res49: Option[Int] = Some(2)

scala> d.get(3)
res50: Option[Int] = Some(4)

scala> d.get(2) // 不存在 返回None
res51: Option[Int] = None

scala> d.getOrElse(7, 10) // 不存在 返回 默认值
res58: Int = 10

scala> d += (5->6) // 添加

scala> d
res54: scala.collection.immutable.Map[Int,Int] = Map(1 -> 2, 3 -> 4, 5 -> 6)

scala> d -= 3     // 删除

scala> d
res56: scala.collection.immutable.Map[Int,Int] = Map(1 -> 2, 5 -> 6)

更多API的使用可以查看官方文档， 注意引用scala.collection.immutable 和 scala.collection.mutable 集合间的区别。