Scala入门 【1】

Scala入门 【1】

---

转载请注明出处：http://www.cnblogs.com/BYRans/

1 基础

• val定义的为常量，var为变量

• val name:Type = ***，变量名后加冒号，然后定义变量类型

• Scala有7种 数值类型 ：Byte、Char、Short、Int、Long、Float和Double，以及一个Boolen类型。

• Scala支持语法： a 方法 b ,或者简写为： a.方法(b) 例如：

  1 to 10
  
  或者
  
  1.to(10)
  
  

  产出 Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

• Scala没有 ++ 和 -- 操作，需要使用 +=1 和 -=1

• 不带参数的Scala方法通常不使用圆括号。例如: "Hello".distinct 输出 "Helo"

2 控制结构和函数

• 概述
  • if表达式有值
  • 块也有值——是它最后一个表达式的值
  • Scala的for循环就像是“增强版”的java for循环
  • 分号（在绝大多数情况下——不是必需的
  • void类型是Unit
  • 避免在函数定义中使用return
  • 注意别在函数式定义中漏掉了=
  • 异常的工作方式和java或C++中基本一样，不同的是你在catch语句中使用“模式匹配”
  • Scala没有受检异常

if语句

• if (3 > 22) "asdf" else () 类似于java/c++中的 ?: ,在Scala中 if/else 和 ?: 结合在了一起。在这个例子中，两个分支有一个公共超类 Any 。如果if语句不需要else，可以写为 if(x>1) () 输出为 Unit = () 。

换行

• Scala程序结尾不需要加 ; ，当然，如果加爷可以。如果一行代码太长，必须要写为两行，要确保第一行以一个 不能 用作语句结尾的符号结尾，通常为操作符，例如：

  s = s0 + (v - v0) * t + // +告诉解析器这里不是语句的末尾
  
  0.5 * (a - a0) * t * t
  
  

控制台输入输出

• scala输出语法：

  print("输出无换行")
  
  println("输出加换行")
  
  printf("Hello,%s. You are %d years old.\n","Rans",27) // C风格输出
  
  

• readLine方法可以从控制台读取一行输入。如果要读取数字、Boolean或字符，可以用readInt、readDouble、readByte、readShort、readLong、readFloat、readBoolean、readChar。这些方法中，只有readLine方法有参数：

  val name = readLine("Your name: ")
  
  print("Your age: ")
  
  val age = readInt()
  
  println("Hello " + name + ", Next year you will be " + (age + 1) )
  
  

for循环

• Scala的while循环与java/C++的相同，但Scala没有 for(int i=0;i < 10;i++) 这种循环语句，如果要使用这种语句有两种选择：

  • 一是使用while循环;
  • 二是使用语法 for（i <- 表达式） ,语法表示让变量i遍历 <- 右边的表达式的所有值。例如：

  for(i <- 1 to n)
  
      r = r * i
  
  

  在for循环的变量之前没有val或var的指定。该变量的类型是集合的元素类型。循环变量的作用域一直持续到循环结束。

• 在遍历字符串或数组时，可以用 until 方法而不是 to 方法， until 方法返回不包含上限的区间。

  val s = "Hello"
  
  var sum = 0
  
  for (i <- 0 until s.length) // i的最后一个取值是s.length-1
  
      sum += s(i)
  
  

  对字符串的遍历可直接使用：

  var sum = 0
  
  for (ch <- "Hello") sum += ch
  
  

• Scala中没有提供 break 和 continue 语句来退出循环，当然，也有方法实现这个功能，但是最好避免使用这种方式。

• 高级for循环和for推导式：

  for(i <- 1 to 3;j <- 1 to 3) print ((10 * i + j) + " ") // 打印11 12 13 21 22 23 31 32 33
  
  for(i <- 1 to 3;j <- 1 to 3 if i != j) print ((10 * i + j) + " ") // 打印12 13 21 23 31 32
  
  for(i <- 1 to 3;from =  <- 1 to 3 if i != j) print ((10 * i + j) + " ") // 打印12 13 21 23 31 32
  
  for(i <- 1 to 10) yield i % 3 // 生成Vector(1,2,0,1,2,0,1,2,0,1)
  
  

函数定义

