Scala快速入门 - 基础语法篇

本篇文章首发于头条号Scala快速入门 - 基础语法篇，欢迎关注我的头条号和微信公众号“大数据技术和人工智能”（微信搜索bigdata_ai_tech）获取更多干货，也欢迎关注我的CSDN博客。

---

Scala是一门多范式编程语言，集成了面向对象和函数式语言的特性。本篇文章将以代码示例的形式简单介绍一下Scala语言的基础语法。

声明值和变量

// val声明的变量是不可变的
val str1 = "Hello World!"
val str2 : String = "Hello World!"
val str3 : java.lang.String = "Hello World!"

println(str1)
println(str2)
println(str3)

// var声明的变量是可变的
var str5 = "Hello World!"
str5 = "str5 Hello World!"

println(str5)

基本数据类型

Scala的数据类型包括：Byte、Char、Short、Int、Long、Float、Double和Boolean。在Scala中，这些类型都是“类”，并且都是包scala的成员，比如，Int的全名是scala.Int。对于字符串，Scala用java.lang.String类来表示字符串。

Scala的字面量包括：整数字面量、浮点数字面量、布尔型字面量、字符字面量、字符串字面量、符号字面量、函数字面量和元组字面量。举例如下：

val i = 123      //123就是整数字面量
val i = 3.14     //3.14就是浮点数字面量
val i = true     //true就是布尔型字面量
val i = 'A'      //'A'就是字符字面量
val i = "Hello"  //"Hello"就是字符串字面量

// Scala允许对“字面量”直接执行方法
5.toString()            //产生字符串"5"
"abc".intersect("bcd")  //输出"bc"

操作符

Scala的常用操作符：加(+)、减(-) 、乘(*) 、除(/) 、余数（%）、大于(>)、小于(<)、大于等于(>=)和小于等于(<=)等，这些操作符就是方法。

Scala的操作符就是方法，a 方法 b和a.方法(b)是等价的，前者是后者的简写形式，这里的+是方法名，是Int类中的一个方法。

// 下面三种写法的输出结果都是8
val sum1 = 5 + 3
val sum2 = (5).+(3)
val sum2 = 5.+(3)

控制结构

if条件表达式

val x = 6
if (x > 0) {
    println("x = " + x)
} else {
    println("x = " + x)
}

val x = 3
if (x > 0) {
    println("x = " + x)
} else if (x == 0) {
    println("x = 0")
} else {
    println("x = " + x)
}

// Scala中的if表达式的值可以赋值给变量
val a = if (x > 0) 1 else -1

while循环

var i = 9
while (i > 0) {
    i -= 1
    printf("i is %d\n", i)
}

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

for循环

// for Range
// Range可以是一个数字区间表示 i to j ，或者 i until j，左箭头 <- 用于为变量 x 赋值。
for (a <- 1 to 10) {
   println("a = " + a);
}
for (a <- 1 until 10) {
   println("a = " + a);
}
for( a <- 1 to 3; b <- 1 to 3){
   println( "a = " + a );
   println( "Value of b: " + b );
}

// 循环集合
var a = 0;
val numList = List(1, 2, 3, 4, 5, 6);
for (a <- numList) {
   println("a = " + a);
}

// 循环过滤
var a = 0;
val numList = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
for (a <- numList if a != 3; if a < 8) {
   println("a = " + a);
}

// 使用yield
// 大括号中用于保存变量和条件，retVal是变量，循环中的yield会把当前的元素记下来，保存在集合中，循环结束后将返回该集合。
var a = 0;
val numList = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
var retVal = for {
    a <- numList if a != 3; if a < 8
} yield a
for(a <- retVal) {
   println("a = " + a);
}

数组

定长数组，就是长度不变的数组，在Scala中使用Array进行声明，如下：

//声明一个长度为3的整型数组，每个数组元素初始化为0
val intValueArr = new Array[Int](3)
//在Scala中，对数组元素的应用，是使用圆括号，而不是方括号，也就是使用intValueArr(0)，而不是intValueArr[0]，这个和Java是不同的。
intValueArr(0) = 12
intValueArr(1) = 45
intValueArr(2) = 33

//声明一个长度为3的字符串数组，每个数组元素初始化为null
val strArr = new Array[String](3)
strArr(0) = "Flink"
strArr(1) = "Storm"
strArr(2) = "Spark"
for (i <- 0 to 2) println(strArr(i)) 

//Scala提供了更加简洁的数组声明和初始化方法，如下：
val intValueArr = Array(12, 45, 33)
val strArr = Array("Flink", "Storm", "Spark")
//从上面代码可以看出，都不需要给出数组类型，Scala会自动根据提供的初始化数据来推断出数组的类型。

可变数组

可变数组需要导入包scala.collection.mutable.ArrayBuffer

//导入ArrayBuffer包
import scala.collection.mutable.ArrayBuffer

//定义一个可变的数组
val arr : ArrayBuffer[String] = new ArrayBuffer[String]()

//在末尾添加一个元素
arr += "Hadoop"
//在末尾添加多个元素
arr += ("Hive", "Hbase")
//在末尾添加一个集合
arr ++= ArrayBuffer("Scala", "Java")
//在指定位置添加元素
arr(1) = "spark"
arr.insert(1, "Flume")
arr.insert(1, "Kafka", "Kylin")
arr.insertAll(1, ArrayBuffer("Hello", "World"))
println(arr)

//更新元素
arr(1) = "insistent"
arr.update(2, "Java")
println(arr)

//获取指定元素
println(arr(1))
println(arr.apply(2))
println(arr.take(3))

//删除元素
arr -= "insistent"
//删除集合
arr -= ("Java", "Kafka")
arr.remove(1)
//从1处开始删掉三个
arr.remove(1, 3)
//从前往后移除n个元素
arr.trimStart(1)
//从后往前移除n个元素
arr.trimEnd(1)
println(arr)

//遍历数组
for (i <- arr) {
  print(i + " ")
}

//变长数组转成定长数组
arr.toArray
//定长数组转成变长数组
array.toBuffer