1. 初识Scala

背景

Scala是为相识决Java在函数式编程、类型推断、模式匹配等方面的不敷而诞生的。它提供了更简洁的语法、更强的类型系统和更丰富的函数式编程特性，使得开发者能够以更高效、更灵活的方式编写代码。在大数据框架spark中，大量使用了scala的语法，所以想看懂spark源码，需要先认识scala。
1. 简介

1.1 上风

• 弥补Java的不敷：
  Scala的创始人Martin Odersky在创建Scala时，对Java的一些特性感到不满，特别是Java在函数式编程方面的支持不敷。因此，他希望通过Scala来弥补这些不敷，提供一种更加灵活和强大的编程语言。
  
• 融合面向对象和函数式编程：
  Scala旨在融合面向对象编程和函数式编程的精髓。它集成了这两种编程风格的多种特性，使得开发者可以根据详细需求选择最符合的编程方式。这种多范式的特性使得Scala在处理复杂问题时更加灵活和高效。
  
• 提高开发效率和应用步调的可扩展性：
  Scala的计划初衷是提高开发效率和应用步调的可扩展性。通过提供简洁的语法和丰富的函数式编程特性，Scala使得开发者能够更加高效地编写代码。同时，Scala的并发编程支持和高效的通讯机制使得它在构建分布式系统时具有明显上风。
  
• 与Java平台无缝集成：
  Scala能够完全与Java举行互操纵，这意味着Scala步调可以轻松地调用Java库，同时Java步调也能无缝地使用Scala编写的代码。这一特性使得Scala能够充分使用Java平台的丰富资源和强大生态系统，为开发者提供了广阔的发展空间。
  
• 满足现代软件开发的需求：
  随着软件开发的不断发展，现代应用对于灵活性和性能的需求越来越高。Scala凭借其强大的表达能力和灵活性，在多个范畴都有广泛的应用，如大数据处理、Web开发、分布式系统等。这使得Scala成为了一种能够满足现代软件开发需求的编程语言。
  

2. 下载安装

2.1 安装jdk

scala底层是java，因此，使用scala需要先安装jdk 。java安装网上有很多教程，本文不再赘述，本文选择java版本为1.8 ，建议读者如果想跑文章中的步调选择同样的版本，避免出现意料之外的错误
2.2 下载安装Scala

• 官网下载scala（留意要和java版本对应） https://www.scala-lang.org/download/2.12.20.html
  
• 解压目次
  
• 设置环境变量(和java类似)
  
• win+r 输入cmd 打开命令行验证 输入scala
  
• idea导入插件：在idea插件市场搜刮scala, 下载对应插件
  

3. 基础语法

3.1 定义变量

1. //定义val 变量
2. scala> val name="张三"
3. name: String = 张三
5. scala> name="李四"
6. <console>:12: error: reassignment to val
7.        name="李四"
8.            ^
9. //定义var变量
10. scala> var name="张三"
11. name: String = 张三
13. scala> name="李四"
14. name: String = 李四

复制代码

从上面代码案例可以看到，定义变量有两种方式，当定义val 变量时，可以以为定义的是常量，该变量值不可变，当定义的是var 时候，变量为变量，值可以变。
可以看到，定义变量的时候，没有定义类型，scala会做类型推断，我们也可以显示定义变量类型，比如

1. scala> val name:String ="李四"
2. name: String = 李四

复制代码

留意：变量名后面需要跟上冒号，类型首字母必须是大写
3.1.2 定义String变量

这里留意：在定义String变量的时候，当变量值包罗双引号等特殊字符的时候，需要做转义

1. val str:String = "我是一个字符串"
2. val str2:String = "我是一个"字符串""
3. val str3:String = """我是一个"字符串""""
4. //可以直接使用三个双引号，当中可以包含所有信息，甚至换行符

复制代码

3.2 操纵符

基本和java一样, 操纵符的优先级和java一样
特殊：

• 不支持java中的三元操纵符(？：)，也不支持+±-
  
• scala中的所有操纵符实质上就是对象上的方法(函数)
  eg. val a = 1 a.+(1)
  
• scala中类的函数可以作为操纵符来举行操纵
  eg. 1 to 10 1.to(10)
  所有以字母或者数字开头的操纵符的优先级只比赋值操纵符高
  
• 基本上所有的操纵符都是左连接，但是以":"开头的操纵符是右连接的
  

3.3 表达式

1. scala> val ss:String = {
2.      |           print("asdasd")
3.      |           "112"
4.      |           }
5. asdasdss: String = 112

