【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_60export PATH=$JAVA_HOME/bin:$PATHSCALA_HOME=/home/prod/softwares/scala/scala-2.12.2export PATH=$SCALA_HOME/bin:$PATH

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

prod@AWS-TEST-DT:~/borey_zhu/scala$ scalaWelcome 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.scalaobject 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 Hellohello borey

变量定义

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

scala> val a = 1a: Int = 1scala> a =2  // error<console>:12: error: reassignment to val       a =2         ^scala> var b = 1b: Int = 1scala> b =3 // okb: 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 = 1b: Int = 2scala> a+bres0: Int = 3scala> a.+(b)  // 方法调用res1: Int = 3

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

例如：java.lang.String

scala> val s: java.lang.String = "abc"s: String = abcscala> s split 'b'res4: Array[String] = Array(a, c)

函数调用

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

scala> import math._ // _ 字符是 通配符， 类似Java 中的 *import math._scala> abs(-1)res5: Int = 1scala> sqrt(4)res6: Double = 2.0

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

常用的控制结构

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

scala> val a = if (b > 1) 10 else 20 // 等效 Java/C++  b > 1? 10:20a: 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;}21scala> for( i <- 1 to 3){println(i)}123

• 懒值 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     // 初次使用进行初始化 打印输出1000scala> 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 zerores15: AnyVal = ()// 抛出异常采用 throw new ExceptionClass( ... )

常用的集合

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

• 元组 Tuple

scala> val a = (1,2)a: (Int, Int) = (1,2)scala> a.getClassres21: Class[_ <: (Int, Int)] = class scala.Tuple2$mcII$spscala> val b = (1,"2", 3.0)b: (Int, String, Double) = (1,2,3.0)scala> b.getClassres22: Class[_ <: (Int, String, Double)] = class scala.Tuple3scala> a._1res28: Int = 1scala> b._3res27: Double = 3.0

• 数组 Array

scala> val a = Array(1,2)a: Array[Int] = Array(1, 2)scala> a.foreach(println)12

• 列表 List

scala> var a = 1::2::Nil  // Nil 结束符a: List[Int] = List(1, 2)scala> var b = 3::4::Nilb: List[Int] = List(3, 4)scala> a::b  //  理解为 a.::(b) 就可了res42: List[Any] = List(List(1, 2), 3, 4)scala> b::ares43: List[Any] = List(List(3, 4), 1, 2)scala> a++b // 合并res45: List[Int] = List(1, 2, 3, 4)scala> a:::bres46: 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) // 不存在 返回Noneres51: Option[Int] = Nonescala> d.getOrElse(7, 10) // 不存在 返回 默认值res58: Int = 10scala> d += (5->6) // 添加scala> dres54: scala.collection.immutable.Map[Int,Int] = Map(1 -> 2, 3 -> 4, 5 -> 6)scala> d -= 3     // 删除scala> dres56: scala.collection.immutable.Map[Int,Int] = Map(1 -> 2, 5 -> 6)

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