Scala基础语法概览

变量和常量

在Scala中，变量使用关键字 var 声明，而常量使用关键字 val 声明。变量的值可以被修改，而常量一旦被赋值后就无法再改变。

// 变量
var x: Int = 10
x = 20 // 合法

// 常量
val y: String = "Hello"
// y = "World" // 非法，常量值不能被修改

数据类型

Scala中有丰富的数据类型，这些类型可以分为两大类：基本数据类型和引用数据类型。以下是Scala中的主要数据类型：

基本数据类型

整数类型

• Byte: 8位有符号整数，范围为-128到127。
• Short: 16位有符号整数，范围为-32768到32767。
• Int: 32位有符号整数，范围为-2147483648到2147483647。
• Long: 64位有符号整数，范围为-9223372036854775808到9223372036854775807。

浮点数类型

• Float: 32位浮点数。
• Double: 64位浮点数。

字符类型

• Char: 16位无符号Unicode字符。

布尔类型

• Boolean: 表示true或false。

引用数据类型

字符串类型

• String: 字符串类型，由字符组成。

数组类型

• Array: 数组，可以包含相同类型的元素。

列表类型

• List: 不可变列表，可以包含不同类型的元素。

元组类型

• Tuple: 不同类型的元素的有序集合。

集合类型

• Set: 不可变集合，不包含重复元素。
• Map: 不可变映射，由键值对组成。

选项类型

• Option: 表示可能存在或可能不存在的值。

类类型

• 自定义类和对象。

函数类型

• 函数是一等公民，可以作为参数传递、作为返回值等。

这些数据类型使得Scala具有强大的表达能力和灵活性，同时支持面向对象和函数式编程。在编写Scala代码时，根据具体的需求选择适当的数据类型是非常重要的。

运算符

算术运算符

Scala支持基本的算术运算符，包括加法、减法、乘法、除法和取余。

val sum = 10 + 5
val difference = 10 - 5
val product = 10 * 5
val quotient = 10 / 5
val remainder = 10 % 3

赋值运算符

Scala中的赋值运算符使用 =，但可以与其他运算符组合成复合赋值运算符。

var a = 10
a += 5 // 相当于 a = a + 5

比较运算符

比较运算符用于比较两个值的关系，返回布尔值。

val isEqual = (a == b)
val isNotEqual = (a != b)
val greaterThan = (a > b)
val lessThan = (a < b)
val greaterOrEqual = (a >= b)
val lessOrEqual = (a <= b)

逻辑运算符

逻辑运算符用于组合多个条件，返回布尔值。

val andResult = (condition1 && condition2)
val orResult = (condition1 || condition2)
val notResult = !condition

位运算符

Scala支持按位运算符，如按位与（&）、按位或（|）、按位异或（^）等。

移位运算符

移位运算符用于将二进制位向左或向右移动。

val leftShift = value << 2 // 左移两位
val rightShift = value >> 2 // 右移两位

运算符优先级

Scala中的运算符有不同的优先级，可以使用括号来明确运算顺序。

在Scala中，运算符的优先级决定了表达式中运算符执行的顺序。以下是Scala中一些常见运算符的优先级，从高到低：

1. 一元运算符：
   

• -（负号）、+（正号）、!（逻辑非）等。

2. 算术运算符：
   

• *、/、%（取余）。
• +、-。

3. 关系运算符：
   

• <、<=、>、>=。
• ==、!=。

4. 逻辑运算符：
   

• &&（逻辑与）。
• ||（逻辑或）。
• !（逻辑非）。

5. 位运算符：
   

• &（按位与）。
• |（按位或）。
• ^（按位异或）。

6. 移位运算符：
   

• <<（左移位）。
• >>（带符号右移位）。
• >>>（无符号右移位）。

7. 赋值运算符：
   

• =（简单赋值）。
• +=、-=、*=、/=、%=等（复合赋值运算符）。

8. 三元运算符：
   

• condition ? expr1 : expr2（Scala中没有三元运算符 ?:，而是使用 if-else 结构）。