复制代码

scala表达式的返回值就是末了一行代码的执行效果
3.4 懒执行

关键词：lazy

1. lazy val price = 66.58

复制代码

在一开始定义的时候不会初始化值
而是在第一次调用的时候才去初始化
使用的场景比如：读取一些大文本文件的时候，可以定义lazy
3.5 range 关键字使用

在 Scala 中，Range 是一种用于表示整数序列的数据类型。你可以使用 to、until 和 by 等关键字或方法来创建和操纵范围（Range）。以下是一些常见的用法：

• 使用 to 关键字创建包罗竣事值的范围：
  

1. val range1 = 1 to 5  // 结果是：Range(1, 2, 3, 4, 5)

复制代码

• 使用 until 关键字创建不包罗竣事值的范围：
  

1. val range2 = 1 until 5  // 结果是：Range(1, 2, 3, 4)

复制代码

• 使用 by 关键字创建带有步长的范围：
  

1. val range3 = 1 to 10 by 2  // 结果是：Range(1, 3, 5, 7, 9)
2. val range4 = 10 to 1 by -2 // 结果是：Range(10, 8, 6, 4, 2)

复制代码

• 将范围转换为其他集合类型（如 List 或 Array）：
  

1. val listFromRange1 = range1.toList  // 结果是：List(1, 2, 3, 4, 5)
2. val arrayFromRange2 = range2.toArray // 结果是：Array(1, 2, 3, 4)

复制代码

• 遍历范围：
  

1. for (i <- range1) {
2.     println(i)
3. }
4. // 输出：
5. // 1
6. // 2
7. // 3
8. // 4
9. // 5

复制代码

• 范围的常用方法：
  

1. start：范围的起始值。
2. end：范围的结束值（对于 until 是不包含的结束值，但对于 to 是包含的）。
3. step：范围的步长（默认为 1）。
4. isEmpty：检查范围是否为空。
5. contains(elem)：检查范围是否包含某个元素。
7. val range = 1 to 5
8. println(range.start)    // 输出：1
9. println(range.end)      // 输出：5
10. println(range.step)     // 输出：1
11. println(range.isEmpty)  // 输出：false
12. println(range.contains(3)) // 输出：true

复制代码

4. 判断循环语句

4.1 判断

1. scala> val age=1
2. age: Int = 1
4. scala> if(age > 18) 1 else 0
5. res1: Int = 0
7. scala>if(age > 18) "adult" else 0
8. res3: Any = 0

复制代码

判断语句基本和java同等，这里重要有想分析两点:

• 第二个语句可以以为是scala的三目表达式
  
• 第三个语句可以看到，scala会做if语句的类型推断，如果两个类型不同，Scala编译器就会去找两个类型的公共父类Any
  

4.2 循环

留意：Scala不支持break或continue语句
4.2.1 for循环

留意两个关键字 <- ，to

1. package com.wanlong
3. object TestFor {
5.   def main(args: Array[String]): Unit = {
6.     //1到 10 之间的数字
7.     for (i <- 1 to 10) {
8.       print(i+"  ")
9.     }
10.     println()
11.     for (c <- "Hello World") print(c + " ")
12.     println()
13.     //另外一种写法
14.     for (i <- 1.to(10)) {
15.       print(i+"  ")
16.     }
17.   }
18. }

复制代码

运行效果：

1. 1  2  3  4  5  6  7  8  9  10  
2. H e l l o   W o r l d
3. 1  2  3  4  5  6  7  8  9  10  

复制代码

4.2.2 while 循环

1. package com.wanlong
3. import scala.util.control.Breaks
5. object TestWhile {
7.   /**
8.    * 循环控制语句改变其正常的顺序执行。执行离开一个范围, 在该范围内创建的所有对象自动被销毁。但是Scala不支持break或continue语句。
9.    *
10.    * @param args
11.    */
12.   def main(args: Array[String]) {
13.     var i = 0;
14.     while (i < 10) {
15.       print(i+" ")
16.       i += 1
17.     }
18.     println("------------------")
19.     var j = 0;
20.     val loop = new Breaks;
21.     loop.breakable {
22.       while (j < 10) {
23.         print(j+" ")
24.         if (j == 5) loop.break
25.         j += 1
26.       }
27.     }
28.     println("------------afper loop------")
29.   }
30. }

复制代码

运行效果：

1. 0 1 2 3 4 5 6 7 8 9 ------------------
2. 0 1 2 3 4 5 ------------afper loop------

