scala编程基础

1、变量

Scala和Java一样，有7种数值类型Byte、Char、Short、Int、Long、Float和Double（无包装类型）和一个Boolean类型

/**
  *  声明、定义变量
  */

object VariableDemo {
  def main(args: Array[String]): Unit = {
    // 定义一个变量，吧变量名在前，类型在后。
    var i: Int = 100;

    //Scala编译器会自动推断变量的类型，必要的时候可以指定类型。
    var i2 = 100
    var s: String = "Hello Scala"
    var s2 = "Hello World"

    // 使用val修饰的变量不可变，相当于java里用final修饰的变量，scala中推荐使用val。
    val s3 = "使用val修饰的变量不可变"

  }

2、条件表达式

/**
  * 条件表达式
  */
object ConditionExprDemo {
  def main(args: Array[String]): Unit = {
    val a = 100
    val b = 200
    // 比较a、b的大小，获取较大的值，但不建议用这种方式
    var max = 0
    if (a > b) {
      max = a
    } else {
      max = b
    }

    // scala中可以直接将使用如下语法，推荐使用。
    var max2 = if (a > b) a else b
    println(max + "," + max2)

    // 同时支持块表达式
    val c = 300
    var max3 = if (a > b){
      if (a > c) a else c
    } else {
      if (b > c) b else c
    }
    println(max3)
  }
}

3、循环

/**
  * 循环
  */
object LoopDemo {
  def main(args: Array[String]): Unit = {
    // for (i <- 表达式/数组/集合)
    // 1 to 10 相等于Int.to(Int)，在一个匿名空间构造值为1的Int变量，调用to(Inf)方法
    for (i <- 0 to 10) println(i)  // 左闭右闭
    for (i <- 0 until 10) println(i) // 左闭右开区间
    for (i <- Range(0,10)) println(i) // 左闭右开区间

    // 双重循环，循环构造器中还能加上条件表达式，yield是关键字，可以把再构造一个新的数组
    var arr = for (i <- 1 to 9; j <- 1 to 9 if i == j ) yield i + j
    println(arr.toBuffer)
  }
}

4、函数和方法

object FunctionAndMethodDemo {

  // 定义一个函数
  val add : (Int, Int) => Int = {
    (x, y) => x + y
  }

  // 同样是定义一个函数
  val dif = (x: Int, y: Int) => (x - y)

  // 定义一个方法
  def  mult(x: Int, y: Int) : Int = {
    x * y
  }

  // 定义一个方法
  def Calculate(func:(Int, Int) => Int, x: Int, y: Int) : Int = {
    func(x,y)
  }

  val Calculate2 =  (func:(Int, Int) => Int, x: Int, y: Int) => {
    func(x,y).toString
  }


  def main(args: Array[String]): Unit = {
    println(Calculate(add,3,2))
    println(Calculate(mult,3,2))
    println(Calculate2(dif,1,2))
    println(Calculate2(mult,6,2))

    // 调用函数，传入匿名函数
    println(Calculate2((x,y) => x / y, 10,5))
    // 调用方法，传入匿名函数
    println(Calculate2((x,y) => {println("hello world.");x / y}, 10,2))

    // 将一个方法强转为函数类型
    val f = mult _
  }

}