Scala

Scala

介绍

Scala是一种多规范的编程语言，它结合了面向对象编程（OOP）和函数式编程（FP）的特征，Scala的名字源于”Scalable language“，意为”可伸缩语言“。2003年开发的，并在JVM（Java虚拟机）上运行的，Scala被设计用于编程简介高效的代码的同时提供强大的表达能力和灵活性。

特点

• 面向对象和函数式编程支持：
  • Scala支持面向对象的编程范式，同时也强调函数式编程，允许开发者以更函数式的方式思考和编写代码，从而更好地处理并发和异步编程等问题。
• 静态类型：
  • Scala是一门静态类型语言，可以在编译时捕获一些错误，提高代码的稳定性和可维护性。
• 表达力强：
  • Scala提供了丰富的语法特性，可以用更少的代码表达更多的概念，从而增强代码的可读性和可理解性。
• 互操作性：
  • Scala可以与Java无缝集成，可以直接调用Java类库和组件，这对于现有的Java开发者来说是一个优势，也使得在已有的Java项目中引入Scala逐步过渡变得容易。
• 并发支持：
  • Scala通过其函数式编程特性，提供了更好的并发编程支持，例如使用不可变数据结构和并行集合来简化多线程编程。

为什么学习

• 丰富的编程范式：
  • 学习Scala可以让你同时了解面向对象和函数式编程的特性，从而能够更灵活地选择适合不同情境的编程方式。
• 并发和多线程编程：
  • Scala在并发编程方面提供了强大的支持，这在处理现代应用中的并发性和异步编程方面非常有用。
• 表达能力：
  • Scala的语法特性允许你以更简洁的代码表达复杂的概念，提高代码的可读性和可维护性。
• JVM平台：
  • Scala运行在Java虚拟机上，因此可以与Java代码互操作，适合在现有的Java项目中引入。Scala可以直接调用Java中的方法，访问Java中的字段，继承java类，实现Java接口。
• 函数式思维：
  • 学习Scala可以培养函数式编程思维，这对于提高编程的抽象能力、模块化能力和问题解决能力都很有帮助。

总之，学习Scala可以让你拥有多规范编程的能力，从而更好的应对复杂的软件开发任务，尤其是在并发编程和大规模的应用开发方面。

数据类型

运算符

案例

scala> "hello scala"
res0: String = hello scala

scala> 1+1
res1: Int = 2
1
2
3
4
5

变量，常量

创建变量方式

var 变量名称: 数据类型 = 变量值;
1

例如

# 创建变量count,数据类型为Int类型，初始值为10
scala> var count:Int=10;
count: Int = 10
# 输入count变量，返回变量值
scala> count
res0: Int = 10
# 对count变量重新赋值
scala> count=1;
count: Int = 1

scala> count
res1: Int = 1
1
2
3
4
5
6
7
8
9
10
11
12

创建常量的方式

val 常量名称：数据类型 = 常量值
1

例如

# 创建常量name,数据类型为String,常量值为zhangsan
scala> val name:String = "zhangsan";
name: String = zhangsan
# 输入name常量，返回常量值
scala> name
res3: String = zhangsan
# 对常量name重新赋值时，编译错误，常量无法重新赋值
scala> name = "lisi";
<console>:12: error: reassignment to val
       name = "lisi";
1
2
3
4
5
6
7
8
9
10

函数

使用关键字def来定义函数，函数定义语法为：

def 函数名称(参数列表)：返回类型={
	//函数体
	//可以包含多条一句
	//最后一行的表达式作为返回值
}
1
2
3
4
5

无参函数

# 定义函数sayHello,Unit:表示无值，等同于Java中的void 
scala> def sayHello():Unit={
     | println("Hello,Scala!");//打印：Hello,Scala!
     | }
sayHello: ()Unit
# 调用函数
scala> sayHello()
Hello,Scala!
1
2
3
4
5
6
7
8

有参函数

# 定义函数add,参数为x(Int整数类型),y(Int整数类型),返回类型为Int
scala> def add(x:Int,y:Int):Int={
     | x+y;
     | }
add: (x: Int, y: Int)Int
# 调用函数，传入实参
scala> val result = add(10,10)
result: Int = 20