复制代码

4.2.3 if守卫

if守卫是Scala编程语言中的一种特性，它允许在for循环中使用if语句作为守卫（guard）条件，从而实现对循环迭代的过滤。
在Scala的for循环中，每个生成器（generator）后面都可以跟一个以if开头的boolean表达式，这个表达式就是if守卫。它用于指定一个条件，只有当该条件为真时，当前的迭代才会被执行。
比方，以下代码演示了如何使用if守卫来过滤出1到20之间的偶数而且大于2：

1. for( x <- 1 to 20 if x % 2 == 0 if x > 2 ) println(x)

复制代码

if守卫特点：

• 多个守卫条件：一个for循环可以支持多个if守卫语句，它们之间以空格或回车字符分割。每个守卫条件都是一个boolean表达式，只有当所有守卫条件都为真时，当前的迭代才会被执行。
  
• 降低循环次数：通过if守卫，可以明显地降低循环次数，因为不满足条件的迭代会被直接过滤掉，从而提高步调的效率。
  
• 易读性：if守卫使得循环的过滤逻辑更加清晰和易读，因为过滤条件直接写在了循环语句中。
  
• 需要留意的是，if守卫并不支持其他循环语句，如while循环。在Scala中，while循环没有提供与for循环类似的守卫机制。但是，可以通过其他方式（如使用boolean类型变量或Breaks对象的break函数）来实现类似的循环控制。
  

复杂示例演示：

1. for {
2.   i <- 1 to 3 // 第一个生成器，遍历1到3
3.   j <- 1 to 2 // 第二个生成器，遍历1到2
4.   if i != j      // 第一个守卫条件，排除i和j相等的情况
5.   if i + j > 3   // 第二个守卫条件，排除i和j之和不大于3的情况
6. } println(i,j)   // 将满足条件的(i, j)输出

复制代码

输出效果：

1. (3,1)
2. (3,2)
3. (3,1)
4. (3,2)

复制代码

4.2.4 双重循环

1. //双重For循环 实现99乘法表
2. for(i<-1 to 9; j<-1 to i) {
3.   print(i+"*"+j+"="+i*j+" ")
4.   if(i==j) println()
5. }

复制代码

运行效果：

1. 1*1=1
2. 2*1=2 2*2=4
3. 3*1=3 3*2=6 3*3=9
4. 4*1=4 4*2=8 4*3=12 4*4=16
5. 5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6. 6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7. 7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8. 8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9. 9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81

复制代码

4.2.5 for循环绑定临时变量

1. //原始写法：
2. val names = Array("wanlong", "hadoop", " sqoop", "    ")
3. for (name <- names if name.trim.nonEmpty) {
4.   println(name.trim)
5. }
6. //优化：
7. for {
8.   name <- names
9.   tmpname = name.trim
10.   if tmpname.nonEmpty
11. } {
12.   println(tmpname)
13. }

复制代码

运行效果：

1. wanlong
2. hadoop
3. sqoop

复制代码

4.2.6 yield关键字

yield会把当前的元素记录下来，保存在集合中，当循环竣事就会返回该集合。

1. val nlist = for (i <- 1 to 10) yield {
2.   print(i+" ")
3.   i * 2
4. }
5. println()
6. nlist.foreach(o=>print(o+" "))
7. //for循环中的yield会把当前的元素记录下来，保存在集合中，当循环结束就会返回该集合。

复制代码

运行效果：

1. 1 2 3 4 5 6 7 8 9 10
2. 2 4 6 8 10 12 14 16 18 20

复制代码

5. 函数

5.1 函数定义

Scala是一门既面向对象，又面向过程的语言。因此在Scala中有非常好的面向对象的特性，可以使用Scala来基于面向对象的头脑开发大型复杂的系统和工程。
而且Scala也面向过程，因此Scala中有函数的概念。在Scala中，函数与类、对象等一样，都是一等公民。这意味着函数可以作为参数传递给其他函数、可以作为返回值从其他函数中返回，而且可以赋值给变量。Scala中的函数可以独立存在，不需要依赖任何类和对象。
Scala的函数式编程，就是Scala面向过程的最好的佐证。也正是因为函数式编程，才让Scala具备了Java所不具备的更强大的功能和特性。
5.2 第一个函数

