scala基本语法

变量定义的方式：
val 值名称 : 类型 = xxx
var 变量名称 : 类型 = xxx
举例：
val a:Int=12
var b:String="1as"
lazy val a=1 //懒加载方式

方法（函数）定义的方式：
def ?方法名(参数名 : 参数类型) : 返回类型 = {
//block内最后?一?行为返回值
}
举例：
def asdq(ds:Int,sd"String):Int={
函数体
}

object week1 {
  def myprint(a: String, b: String): String = {
    var c: String = a + b
    return c
  }

  def myprint(b: String): String = {
    var c: String = b + b
    return c
  }

  def main(args: Array[String]): Unit = {
    var d = myprint("hello ", "world")
    println(d)
    d = myprint(b = "hello ", a = "world")
    println(d)
    d = myprint("U")
    println(d)
  }
}

注：
1、以上方法为标准方法，有简写的方法
2、同名函数是可以的，但是参数要不同
3、变量可以指定顺序

for循环中的数值：
1 to 10=>1,2,3...10
0 until 10=>0,1,2,3...9
range(1,10)=>1,2,3...9
range(1,11,2)=>1,3,5,7,9

object week1 {
  def main(args: Array[String]): Unit = {
    for (i <- 1 until 10 if i % 2 == 0) {
      println(i)
    }
  }
}

结果是2，4，6，8

错误机制

try {
block(redis)
} catch{
case e : Exception => System.err.println(e) //should use log in production
case _ => //should never happen
}finally {
this.close(pool, redis)
}

数组
数组分为定长数组和变长数组
定长数组的建立方法：

val array_name = new Array[T](length)
val array_name = Array(“”,””)

变长数组建立的方法：

import scala.collection.mutable.ArrayBuffer
val buff = ArrayBuffer[T]()

定长和变长元素的一些操作：

import scala.collection.mutable.ArrayBuffer
object week1 {
  def main(args: Array[String]): Unit = {
    var a = new Array[Int](4)
    println(a)
    var buff = ArrayBuffer[Int]()
    buff += 1
    buff += (2, 3, 4)
    buff ++= a
    buff ++= Array(1, 3, 5)
    println(buff)
    buff.insert(2, 32)
    buff.remove(5)
    buff.remove(6, 2)//去除从第6个元素开始的2个元素
    println(buff)
    buff.toArray//将变长数组转为定常数组后才可以有以下操作
    println(buff.sum, buff.max, buff.min)
    buff.trimEnd(4)//去除最后4个元素
    println(buff)
  }
}

数组的便利

for(i <- 0 until array_name.length)
for(i <- array_name)

举例如下：

object week1 {
  def main(args: Array[String]): Unit = {
    var a = new Array[Int](10)
    for (i <- 0 until a.length) {
      print(a(i) + ",")
    }
    println()
    for (i <- a) {
      print(i + ",")
    }
  }
}

字典
字典分为变长和定长字典

val age = Map(“Jack” -> 20,”Lucy” ->”18” )//不可变
val age = scala.collection.mutable.Map( … )//可变 
val m = scala.collection.mutable.Map[String,Int]()//初始化变长字典 

举例

object week1 {
  def main(args: Array[String]): Unit = {
    val m = scala.collection.mutable.Map[String, Int]() //初始化变长字典
    m("aa") = 2
    m += ("cc" -> 3, "bb" -> 23)
    println(m)
        m-="cc"//删除cc这个键值对
    var r = m.getOrElse("aa", 250)//a这个键存在，所以取值为a的value
    println(r)
    r = m.getOrElse("a", 250)//a这个键不存在，所以取值为250
    println(r)
  }
}

字典的迭代

object week1 {
  def main(args: Array[String]): Unit = {
    val m = scala.collection.mutable.Map[String, Int]() //初始化变长字典
    m("aa") = 2
    m += ("cc" -> 3, "bb" -> 23)
    m += ("ee" -> 3, "ff" -> 23)
    println(m)
    for ((k, v) <- m) {
      println(k, v)
    }
    println()
    for ((k, _) <- m) {
      println(k)
    }
  }
}

迭代中可以循环整个字典，也可以只循环字典的键或者值。

原文：https://blog.51cto.com/14156081/2357356