scala> result
res8: Int = 20
1
2
3
4
5
6
7
8
9
10
11

默认参数函数

# 定义函数greet，参数为name（String字符串类型），greeting（String字符串类型，默认值为Hello）
scala> def greet(name:String,greeting:String="Hello"):Unit={
     | println(s"$greeting,$name");//插值语法
     | }
greet: (name: String, greeting: String)Unit

scala> greet("zhangsan");
Hello,zhangsan

scala> greet("lisi","Hi");
Hi,lisi
1
2
3
4
5
6
7
8
9
10
11

可变参数函数

# 定义函数sum，参数为number(Int整数类型，*多个值)
scala> def sum(number:Int*):Int = {
     | number.sum; //参数的和
     | }
sum: (number: Int*)Int

scala> println(sum(1,2,3,4,5,6));
21
1
2
3
4
5
6
7
8

匿名函数（lambda表达式）

# 定义函数add，参数为x(Int整数类型),y(Int整数类型),返回类型为Int
scala> val add:(Int,Int)=> Int=(x,y)=>x+y
add: (Int, Int) => Int = <function2>

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

if判断

语法

if(布尔表达式){
	//执行条件为true时的代码块
}else{
	//执行条件为false时的代码块
}
1
2
3
4
5

例如

scala> val x = 10;
x: Int = 10

scala> if (x>5){
     | println("x大于5");
     | }else{
     | println("x小于5");
     | }
x大于5
1
2
3
4
5
6
7
8
9

for循环

语法

for（变量 <- 初始值 to 结束值）{
	//循环体
}
1
2
3

例如

# 循环从1输出到5
scala> for(i <- 1 to 5){
     | println(i);
     | }
1
2
3
4
5
1
2
3
4
5
6
7
8
9

数组

创建数据的方式

var 数据名称 : Array[数据类型] = new Array[数据类型](数组长度)
var 数组名称 : Array[数据类型] = Array(元素1,元素2......) 
var 数组名称 : Array.ofDim[数据类型](数组长度)
1
2
3

操作数组常用的方式

例如

# 第一种创建方式
scala> var arr: Array[String] = new Array[String](3)
arr: Array[String] = Array(null, null, null)
# 数组的长度
scala> arr.length
res0: Int = 3
# 对索引1的元素赋值
scala> arr(1)="zhangsan"
# 查看索引1的元素
scala> arr(1)
res2: String = zhangsan
# 查看索引0的元素
scala> arr(0)
res3: String = null
# 查看数组
scala> arr
res4: Array[String] = Array(null, zhangsan, null)


# 第二种创建方式
scala> var arr1 : Array[Int] = Array(1,2,3,4)
arr1: Array[Int] = Array(1, 2, 3, 4)
# 数组长度
scala> arr1.length
res6: Int = 4
# 索引处的元素值
scala> arr1(2)
res7: Int = 3
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

List列表

在Scala中，List是一个常用的数据结构，用于存储有序的元素序列。List是不可变的，意味着一旦创建就不能修改，但可以通过创建新的List来进行操作和转换

语法

val 列表名称:List[列表类型] = List(列表元素);
1

例如

scala> val list:List[String] = List("zhangsan","lisi","wangwu");
list: List[String] = List(zhangsan, lisi, wangwu)

scala> val ageList:List[Int] = List(18,29,38,10);
ageList: List[Int] = List(18,29,38,10)
1
2
3
4
5

列表常用方法

案例

定义数组

scala> val ageList:List[Int] = List(18,28,39,40,12,32,21);
ageList: List[Int] = List(18, 28, 39, 40, 12, 32, 21)
1
2

• 访问元素

# 获取第一个元素
scala> ageList.head
res7: Int = 18

# 获取除第一个元素外的所有元素
scala> ageList.tail
res8: List[Int] = List(28, 39, 40, 12, 32, 21)

# 获取最后一个元素
scala> ageList.last
res9: Int = 21

# 获取除最后一个元素外的所有元素
scala> ageList.init
res10: List[Int] = List(18, 28, 39, 40, 12, 32)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 添加元素