1. package com.wanlong
3. object TestFunction {
4. //定义最大值函数
5.   def max(x:Int,y:Int):Int ={
6.     if(x>y){
7.       x
8.     }else{
9.       y
10.     }
11.   }
12.   //函数定义
13.   def add(x: Int, y: Int): Int = {
14.      x + y
15.   }
16. }

复制代码

在上面代码中定义了两个函数，此中max是最大值函数，在scala中，函数用def定义，def有点像java中的public static
这里要留意：

• 如果一个函数在定义的时候，没有输入参数，而且定义的时候使用的是空的参数列表，那么在调用的时候可以给()，也可以不给
  
• 如果没有参数，可以在定义的时候，不给定参数列表==》调用的时候不能给定()，只能f2
  

举比方下：

1.   //如果一个函数在定义的时候，没有输入参数，而且定义的时候使用的是空的参数列表，那么在调用的时候可以给()，也可以不给
2.   def f1() {
3.     println("ss")
4.   }
5.   // 如果没有参数，可以在定义的时候，不给定参数列表==》调用的时候不能给定()，只能f2
6.   def f2: Unit = {
7.     println("hello f2")
8.   }
11.   def main(args: Array[String]) {
13.     println(add(1, 2))
14.     f1()
15.     f1
16.     f2
17. }

复制代码

5.3 嵌套函数

1.   //函数中定义函数
2. def function1(a: Int): Int = {
3.   def function2(b: Int): Int = {
4.     a + b
5.   }
6.   function2(2)
7. }
8.   def main(args: Array[String]) {
9.         //1+2
10.     println(function1(1))
11. }

复制代码

5.4 匿名函数

将函数传递给变量有三种传递方式:

• 将函数的值传递给变量
  
• 将函数直接传递给变量
  
• 匿名函数(没有写def，一样平常情况下就是将匿名函数赋值给变量使用)
  

1.   //第一种方式
2.   val num: Int = max(1, 2)
3.   //第二种方式 注意 下划线前不加空格会报错
4.   val num2=max _
5.   println(num2(1,2))
6.   //第三种方式
7.   val num3 = (x: Int, y: Int) => if (x > y) x else y

复制代码

留意：

• 函数可以赋值给变量也可以赋值给函数
  

5.5 给函数参数默认值

2.   // scala 默认参数  Scala 可以为函数参数指定默认参数值，使用了默认参数，
3.   // 你在调用函数的过程中可以不需要传递参数，这时函数就会调用它的默认参数值，如果传递了参数，则传递值会取代默认值。
4.   def sayName(name: String = "wanlong") {
5.     println("hello," + name)
6.   };
7.   sayName()

复制代码

留意：一样平常情况将给定默认值的输入参数放到函数的参数列表末了，因为参数的补全从左到右
5.6 可变参数

在scala中，函数参数可变，但是只能是末了一个参数，*代表的是参数可重复

1.   /**
2.    * "在函数内部，变长参数的类型，实际为一数组，比如上例的string*类型实际为 Array[string]。
3.    * 然而，如今你试图直接传入一个数组类型的参数给这个参数，
4.    * 编译器会报错:\
5.    * val arr* Array("hadoop", "hive", "hbase", "spark")
6.    * printCourses(arr)
7.    * "为了避免这种情况，你可以通过在变量后面添加_*来解决，这个符号告诉scala编译器在传递参数时逐个传入数组的每个元素，而不是数组整体。
8.    * printCourse(arr: _*)
9.    *
10.    * @param args
11.    */
12.   def printCourse(course: String*) {
13.     for (c <- course) println(c)
14.   }
15.   def main(args: Array[String]) {
17.     printCourse("hadoop", "spark", "hive")
18.     printCourse("java")
19.     val arr = Array("hadoop", "hive", "hbase", "spark")
20.     // printCourse(arr)
21.     printCourse(arr: _*)
22. }

复制代码

留意： 在传入数组参数时，后面加_* ，告诉编译器，代表数组中元素一个个举行传递，而不是整个数组传递，传递整个数组是不认可的。
6. 高阶函数

在Scala中，高阶函数（Higher-Order Function）是指接受一个或多个函数作为参数，或者返回一个函数作为效果的函数。高阶函数极大地增强了Scala的表达能力，使得代码更加简洁和模块化
6.1 接受函数作为参数

1. def applyFunction(x: Int, f: Int => Int): Int = {
2.   f(x)
3. }
5. // 定义一个简单的函数作为参数传递
6. val square: Int => Int = x => x * x
8. // 使用高阶函数applyFunction
9. val result = applyFunction(5, square)
10. println(result)  // 输出: 25

