Scala 基础语法

1
var var_name[:type] = xxx

1
val val_name[:type] = xxx

1
2
3
val flag = true
// 等价于
val flag: Boolean = true

1
2
3
// 以下两种写法是一样的:
val num1 = 2 + 3
val num2 = 2.+(3)

1
2
3
// 以下两种写法一样:
val str1 = "123456".charAt(1)
val str2 = "123456" charAt 1

1
2
3
4
val str1 = "123456".substring(2, 3)
val str2 = "123456" substring (2, 3)
val str3 = "a".toUpperCase()
val str4 = "a" toUpperCase

1
2
3
4
5
6
7
8
9
10
11
12
13
val num = 10

val res = if (num > 100) {
    "num大于100"
}
else if (num < 100 && num > 5) {
    "num在5到100之间"
}
else {
    "num小于5"
}

println(res)

1
2
3
4
5
6
7
8
9
10
11
def sum100(x: Int, sum: Int): Int = {
    if (x <= 100) {
        sum100(x + 1, sum + x)
    }
    else {
        sum
    }
}

val res = sum100(1, 0)
println(res)

1
2
3
4
val list = List(1, 3, 4, 5, 12)
for (x:Int <- list) {
    println(x)
}

1
2
3
for (x <- 1 to 5) {
    println(x)
}

1
2
3
for (x <- 0 to 100; if x % 2 == 0) {
    println(x)
}

1
2
3
for (x <- 0 to 100; if x > 20; if x < 80) {
    println(x)
}

1
2
3
for (i <- 1 to 9; j <- 1 to i) {
    print(i * j + ",")
}

1
2
3
for (i <- 1 to 9; j <- 1 to i; next = if (i == j) "\n" else "\t") {
    print(i + "*" + j + "=" + i * j + next)
}

1
2
3
4
5
val res = for (i <- 1 to 9; j <- 1 to i; next = if (i == j) "\n" else "\t") yield {
    i + "*" + j + "=" + i * j + next
}

println(res)

1
2
3
4
5
6
7
8
9
try {
    ...
} catch {
    case e: Exception1 => ...
    case e: Exception2 => ...
    ...
} finally {
    ...
}

1
2
3
4
5
6
7
8
val res = try {
    ...
    "no exception"
} catch {
    case e: Exception => "have an exception"
}

println(res)

1
2
3
4
5
6
7
8
val str = "abc"
val res = str match {
    case "abc" => "我是abc"
    case "bbb" => "我是bbb"
    case _ => "我既不是abc也不是bbb"
}

println(res)

