函数参数为val类型，且可以给出默认值

def test(a: Int, b: Int = 1, c: Int = 2): Unit = {
  println(s"$a $b $c")
}
  
test(1, 2)      //1 2 2
test(1, c = 4)  //1 1 4

函数是带有参数的表达式。

(x: Int) => x + 1

方法的表现和行为和函数非常类似，但是它们之间有一些关键的差别。

方法由def关键字定义。def后面跟着一个名字、参数列表、返回类型和方法体。

def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier
println(addThenMultiply(1, 2)(3)) // 9

val a = 1
val b = 2
val c = s"$a+$b=${a + b}"

约等于static单例对象

object TestObj {
  def main(args: Array[String]): Unit = {
    val a = 1
    val b = 2
    val c = s"$a+$b=${a + b}"
    println(c)
  }
}

可以使用class关键字定义一个类，后面跟着它的名字和构造参数。

• 类里裸露的代码是默认构造中的
• 类名构造器中的参数就是类的成员属性，默认是val类型，且是private
• 只有在类名构造器中的参数可以设置成var，其他方法函数中的参数都是val类型的，且不允许设置成var类型

class Greeter(prefix: String, var suffix: String) {
  var name = "name"

  def greet(name: String): Unit =
    println(prefix + name + suffix)
}

scala中嵌套for循环可以写到一起，循环上可以加守卫（条件）。 循环结果可以通过yield收集到一个集合中

// val value = for (i <- 1 to 9; j <- 1 to i) yield {
val value = for (i <- 1 to 9; j <- 1 to 10 if (j <= i)) yield {
  i * j
}
for (i <- value) {
  println(i)
}

类似于重新封装一下函数

def log(date: Date, logType: String, msg: String): Unit = {
  println(s"$date\t$logType\t$msg")
}

val info = log(_, "info", _)
info(new Date, "this is a info msg")  //Thu Jul 22 23:14:04 CST 2021	info	this is a info msg

def foreachTest(a: Int*): Unit = {
  //for (i <- a) {
  //  print(i)
  //}

  //a.foreach((x: Int) => {
  //  print(x)
  //})

  //a.foreach(print(_))
  a.foreach(print)
}

foreachTest(1, 2, 3, 4, 5)  //12345

函数作为参数

def computer(a: Int, b: Int, f: (Int, Int) => Int): Unit = {
  val res = f(a, b)
  println(res)
}

computer(1, 2, (x: Int, y: Int) => {x + y}) //3
computer(1, 2, _ + _)                       //3

函数作为返回值

def factory(i: String): (Int, Int) => Int = {
  def plus(x: Int, y: Int): Int = {
    x + y
  }

  if (i.equals("+")) {
    plus
  } else {
    _ * _
  }
}

val plus = factory("+")
computer(1,2,plus)  //3

多个参数列表

def testFunc(a:Int*)(b:Int*)(c:String*): Unit ={
  a.foreach(print)
  b.foreach(print)
  c.foreach(print)
}

testFunc(1,2,3)(2,3,4)("3","4","5") //123234345

数组 scala中泛型是[]，数组用()

val约等于final，不可变描述的是val指定的引用（字面值、地址）

val arr1 = Array[Int](1, 2, 3)
arr1(1) = 99
println(arr1(1))  //99

遍历

for (elem <- arr1) {}
//foreach需要函数接收元素
arr1.foreach(println)

scala中collections中有两个包：immutable,mutable，默认是不可变的immutable

val list1 = List(1, 2, 3, 4)

//++ += ++: :++
val list2 = new ListBuffer[Int]
list2.+=(1)
list2.+=(2)
list2.+=(3)

val list1 = List(1, 2, 3, 4)
val list2 = list1.map(_ * 2)
list2.foreach(print) //2468

Set

不可变的

val set1 = Set(1, 2, 3, 4, 1, 2)  //1 2 3 4

可变的

val set2 = mutable.Set(1, 2, 3, 4, 1, 2)
set2.add(1)
set2.add(5) //1 2 3 4 5

Map

val map1 = Map(("a", 1), "b" -> 2, ("c", 3), ("a", 4))

map1.foreach(print) //(a,4)(b,2)(c,3)
println(map1.get("a")) //Some(4)
println(map1.get("d")) //None
println(map1.getOrElse("a", "test")) //4
println(map1.getOrElse("d", "test")) //test

val keys = map1.keys
keys.foreach(println)

遍历

for (m <- map1) {
  print(s"$m")
}
for (k <- keys) {
  print(s"($k,${map1(k)})")
}

可变的

val map2 = mutable.Map(("a", 1), "b" -> 2, ("c", 3), ("a", 4))
map2.put("a", 5)