复制代码

6.2 返回函数作为效果

高阶函数也可以返回另一个函数作为效果。比方，我们可以定义一个函数makeIncrementer，它接受一个整数n并返回一个函数，该函数接受另一个整数并返回n加上该整数的效果：

1. def makeIncrementer(n: Int): Int => Int = {
2.   (x: Int) => x + n
3. }
5. // 使用高阶函数makeIncrementer
6. val incrementBy5 = makeIncrementer(5)
7. val result = incrementBy5(10)
8. println(result)  // 输出: 15

复制代码

6.3 匿名函数

在Scala中，匿名函数（也称为Lambda表达式）常用于高阶函数。Lambda表达式的基本语法是：

1. (参数列表) => 表达式

复制代码

比方，在上面的例子中，我们使用了Lambda表达式来定义square和makeIncrementer中的匿名函数。
6.4 高阶函数类型推断

高阶函数可以自动推断出参数类型，而不需要写明类型;而且对于只有一个参数的函数，还可以省去其小括号。
如果仅有的一个参数在右侧的函数体内只使用一次，则还可以将吸取参数省略而且将参数用_来替代，诸如3 * _的这种语法，spark源码中大量使用了这种语法!

1. def triple(func:(Int)=>Int) = {
2.   func(3)
3. }
4. triple((x:Int)=>3*x)
5. triple(x=>3*x)
6. triple(3*_)

复制代码

6.5 常用高阶函数

1. /**
2.    * map
3.    * flatMap
4.    * filter
5.    * reduce
6.    * sortBy
7.    * groupBy
8.    * countByKey
9.    * take
10.    * takeOrdered
11.    * takeRight
12.    * drop
13.    * max
14.    * min
15.    * sum
16.    * zip
17.    * partition
18.    * forall
19.    * exists
20.    */
21.   //map  对数组中的每个元素进行映射，返回处理后的元素
22.   Array(1,2,3,4,5,6,7,8,9,10) map (_*2)
23.   //foreach
24.   Array(1,2,3,4,5,6,7,8,9,10) foreach println
25.   //filter
26.   Array(1,2,3,4,5,6,7,8,9,10) filter (_%2==0)
27.   //reduceLeft  对数组中的元素进行左折叠操作，从左侧元素开始，进行reduce操作, 即先对元素1和元素2 进行处理，
28.   //然后将第一次reduce的结果和元素3进行reduce，以此类推， reduce操作必须掌握!spark编程的重点!!!
29.   // 最终返回reduce之后的结果 相当于1+2+3+4+5+6+7+8+9+10
30.   Array(1,2,3,4,5,6,7,8,9,10) reduceLeft (_+_)
31.   //flatmap 使用举例
32.   (Array("hello","world") flatMap (_.toArray)).foreach(println)

复制代码

此中，map和flatmap的操纵需要重点关注。
map操纵符‌重要用于将集合中的每个元素通过一个函数转换后，收集转换效果。比方，如果有一个字符串列表，map操纵可以将每个字符串转换为大写字母，效果是一个包罗大写字母的新列表。map操纵保留了原始数据的结构，即每个元素仍旧是独立的。
flatMap操纵符‌则在此基础上增加了一个“摊平”的操纵。它不但对每个元素应用函数，还将函数的返回值扁平化。比方，如果有一个嵌套列表，flatMap会将内部的列表展开，并将所有元素归并到一个新的列表中。flatMap操纵符特别实用于处理嵌套的数据结构，能够将多层嵌套的数据扁平化为单层结构。
举比方下：
   有二箱鸡蛋，每箱5个，现在要把鸡蛋加工成煎蛋，然后分给学生。map做的事情：把二箱鸡蛋分别加工成煎蛋，还是放成原来的两箱，分给2组学生。flatMap做的事情：把二箱鸡蛋分别加工成煎蛋，然后放到一起【10个煎蛋】，分给10个学生
    scala中map和flatmap的区别可以用一句话举行总结，原始RDD如果是10行，颠末map操纵后仍旧是10行，但是flatmap后会>=10行，map是对每一行举行处理，flatmap对每一行举行处理后，如果处理效果的长度是1，那么就和map操纵一样；如果处理后是个List或者Array类型，那么就会将这个List或者Array的每个元素变成1行。
  以上，本文重要讲了scala基础用法，下一章，我会介绍scala中常用的集合，元组以及他们对应的api等内容。
末了，感谢阅读，如有错误，请不吝指正！！！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。