• 定义函数需要指明函数的名称、参数(包括参数的类型)和函数体，只要函数不是递归的，就不需要指定返回类型，例如：

  def abs(x: Double) = if (x >= 0) x else -x
  
  

  如果函数体需要多个表达式，可以使用代码块。代码块中最后一个表达式的值就是函数的返回值，例如下面代码中 r 值即为函数的返回值：

  def fac(n: Int) = {
  
      var r = 1
  
      for (i <- 1 to n) r = r * i
  
      r
  
  

• 递归函数需要指明返回类型，示例：

  def fac(n: Int): Int = if (n <= 0） 1 else n * fac（n - 1）
  
  

参数参数和带名参数

• 默认函数参数和带名参数，例如下面函数有3个参数，其中 left 和 right 两个参数有默认值。在调用该函数时，如果没有指定默认参数的值，那么默认参数将使用默认值。

  def decorate(str: String, left: String = "[", right: String = "]") = left + str + right
  
  decorate("Hello") // 得到 [Hello]
  
  decorate("Hello","<<<",">>>") // 得到 <<<Hello>>>
  
  decorate("Hello","<<<") // 得到 <<<Hello]
  
  decorate("Hello",rigth = ">>>") // 得到 [Hello>>>
  
  decorate(left = "<<<", str = "Hello", right = ">>>") // 得到 <<<Hello>>>
  
  

变长参数

• 如下函数的参数个数是可变的,可以用任意个参数调用该函数，这多个参数在函数内部是一个 Seq 类型的参数：

  def sum(args: Int*) = {
  
      var result = 0
  
      for (arg <- args) result += arg
  
      result
  
  }
  
  val s = sum(1,2,3,4) // 得到 s: Int = 10
  
  val s = sum(1 to 4) // 错误！！
  
  val s = sum(1 to 4: _*) // 如果传入的是一个区间，需要追加:_*
  
  

3 数组相关操作

定长数组

• Scala中定长数组为 Array ，示例如下：

  val nums = new Array[Int](10) // 10个整数类型的数组，所有元素初始化为0
  
  val a = new Array[String](10) // 10个元素的字符串数组，所有元素初始化为null
  
  val s = Array("Hello","World") // 已提供初始值就不需要new关键词，也不需要指明类型，类型Scala会自动推断
  
  s(0) = "Goodbye" // Array("Goodbye","World"),使用()访问元素，注意不是使用[]
  
  

变长数组

• ArrayBuffer 变长数组（数组缓冲）的长度可以变化，类似于java中的ArrayList。示例如下：

  import scala.collection.mutable.ArrayBuffer
  
  val b = new ArrayBuffer[Int]() // 创建ArrayBuffer，可以不写new关键词
  
  b += 1 // ArrayBuffer(1)，用 += 在末尾添加元素
  
  b += (2,3,4) // ArrayBuffer(1,2,3,4)，用 += 可添加多个元素，多个元素用括号包起来
  
  b ++= Array(5,6,7) // ArrayBuffer(1,2,3,4,5,6,7)，用 ++= 操作追加集合
  
  b.trimEnd(5) // ArrayBuffer(1,2)，移除最后5个元素
  
  

遍历

• 在for循环中如果不需要元素的下标，可以如下遍历：

  for (elem <- a)
  
      println(elem)
  
  

• 在for循环中如果需要用到元素下标,可以如下遍历：

  for (i <- 0 until a.length) // until产生0到length-1之间的数
  
      println(i + ": " + a(i)) 
  
  （0 until a.length).reverse // 倒序产生区间，得到Range(...,2,1,0)
  
  

数组转换

• 基于数组或数组缓冲，构建新的数组或数组缓冲。使用 for (elem <- arr if ...) ... yield ... ，示例如下：

  val a = Array(2,3,5)
  
  val result = for (elem <- a) yield 2 * elem // 得到Array(4,6,10)。如果a是ArrayBuffer，那么得到的就是ArrayBuffer
  
  // for循环中也可以使用守卫，即for中加if
  
  val guard = for (elem <- a if elem % 2 == 0) yield 2 * elem // 得到Array(4)
  
  

多维数组

• Scala和java一样，多维数组是通过数组内放数组的方式来实现的。构建数组使用 ofDim 方法：

  val marix = Array.ofDim[Double](3,4) // 构建三行四列的Double类型的数组
  
  // 可以创建不规则的数组，即每行的长度可以不同
  
  val triangle = new Array[Array[Int]](10)
  
  for (i <- 0 until triangle.length)
  
      triangle(i) = new Array[Int](i + 1)
  
  

数组与java互操作

• Scala数组和java数组可以互操作；用ArrayBuffer，使用 scala.collection.JavaConversions 中的转换函数

4 映射和元组

构造Map

• 构造Map代码示例：

  val scores = Map("Alice" -> 10,"Bob" -> 3) // 该Map[String,Int]key对应的value不可以修改,也不可以添加新的kv对
  
  val scores = scala.collection.mutable.Map("Alice" -> 10,"Bob" -> 3) // 该Map[String,Int]key对应的value可以修改
  
  val scores = scala.collection.mutable.HashMap[String,Int] //创建空的HashMap
  
  

获取Map的值

• 可以使用 map(key) 访问key对应的value，对map可以调用 contains 、 getOrElse 、 get 等方法代码示例：

  val bobsScore = scores("Bob")
  
  // 如果map中没有参数指定的key，则会报出异常，在调用前可以使用contains检查是否存在key
  
  val bobsScore = if (scores.contains("Bob")) scores("Bob") else 0
  
  // 可以使用getOrElse方法实现上述功能
  
  val bobsScore = scores.getOrElse("Bob",0)
  
  

更新Map中的值

• 使用 += 添加新的kv对（可以为多个kv对），使用 -= 删除某个key对应的kv对（可以为多个kv对）

遍历Map

• 可以用 for ((k,v) <- 映射） k和v的处理逻辑 来迭代处理hashmap
• 可以用 map.keySet 方法和 map.values 方法获取key和value的集合

元组

• 元组(tuple)是不同类型的值的聚集。例如 (1,3.14,"Fred") 为一个3元组，类型为`Tuple3[Int,Double,java.lang.String]

• 对于一个元组可以使用方法 _i （i为从1开始的下标）访问其组元，例如：

  val t = (1,3.14,"Fred")
  
  val second = t._2 // 得到second: Double = 3.14