在表达式中，可以使用括号 () 来明确运算符的优先级，确保表达式按照预期的顺序进行计算。例如，2 + 3 * 4 中，* 的优先级更高，因此先执行乘法，然后再加法。

val result = 2 + 3 * 4 // 结果为 14

条件表达式

在Scala中，条件语句主要由 if-else 结构构成，但还有其他一些变种和附加的功能。以下是Scala中的条件语句的详细描述：

1. 基本的 if-else 结构

val x = 10

if (x > 5) {
  println("x 大于 5")
} else {
  println("x 小于或等于 5")
}

2. 表达式作为条件

Scala中的 if-else 结构是表达式，因此可以将其结果赋值给变量。

val result = if (x > 5) "大于 5" else "小于或等于 5"
println(result)

3. 多个条件

可以使用 else if 在 if-else 结构中添加多个条件。

val score = 75

if (score >= 90) {
  println("优秀")
} else if (score >= 70) {
  println("良好")
} else if (score >= 60) {
  println("及格")
} else {
  println("不及格")
}

4. 嵌套的 if-else 结构

条件语句可以嵌套在其他条件语句中，形成嵌套的 if-else 结构。

val a = 5
val b = 10

if (a > 0) {
  if (b > 0) {
    println("a 和 b 都大于 0")
  } else {
    println("a 大于 0，但 b 不大于 0")
  }
} else {
  println("a 不大于 0")
}

5. 模式匹配（Match表达式）

Scala中的模式匹配可以看作是一种更强大和灵活的条件语句。它允许对一个值进行模式匹配，从而执行相应的代码块。

val day = "Monday"

day match {
  case "Monday" => println("星期一")
  case "Tuesday" | "Wednesday" => println("星期二或星期三")
  case _ => println("其他")
}

6. if 表达式的后缀形式

if 表达式可以使用后缀形式，将 if 放在条件之后。

val result = "Hello" if (result.length > 5) "Long" else "Short"
println(result)

循环语句

在Scala中，主要有 for 循环和 while 循环两种基本的循环语句，同时还有一些其他高级的迭代方法。以下是对这些循环语句的详细描述：

1. for 循环

基本形式

for 循环可以遍历集合（如数组、列表等）中的元素。

val numbers = List(1, 2, 3, 4, 5)

for (num <- numbers) {
  println(num)
}

使用 to 和 until 运算符创建范围

for (i <- 1 to 5) {
  println(i)
}

for (j <- 1 until 5) {
  println(j)
}

循环嵌套

for 循环支持嵌套。

for (i <- 1 to 3) {
  for (j <- 1 to 3) {
    println(s"($i, $j)")
  }
}

2. while 循环

while 循环会在条件为真时一直执行。

var i = 0

while (i < 5) {
  println(i)
  i += 1
}

3. do-while 循环

do-while 循环至少会执行一次，然后在条件为真时重复执行。

var j = 0

do {
  println(j)
  j += 1
} while (j < 5)

4. foreach 方法

对于集合类，可以使用 foreach 方法进行迭代。

val fruits = List("Apple", "Banana", "Orange")

fruits.foreach(fruit => println(fruit))

5. for-yield 表达式

for-yield 表达式用于生成一个新的集合，通过对现有集合的元素进行转换。

val numbers = List(1, 2, 3, 4, 5)

val squaredNumbers = for (num <- numbers) yield num * num

println(squaredNumbers) // 输出 List(1, 4, 9, 16, 25)

6. 高级迭代方法

Scala提供了一些高级的迭代方法，如 map、filter、reduce 等，用于对集合进行函数式的操作。

val numbers = List(1, 2, 3, 4, 5)

val doubledNumbers = numbers.map(_ * 2)
val evenNumbers = numbers.filter(_ % 2 == 0)
val sum = numbers.reduce(_ + _)

println(doubledNumbers) // 输出 List(2, 4, 6, 8, 10)
println(evenNumbers)    // 输出 List(2, 4)
println(sum)            // 输出 15

以上是Scala基础语法的简要概述。Scala是一门强大而灵活的语言，具有面向对象和函数式编程的特性，让程序员能够以简洁的方式表达复杂的逻辑。希望这篇博客对初学者有所帮助！