1
2
3
[private | protected] [override] [final] def fun_name(param: type[,param: type]...) [:retType] = {
    ...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Person {

  def eat(food: String): Unit = {
    println("eating " + food)
  }

}

object Main {
  def main(args: Array[String]): Unit = {
    val p = new Person()
    p.eat("苹果")
  }
}

1
2
val add = (x: Int, y: Int) => x + y
println(add(1, 2))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
object Hello {
  def main(args: Array[String]): Unit = {
    val test = new Test
    println(test.foo())
  }
}

class Test {
  def foo(): String = {
    def hello(): String = {
      "hello, world"
    }

    hello()
  }
}

1
2
3
4
5
6
7
8
9
10
11
object Hello {

  def sum(x: Int, y: Int, z: Int): Int = {
    x + y + z
  }

  def main(args: Array[String]): Unit = {
    val sumFun = sum(_, _, _)
    println(sumFun(1, 2, 3))
  }
}

1
2
3
4
5
6
7
8
9
10
11
object Hello {

  def sum(x: Int, y: Int, z: Int): Int = {
    x + y + z
  }

  def main(args: Array[String]): Unit = {
    val sumFun = sum(_: Int, _: Int, 6)
    println(sumFun(2, 4))
  }
}

1
2
3
4
5
6
7
8
def operate2Int(x: Int, y: Int,
                opera: (Int, Int) => Int): Int = {
    opera(x, y)
}

val add = (x: Int, y: Int) => x + y

println(operate2Int(5, 1, add))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def opt2NumFun(funName: String): (Int, Int)=>Int = {
    funName match {
        case "add" => (x, y) => x + y
        case "sub" => (x, y) => x - y
        case "mul" => (x, y) => x * y
        case "div" => (x, y) => x / y
        case _ => (_, _) => 0
    }
}

println(opt2NumFun("add")(5, 1))
println(opt2NumFun("sub")(10, 5))
println(opt2NumFun("mul")(3, 10))
println(opt2NumFun("div")(30, 3))

1
2
3
4
5
6
7
8
9
def opt2NumFun(funName: String): (Int, Int)=>Int = {
    funName match {
        case "add" => _ + _
        case "sub" => _ - _
        case "mul" => _ * _
        case "div" => _ / _
        case _ => (_, _) => 0
    }
}

1
2
val add = (_:Int) + (_:Int)
println(add(10, 1))

1
2
3
4
5
6
7
8
def opt3Num(func: (Int, Int, Int) => Int,
            x: Int, y: Int, z: Int): Int = {
  func(x, y, z)
}

println(opt3Num(_ + _ + _, 1, 3, 4))
println(opt3Num(_ + _ * _, 1, 2, 5))
println(opt3Num(_ / _ / _, 30, 10, 3))

1
2
3
4
val opt3Num = (_:(Int, Int, Int)=>Int)(_: Int, _: Int, _: Int)
println(opt3Num(_ + _ + _, 1, 3, 4))
println(opt3Num(_ + _ * _, 1, 2, 5))
println(opt3Num(_ / _ / _, 30, 10, 3))

1
2
3
4
5
6
7
8
9
10
def add(nums: Int*): Int = {
    var sum = 0
    for (num <- nums) {
        sum += num
    }
    sum
}

println(add(1, 2, 3))
println(add(4, 5, 6, 7, 8))

1
2
3
4
5
6
7
8
9
10
11
12
def foo(x: Int, sum: Int): Int = {
    if (sum > 100 || x > 100) {
        sum
    }
    else if (x % 2 == 0) {
        foo(x + 1, sum)
    }
    else {
        foo(x + 1, sum + x)
    }
}
println(foo(1, 0))

1
2
3
4
5
def addAndPrint(num1: Int, num2: Int, pf: (Int)=>Unit): Unit = {
    val sum = num1 + num2
    pf(sum)
}
addAndPrint(5, 7, println)

1
2
3
4
5
6
def addAndPrint(num1: Int, num2: Int)(pf: (Int)=>Unit): Unit = {
    val sum = num1 + num2
    pf(sum)
}

addAndPrint(5, 7)(println)

1
2
3
addAndPrint(10, 12) {
    println(_)
}

1
2
3
4
5
6
7
val li = List(1, 3, 5, 10)

li.foreach {
    (num: Int)=> {
        println(num + 10)
    }
}

1
2
3
4
5
val li = List(1, 3, 5, 10)

li.foreach {
    println(_)
}

1
2
3
4
5
6
7
8
9
10
11
class Person {
  def eat(): Unit = {
    println("吃饭饭")
  }
}

object Person {
  def sleep(): Unit = {
    println("睡觉觉")
  }
}

1
2
3
Person.sleep()
val p = new Person
p.eat()

1
2
3
class class_name [(construct_list)] {
    class_body
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
object Test {
  def main(args: Array[String]): Unit = {
    val p = new Person("zhang", 20)
    p.show()
  }
}

class Person (name: String, age: Int) {

  println("construct a person")

  def show(): Unit = {
    println("name = " + name + ",age = " + age)
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
object Test {
  def main(args: Array[String]): Unit = {
    val p1 = new Person()
    val p2 = new Person("zhang")
  }
}

class Person (name: String, age: Int) {

  def this() {
    this("default", 0)
    println("call this()")
  }

  def this(name: String) {
    this(name, 0)
    println("call this(String)")
  }

  println("construct a person")
}

1
2
3
4
5
6
7
8
9
10
11
class Fruit {
  def eat(): Unit = {
    println("吃水果")
  }
}

class Apple extends Fruit {
  override def eat(): Unit = {
    println("吃苹果")
  }
}

1
2
3
4
5
6
7
8
9
10
object Test {
  def main(args: Array[String]): Unit = {
    val apple = new Apple
    println(apple)
  }
}

class Apple {
  override def toString: String = "一个小苹果"
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
object Test {
  def main(args: Array[String]): Unit = {
    val p = new Person
    println(p.say1)
    println(p.say2())
    println(p.say3)

  }
}

class Person {
  def say1 = "LOL"

  // 以上写法和以下一样
  def say2(): String = {
    "LOL"
  }

  // 也和下面的一样
  val say3 = "LOL"
}

1
2
3
4
5
6
7
8
9
package cn {
    package lazycat {
        // 此处的包为cn.lazycat
    }

    package hi {
        // 此处的包为cn.hi
    }
}

1
import java.util.{List, Map}

1
import java.util.{SimpleDataFormat => Sdf}

1
val s: Sdf = null

1
private [cn.hhh] val f: String

1
2
3
4
5
6
7
8
abstract class Fruit {
  def eat()  // 这是一个抽象方法,子类如果不是抽象类,必须实现
  def get(): Unit = println("得到了一个水果!")
}

class Apple extends Fruit {
  override def eat(): Unit = println("吃了一个苹果")
}

1
2
3
4
5
6
7
8
9
10
11
12
object Test {
  def main(args: Array[String]): Unit = {
    val r = new Teacher("Tang")
    println(r)
  }
}

class Person (name: String)

class Teacher (name:String) extends Person(name) {
  override def toString: String = "teacher's name = " + name
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
object Test {
  def main(args: Array[String]): Unit = {
    val f1: Fruit = new Apple
    val f2: Fruit = new Orange
    f1.eat()
    f2.eat()
  }
}

abstract class Fruit {
  def eat()
}

class Apple extends Fruit {
  override def eat(): Unit = println("吃苹果")
}

class Orange extends Fruit {
  override def eat(): Unit = println("吃橘子")
}

1
2
3
final class class_name {
    ...
}

1
val p: Person = null

1
val i: Int = null  // 错误!!!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
trait Eatable {
  def eat()
}

trait Walkable {
  def walk(): Unit = println("走路!")
}

abstract class Person {
  def talk()
}

class Student extends Person with Eatable with Walkable {
  override def talk(): Unit = println("学生说话啦!")
  override def eat(): Unit = println("学生吃饭啦!")
}

object Test {
  def main(args: Array[String]): Unit = {
    val student: Student = new Student
    val eat: Eatable = student
    val walk: Walkable = student
    val person: Person = student

    eat.eat()
    walk.walk()
    person.talk()
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 定义一个长度为3的数组
val arr1 = new Array[String](3)

// 直接初始化数组
val arr2 = Array[String]("abc", "123", "456")

// 不声明泛型,可以存放不同类型的数据
val arr3 = Array("a", 1, 3, 9.0, "b")

// 访问数组使用小括号
println(arr3(2))

// 遍历数组
for (str <- arr2) {
    println(str)
}

// 修改元素
arr1(1) = "niubi"
println(arr1(1))

1
2
3
4
5
6
7
val arr1 = Array[Int](1, 2, 3, 4)
val arr2 = Array[Int](5, 6, 7)

val arr3 = Array.concat(arr1, arr2)
arr3.foreach {
    println(_)
}

1
2
val list1 = List(2, 3, 5)
val list2 = "a" :: "b" :: "c" :: "d" :: "e" :: Nil

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
val list1 = List(2, 3, 5)
val list2 = "a" :: "b" :: "c" :: "d" :: "e" :: Nil

println(list2(2))
println(list2.head)
println(list2.tail)
println(list1.sum)

// 连接链表
val list3 = list1 ::: list2
println(list3)

// 向后插入元素
val list4 = list2 :+ "f"
println(list4)

// 向前插入元素
val list5 = "z" +: list2
println(list5)

// 删除元素
val list6 = list2.drop(1)
println(list6)

// 修改元素
val list7 = list2.updated(2, "a")
println(list7)

1
2
3
4
5
val buffer = ArrayBuffer(4, 1, 4)
buffer.append(10, 20)

val arr = buffer.toArray
println(arr)

1
2
3
4
val r = 1 to 10
val list = r.toList

println(list)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// 创建Map
val m1 = Map(1 -> "zhang", 2 -> "Li", 3 -> "Wang")

// 追加元素
val m2 = m1 + (4 -> "Zhao")
println(m2)

// 删除元素
val m3 = m1 - 2
println(m3)

// 获取元素
println(m1.getOrElse(1, null))

// 遍历Map
for (key <- m1.keySet) {
    println(key + "," + m1.getOrElse(key, null))
}

// 或
val ite = m1.iterator
for (t <- ite) {
    println(t._1 + "," + t._2)
}

// 或
m1.foreach(t => println(t._1 + "," + t._2))

1
2
3
4
5
6
val l1 = List(1, 2, 3)
val l2 = List("a", "b", "c")

val map = l1.zip(l2).toMap

println(map)

1
2
3
4
5
val t = (1, "a", "b", 200)
println(t._1)
println(t._2)
println(t._3)
println(t._4)

1
2
3
lazy val str = "hello"
...           // 此处没有分配空间
println(str)  // 此处为str分配了空间

1
2
3
4
5
6
7
8
9
10
11
def div(x: Double, y: Double): Option[Double] = {
    if (y == 0) {
        None
    }
    else {
        Some(x / y)
    }
}

println(div(20.0, 10.0).getOrElse(0.0))
println(div(10.0, 0).getOrElse(0.0))

1
2
3
4
5
6
7
8
9
10
object Test {
  def main(args: Array[String]): Unit = {
    val p: Person = Person("zhang")
    println(p.getName)
  }
}

case class Person (name: String) {
  def getName: String = name
}