# 在列表开头添加元素
scala> 80::ageList
res11: List[Int] = List(80, 18, 28, 39, 40, 12, 32, 21)

# 在列表末尾添加元素
scala> ageList :+ 90
res12: List[Int] = List(18, 28, 39, 40, 12, 32, 21, 90)

# 连接两个列表
scala> ageList ++ List(70,60)
res13: List[Int] = List(18, 28, 39, 40, 12, 32, 21, 70, 60)
1
2
3
4
5
6
7
8
9
10
11

• 修改元素

# 更新0索引位置的元素为43
scala> ageList.updated(0,43)
res15: List[Int] = List(43, 28, 39, 40, 12, 32, 21)

# 替换一部分元素，将索引1，2位置的值替换
scala> ageList.patch(1,List(31,42),2)
res16: List[Int] = List(18, 31, 42, 40, 12, 32, 21)
1
2
3
4
5
6
7

• 遍历列表

# 对列表的每个元素应用函数进行遍历打印
scala> ageList.foreach(println);
18
28
39
40
12
32
21

# 将列表中的每个元素平方
scala> ageList.map(x => x * x)
res19: List[Int] = List(324, 784, 1521, 1600, 144, 1024, 441)

# 过滤出偶数元素
scala> ageList.filter(_%2 == 0)
res20: List[Int] = List(18, 28, 40, 12, 32)

# 计算列表元素的累加和
scala> ageList.foldLeft(0)(_+_)
res21: Int = 190
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

• 判断列表

# 判断列表是否为空
scala> ageList.isEmpty
res22: Boolean = false

# 判断列表是否包含40
scala> ageList.contains(40)
res25: Boolean = true

# 判断列表是否存在偶数元素
scala> ageList.filter(_%2==0)
res26: List[Int] = List(18, 28, 40, 12, 32)

# 判断列表中的所有元素是否都为正数
scala> ageList.forall(_>0)
res2: Boolean = true
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 删除元素

# 根据条件过滤元素
scala> ageList.filter(_%2 == 0)
res3: List[Int] = List(18, 28, 40, 12, 32, 70, 60)

# 删除前两个元素
scala> ageList.drop(2)
res4: List[Int] = List(39, 40, 12, 32, 21, 70, 60)

# 删除小于30的前缀元素
scala> ageList.dropWhile(_<30)
res6: List[Int] = List(39, 40, 12, 32, 21, 70, 60)

# 删除后两个元素
scala> ageList.dropRight(2)
res7: List[Int] = List(18, 28, 39, 40, 12, 32, 21)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Set集合

在Scala中，集合（Set）是一个用于存储不重复元素的无序集合

语法

# Scala默认创建的时不可变集合
val 集合名称: Set[数据类型] = Set(集合元素)

# 创建一个可变集合
import scala.collection.mutable.Set
val 集合名称: Set[数据类型] = Set(集合元素)

# 创建一个不可变集合
import scala.collection.immutable.Set
val 集合名称: Set[数据类型] = Set(集合元素)
1
2
3
4
5
6
7
8
9
10

集合常用的方法

例如

定义集合

# 定义为可变
scala> import scala.collection.mutable.Set;
import scala.collection.mutable.Set

scala> val nameSet:Set[String] = Set("张三","李四","王五")
nameSet: scala.collection.mutable.Set[String] = Set(李四, 张三, 王五)
1
2
3
4
5
6

• 添加元素

scala> nameSet.add("赵六")
res10: Boolean = true

scala> nameSet
res11: scala.collection.mutable.Set[String] = Set(李四, 张三, 王五, 赵六)

scala> nameSet+"老王"
res12: scala.collection.mutable.Set[String] = Set(老王, 李四, 张三, 王五, 赵六)

1
2
3
4
5
6
7
8
9

• 删除元素

scala> nameSet.remove("张三")
res14: Boolean = true

scala> nameSet
res15: scala.collection.mutable.Set[String] = Set(李四, 王五, 赵六)

scala> nameSet - "李四"
res16: scala.collection.mutable.Set[String] = Set(王五, 赵六)

1
2
3
4
5
6
7
8
9

• 判断集合是否包含某个元素

