Scala基础 -- 1,2.Scala的安装和基础语法

1 安装Scala

1.1 Win安装scala环境

  访问Scala官网http://www.scala-lang.org/下载Scala编译器安装包，解压后配置上环境变量就可以了。

1.2 Linux安装scala环境

  a) 下载Scala，地址https://www.scala-lang.org/download/2.12.6.html
  b) 然后解压Scala到指定目录：tar -zxvf scala-2.12.6.tgz -C /usr/local/src
  c) 配置环境变量，将scala加入到PATH中

vi /etc/profile
export SCALA_HOME=/usr/local/src/scala-2.12.6
export PATH=$PATH:$SCALA_HOME/bin

1.3 IDEA安装scala插件

  Configure -> Plugins -> Browse Repositories -> 搜索Scala -> 找到Scala LANGUAGES -> 点击右侧的Install -> 重启IDEA

2 Scala基础

2.1 声明变量

//使用val定义的变量值是不可变的，相当于java里用final修饰的变量
val i = 1

//使用var定义的变量是可变得，在Scala中鼓励使用val
var s = 2

//Scala编译器会自动推断变量的类型，必要的时候可以指定类型
//变量名在前，类型在后
val str: String = "hello scala"
println(i + "," + s + "," + str)

2.2 条件表达式

val x = 1

//判断x的值，将结果赋给y
val y = if (x > 0) 1 else -1
println("y:" + y)

//支持混合类型表达式
val z = if (x > 1) 1 else "error"
println("z:" + z)

//如果缺失else，相当于if (x > 2) 1 else ()
val m = if (x > 1) 1
println("m:" + m)

//在scala中每个表达式都有值，scala中有个Unit类，写做(),相当于Java中的void
val n = if (x > 1) 1 else ()
println("n:" + n)

//if和else if
val k = if (x > 1) 1 else if (x > 0) 0 else -1
println("k:" + k)

2.3 块表达式

val x = 0
//在scala中{}中课包含一系列表达式，块中最后一个表达式的值就是块的值
val result = {
  if(x > 0) 1 else if(x == 0) 0 else -1
}
//result的值就是块表达式的结果
println("result: " + result)

2.4 For循环

//for(i <- 表达式),表达式1 to 10返回一个Range（区间）
//每次循环将区间中的一个值赋给i
for (i <- 1 to 10) {
  print(i + ",")
}
println()

//for(i <- 数组)
val arr = Array("a", "b", "c")
for (i <- arr) {
  print(i + ",")
}
println()

//高级for循环，每个生成器都可以带一个条件，注意：if前面没有分号
for (i <- 1 to 3; j <- 1 to 3 if i != j) {
  print(i*10 + j + ",")
}
println()

//for推导式：如果for循环的循环体以yield开始，则该循环会构建出一个集合
//每次迭代生成集合中的一个值
val v = for(i <- 1 to 10) yield i * 10
println(v)

2.5 函数和方法

object ScalaTest2 {

  //定义一个方法,方法由def开始，m1为方法名，括号内为参数，括号右边是返回值，等号右边为表达式
  def m1 (x:Int, y: Int) : Int = x * y
  //返回值可以不写，scala会自动识别,但是递归方法，必须指定返回值
  def m2 (x: String, y: String) = x + y

  //定义函数
  //定义了一个匿名函数，左边为参数列表，右边是表达式，该函数没由变量引用，即匿名函数，同时没写返回值
  (x: Int, y: Int) => (x + y)

  //普通函数,即有变量引用的函数
  val f1 = (x: String, y: String) => {x + y}
  val f2 = (x: Int) => x * 10
  val f3 = (x: Int) => x + 10

  //将函数传入方法中
  val f4 = (x: Int) => x * 10
  def m3 (f: Int => Int) : Int = {
    //方法中调用传入的函数
    f(3)
  }

  //将方法转化为函数
  def m4 (x : Int, y: Int) : Int = x * y

  def main(args: Array[String]): Unit = {
    //调用方法
    println(m1(2, 4))
    println(m2("Hello ", "World"))

    //调用函数
    println(f1("Hello ", "Scala"))

    //在函数式编程语言中，函数是“头等公民”，它可以像任何其他数据类型一样被传递和操作
    //其实就是把函数f2，f3的功能给传递到方法中，执行函数的功能
    //这里就是把f2的x*10传入map方法，执行了x*10，把f3的x+10传入map方法，执行了x+10
    val r = 1 to 10
    println(r.map(f2))
    println(r.map(f3))

    //函数传入方法
    println("函数传入方法中，结果为：" + m3(f4))

    //三种相同功能的不同写法
    println(r.map((x: Int) => x * 100)) //map中传入一个匿名函数，参数为Int，功能是map取出的每个元素*100
    println(r.map(x => x * 100)) //既然知道传入的必然是Int，则参数可以不写，即：map每个元素赋予x，功能是x*100
    println(r.map(_ * 100)) //再可以直接简写为_

    val a2 = Array(1,2,3,4,5,6)
    //map中传入匿名函数
    val r1 = a2.map(x => x * 10)
    val r2 = a2.map(x => x - 10)
    //这样打印的是地址
    println(r1)
    //scala中用toBuffer查看里面的内容
    println(r1.toBuffer)
    //还是输出的是地址
    println(r1.toString)
    println(r2.toBuffer)
    println(a2.toBuffer)

    //将方法转化为函数，神奇的下划线
    val f5 = m4 _
    println(f5(3, 2))
  }
}