scala> nameSet.contains("赵六")
res17: Boolean = true
1
2

• 遍历集合

scala> nameSet.foreach(println)
李四
王五
赵六
1
2
3
4

Map映射

在Scala中，映射（Map）是一种键值对的集合，其中每个键都唯一且与一个值相关联

语法

# Scala默认创建的时不可变映射
val 映射名称:Map[键的数据类型，值的数据类型] = Map(键->值)

# 创建可变映射
import scala.collection.mutable
val 映射名称:Map[键的数据类型，值的数据类型] = Map(键->值)

1
2
3
4
5
6
7

常用的方法

例如

定义映射

scala> import scala.collection.mutable
import scala.collection.mutable

scala> val nameMap:Map[String,Int] = Map("张三"->28,"李四"->29,"王五"->30)
nameMap: Map[String,Int] = Map(张三 -> 28, 李四 -> 29, 王五 -> 30)
1
2
3
4
5

• 获取所有键或所有值

scala> nameMap.keys
res20: Iterable[String] = Set(张三, 李四, 王五)

scala> nameMap.values
res22: Iterable[Int] = MapLike(28, 29, 30)
1
2
3
4
5

• 检查是否包含某个建或值

scala> nameMap.contains("张三")
res23: Boolean = true

scala> nameMap.values.exists(_==28)
res24: Boolean = true
1
2
3
4
5

• 迭代Map

scala> nameMap.foreach{
     | case (key,value) => println(s"Key:$key,Value:$value")
     | }
Key:张三,Value:28
Key:李四,Value:29
Key:王五,Value:30
1
2
3
4
5
6

• 转换为列表

scala> nameMap.toList
res27: List[(String, Int)] = List((张三,28), (李四,29), (王五,30))
1
2

• 更新Map中的值

scala> nameMap.updated("王五",20)
res28: scala.collection.immutable.Map[String,Int] = Map(张三 -> 28, 李四 -> 29, 王五 -> 20)

1
2
3

• 删除键值对

scala> nameMap-"王五"
res29: scala.collection.immutable.Map[String,Int] = Map(张三 -> 28, 李四 -> 29)
1
2

元组

在Scala中，元组（Tuple）时一种类似于列表的结构，是一种不同类型的值的集合

语法

val 元组名称 = (元组元素);
// Tuple3中的3元组即元组中包含了3个元素，若定义的时N元组，写成Tuplen
val 元组名称 = new Tuple3(元素元素);
1
2
3

例如

scala> val tuple = (1,"hello",true);
tuple: (Int, String, Boolean) = (1,hello,true)

scala> val tuple1 = new Tuple3(2,"Hi",3.14)
tuple1: (Int, String, Double) = (2,Hi,3.14)
1
2
3
4
5

• 获取元素

_N：通过索引获取元素的第N个元素，索引从1开始

scala> tuple._1
res30: Int = 1

scala> tuple._2
res31: String = hello

scala> tuple._3
res32: Boolean = true
1
2
3
4
5
6
7
8

• 转换为列表

scala> tuple.productIterator.toList
res33: List[Any] = List(1, hello, true)
1
2

• 合并元组

scala> tuple ++ tuple1
scala> Tuple.concat(tuple,tuple1)
1
2

关键字

• Unit ：表示无值，等同于Java中的void

• abstract：抽象类、抽象方法

• case：模式匹配中的一个分支

• class：类定义

• def：方法/函数定义

• do：do-while循环的开始

• else：if条件的分支

• extends：类的继承

• false：布尔值false

• final：不可继承、重写或修改的修饰符

• for：for循环

• if：条件语句

• implicit：隐式转换

• import：导入其他包或类

• match：模式匹配

• new：创建对象

• null：空值

• object：单例对象或伴生对象

• override：重写父类或特质中的方法

• package：包定义

• private：私有访问权限

• protected：受保护的访问权限

• return：返回值

• sealed：密封类

• super：父类引用

• this：当前类或对象的引用

• throw：抛出异常

• trait：特质定义

• true：布尔值true

• try：异常处理

• type：类型别名

• val：不可变变量声明

• var：可变变量声明

• while：while循环

• with：混入特质

• yield：生成器