3天极速掌握 Scala 语言：First Day

系统管理员 2023-01-23 12:49 6阅读 0赞

### 目录 ###

*  一、基础语法学习
 *   *  1.1 声明变量
     *   *  1.1.1 语法格式
         *  1.1.2 在解释器中定义一个变量
         *  1.1.3 val 和 var 变量
         *  1.1.4 使用类型推断来定义变量
         *  1.1.5 惰性赋值
     *  1.2 字符串
     *   *  1.2.1 使用双引号
         *  1.2.2 使用插值表达式
         *  1.2.3 使用三引号
     *  1.3 数据类型与操作符
     *   *  1.3.1 数据类型
         *  1.3.2 运算符
         *  1.3.3 Scala 类型层次结构
     *  1.4 条件表达式
     *   *  1.4.1 有返回值的 if
         *  1.4.2 块表达式
     *  1.5 循环
     *   *  1.5.1 for 表达式
         *  1.5.2 while 循环
     *  1.6 break 和 continue
     *   *  1.6.1 实现 break
         *  1.6.2 实现 continue
     *  1.7 方法
     *   *  1.7.1 定义方法
         *  1.7.2 返回值类型推断
     *  1.8 方法参数
     *   *  1.8.1 默认参数
         *  1.8.2 带名参数
         *  1.8.3 变长参数
     *  1.9 方法调用方式
     *   *  1.9.1 后缀调用法
         *  1.9.2 中缀调用法
         *  1.9.3 操作符即方法
         *  1.9.4 花括号调用法
         *  1.9.5 无括号调用法
     *  1.10 函数 -- 重点掌握
     *   *  1.10.1 定义函数
         *  1.10.2 方法和函数的区别
         *  1.10.3 方法转换为函数
         *  1.10.4 完全体函数
     *  1.11 数组 -- 重点掌握
     *   *  1.11.1 定长数组
         *  1.11.2 变长数组
         *  1.11.3 遍历数组
         *  1.11.4 数组常用算法
     *  1.12 元组 -- 重点掌握
     *   *  1.12.1 定义元组
         *  1.12.2 访问元组
     *  1.13 列表 -- List -- 重点掌握
     *   *  1.13.1 不可变列表定义
         *  1.13.2 可变列表
         *  1.13.3 列表常用操作
     *  1.14 Set
     *   *  1.14.1 不可变集
         *  1.14.2 可变集
     *  1.15 Map 对象
     *   *  1.15.1 不可变 Map
         *  1.15.2 可变 Map
         *  1.15.3 Map 基本操作
     *  1.16 iterator 迭代器
     *   *  1.16.1 使用迭代器遍历集合

# 一、基础语法学习 #

## 1.1 声明变量 ##

### 1.1.1 语法格式 ###

在 Scala 中，可以使用 **val** 或者 **var** 关键字来定义变量，语法格式如下:

val/var 变量标识:变量类型 = 初始值

注意：

1.  **val** 定义的是 **不可重新赋值的变量，不可变。** 不是 java 中 final 的意思。Scala 也有 final，在 Scala 中 final 表示数值不可变以及不可被覆写。val 仅仅是数值不变，可以被复写。
2.  **var** 定义的是 **可重新赋值的变量，可变。**
3.  Scala 中定义变量类型写在变量名后面。
4.  Scala 的语句最后不需要添加分号。
5.  Scala 中类型是 首字母大写的。

### 1.1.2 在解释器中定义一个变量 ###

示例：定义一个变量保存一个人的名字 “Amo”

**步骤：**

1.  打开 Scala 解释器
2.  定义一个字符串类型的变量用来保存名字

**参考代码**

scala> val name:String = "Amo"
    name: String = Amo

### 1.1.3 val 和 var 变量 ###

**示例1**

给名字变量进行重新赋值为 Jerry，观察其运行结果  
![在这里插入图片描述][20210714160612631.png]  
**示例2**

使用 `var` 重新定义变量来保存名字 “Paul”，并尝试重新赋值为 “Ben”，观察其运行结果：

scala> var name:String = "Paul"
    name: String = Paul
    
    scala> name = "Ben"
    name: String = Ben

**优先使用 val 定义变量，如果变量需要被重新赋值，才使用 var。**

### 1.1.4 使用类型推断来定义变量 ###

Scala 的语法要比 Java 简洁，我们可以使用一种更简洁的方式来定义变量。Scala 是强类型语言，千万不要被它省略类型所迷惑。它是可以省略类型，不代表变量没有类型。

**示例1**

使用更简洁的语法定义一个变量保存一个人的名字 “Amo”

**参考代码**

scala> val name = "Amo"
    name: String = Amo

Scala 可以自动根据变量的值来自动推断变量的类型，这样编写代码更加简洁。

### 1.1.5 惰性赋值 ###

什么时候用到，什么时候被加载的内存中。 在企业的大数据开发中，有时候会编写非常复杂的 SQL 语句，这些 SQL 语句可能有几百行甚至上千行。这些 SQL 语句，如果直接加载到 JVM 中，会有很大的内存开销。如何解决？当有一些变量保存的数据较大时，但是不需要马上加载到 JVM 内存。可以使用 **惰性赋值** 来提高效率。语法格式：

lazy val 变量名 = 表达式

**注意：var 不可以用 lazy**  
![在这里插入图片描述][20210714161805646.png]

## 1.2 字符串 ##

Scala 提供多种定义字符串的方式，将来我们可以根据需要来选择最方便的定义方式。使用双引号、使用插值表达式、使用三引号。

### 1.2.1 使用双引号 ###

语法

val/var 变量名 = "字符串"

**示例：** 有一个人的名字叫 “Amo”，请打印他的名字以及名字的长度。

**参考代码**

scala> val name:String = "Amo"
    name: String = Amo
    
    scala> println(name + name.length)
    Amo3

### 1.2.2 使用插值表达式 ###

Scala 中，可以使用插值表达式来定义字符串，有效避免大量字符串的拼接。语法：

val/var 变量名 = s"${变量/表达式}字符串"

1.  在定义字符串之前添加 **s**
2.  在字符串中，可以使用 **$\{\}** 来引用变量或者编写表达式

**示例：** 请定义若干个变量，分别保存：“Amo”、18、“male”，定义一个字符串，保存这些信息。打印输出：name=Amo, age=18, sex=male

**参考代码**

scala> val name = "Amo"
    name: String = Amo
    
    scala> val age = 18
    age: Int = 18
    
    scala> val sex = "male"
    sex: String = male
    
    scala> println(s"name=${name},age=${age},sex=${sex}")
    name=Amo,age=18,sex=male

### 1.2.3 使用三引号 ###

如果有大段的文本需要保存，就可以使用三引号来定义字符串。例如：保存一大段的 SQL 语句。三个引号中间的所有字符串都将作为字符串的值。语法：

val/var 变量名 = """字符串1
    字符串2"""

**示例：** 定义一个字符串，保存以下 SQL 语句。

scala> val sql = """
         | create table course(
         | cid string,
         | cname string,
         | tid string)
         | clustered by(cid) into 3 buckets
         | row format delimited fields terminated by '\t';
         | """
    sql: String =
    "
    create table course(
    cid string,
    cname string,
    tid string)
    clustered by(cid) into 3 buckets
    row format delimited fields terminated by '\t';
    "
    
    scala> println(sql)
    
    create table course(
    cid string,
    cname string,
    tid string)
    clustered by(cid) into 3 buckets
    row format delimited fields terminated by '\t';

但是要注意一点，三引号字符串不要出现重复，比如 `""'' aaa """ bbb """`。因为，Scala 编译器，从第一个三引号开始，到第二个三引号结束，算一个完整的字符串，后面的就是多出来的语法错误的内容。  
![在这里插入图片描述][20210714163609974.png]

## 1.3 数据类型与操作符 ##

Scala 中的类型以及操作符绝大多数和 Java 一样，我们主要来学习，与 Java 不一样的一些用法，Scala 类型的继承体系。

### 1.3.1 数据类型 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">基础类型</th> 
   <th align="left">类型说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">Byte</td> 
   <td align="left">8位带符号整数</td> 
  </tr> 
  <tr> 
   <td align="left">Short</td> 
   <td align="left">16位带符号整数</td> 
  </tr> 
  <tr> 
   <td align="left">Int</td> 
   <td align="left">32位带符号整数</td> 
  </tr> 
  <tr> 
   <td align="left">Long</td> 
   <td align="left">64位带符号整数</td> 
  </tr> 
  <tr> 
   <td align="left">Char</td> 
   <td align="left">16位无符号Unicode字符</td> 
  </tr> 
  <tr> 
   <td align="left">String</td> 
   <td align="left">Char类型的序列（字符串）</td> 
  </tr> 
  <tr> 
   <td align="left">Float</td> 
   <td align="left">32位单精度浮点数</td> 
  </tr> 
  <tr> 
   <td align="left">Double</td> 
   <td align="left">64位双精度浮点数</td> 
  </tr> 
  <tr> 
   <td align="left">Boolean</td> 
   <td align="left">true或false</td> 
  </tr> 
 </tbody> 
</table>

Scala 类型与 Java 的区别：

1.  Scala 中所有的类型都使用 **大写字母** 开头。
2.  整型使用 **Int** 而不是 **Integer。**
3.  Scala 中定义变量可以不写类型，让 Scala 编译器自动推断。

### 1.3.2 运算符 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">类别</th> 
   <th align="left">操作符</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">算术运算符</td> 
   <td align="left">+、-、*、/、%(加减乘除和取模)</td> 
  </tr> 
  <tr> 
   <td align="left">关系运算符</td> 
   <td align="left">&gt;、&lt;、==、!=、&gt;=、&lt;=</td> 
  </tr> 
  <tr> 
   <td align="left">逻辑运算符</td> 
   <td align="left">&amp;&amp;、||、!</td> 
  </tr> 
  <tr> 
   <td align="left">位运算符</td> 
   <td align="left">&amp;、||、^、&lt;&lt;、&gt;&gt;</td> 
  </tr> 
 </tbody> 
</table>

Scala 中的运算符, 基本上和 Java 一样, 除了:

1.  Scala 中没有，++、-- 运算符
2.  与 Java 不一样，在 Scala 中，想要比较值是否相同，就用 `==` 即可。 在 Scala 中 `==` 是很智能的。 如果对象为 NULL 会自动判断空的情况， 如果对象不为空会自动判断对象的值是否相等。想要比较内存地址，使用 `.eq` 方法。

**示例：** 有一个字符串"abc"，再创建第二个字符串，值为：在第一个字符串后拼接一个空字符串。然后使用比较这两个字符串是否相等、再查看它们的引用值是否相等。

**参考代码**

scala> val str1 = "abc"
    str1: String = abc
    
    scala> val str2 = str1 + ""
    str2: String = abc
    
    scala> str1==str2
    res4: Boolean = true
    
    scala> str1.eq(str2)
    res5: Boolean = false

### 1.3.3 Scala 类型层次结构 ###

![image-20210316205637253][]所有的类型都是从 Any 继承了, 也就是我们 Scala 是一种单根继承体系。

<table> 
 <thead> 
  <tr> 
   <th align="left">类型</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">Any</td> 
   <td align="left"><strong>所有类型</strong> 的父类，它有两个子类 AnyRef 与 AnyVal</td> 
  </tr> 
  <tr> 
   <td align="left">AnyVal</td> 
   <td align="left"><strong>所有数值类型</strong> 的父类</td> 
  </tr> 
  <tr> 
   <td align="left">AnyRef</td> 
   <td align="left">所有对象类型（引用类型）的父类 (String 本质就是 Char 数组，也是引用类型哦)</td> 
  </tr> 
  <tr> 
   <td align="left">Unit</td> 
   <td align="left">表示空，Unit 是 AnyVal 的子类，它只有一个的实例{% em %}() {% endem %}<br>它类似于 Java 中的 void，但 Scala 要比 Java 更加面向对象，Unit 本身也是一个类哦，当返回值为空的时候，返回的就是 Unit，Unit 的实例就是一个括号(). 这个对象用来做空返回值的时候用</td> 
  </tr> 
  <tr> 
   <td align="left">Null</td> 
   <td align="left">Null 也就是 AnyRef 的子类，也就是说它是所有引用类型的子类。它的实例是{% em %}** null **{% endem %}<br>可以将null赋值给任何引用对象类型. 真的是空，表示的是<code>引用类型</code>指针指向的内存地址不存在或者不指向内存区域。</td> 
  </tr> 
  <tr> 
   <td align="left">Nothing</td> 
   <td align="left">所有类型的 <strong>子类</strong><br> 不能直接创建该类型实例，某个方法抛出异常时，返回的就是 Nothing 类型，因为 Nothing 是所有类的子类，那么它可以赋值为任何类型</td> 
  </tr> 
 </tbody> 
</table>

**问题：** 以下代码是否有问题？

val b:Int = null

Scala 会解释报错：Null 类型并不能转换为 Int 类型，说明 **Null 类型并不是 Int 类型的子类**，也就是不是数值类型 AnyVal 的子类。

## 1.4 条件表达式 ##

条件表达式就是 if 表达式，if 表达式可以根据给定的条件是否满足，根据条件的结果(真或假)决定执行对应的操作。Scala 条件表达式的语法和 Java 一样。

### 1.4.1 有返回值的 if ###

与 Java 不一样的是：

1.  在 Scala 中，条件表达式也是有返回值的。
2.  在 Scala 中，没有三元表达式，可以使用 if 表达式替代三元表达式。

**示例：** 定义一个变量 sex，再定义一个 result 变量，如果 sex 等于 “male”，result 等于 1，否则 result 等于 0。

**参考代码**

scala> val sex = "male"
    sex: String = male
    
    scala> val result = if sex == "male" 1 else 0
    <console>:1: error: '(' expected but identifier found.
           val result = if sex == "male" 1 else 0
                           ^
    
    scala> val result = if(sex == "male") 1 else 0
    result: Int = 1

### 1.4.2 块表达式 ###

1.  Scala 中，使用 **\{\}** 表示一个块表达式。
2.  和 if 表达式一样，块表达式也是有值的。
3.  值就是最后一个表达式的值(因为 Scala 中没有 return 语句)

**问题：** 请问以下代码，变量 a 的值是什么？

scala> val a = {
        
         | println(1+1)
         | 1 + 1
         | }
    2
    a: Int = 2

## 1.5 循环 ##

在 Scala 中，可以使用 for 和 while，但一般推荐使用 for 表达式，因为 for 表达式语法更简洁。

### 1.5.1 for 表达式 ###

语法格式如下：

for(i <- 表达式/数组/集合) {
        
        // 表达式
    }

**示例：** 简单循环，使用 for 表达式打印 1-10 的数字。

**步骤：**

1.  生成 1-10 的数字（提示：使用 to 方法）。
2.  使用 for 表达式遍历，打印每个数字。

**参考代码1：**

scala> val nums = 1.to(10)
    nums: scala.collection.immutable.Range.Inclusive = Range 1 to 10
    scala> for(i <- nums) println(i)

**参考代码2：**

scala> for(i <- 1 to 10) println(i)
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    
    scala> for(i <- 1 until 10) println(i)
    1
    2
    3
    4
    5
    6
    7
    8
    9

**嵌套循环：** 使用 for 表达式，打印以下字符。

\*\*\*\*\*  
\*\*\*\*\*  
\*\*\*\*\*

**参考代码**

scala> :paste
    // Entering paste mode (ctrl-D to finish)
    
    for(i <- 1 to 3){
        
     for(i <- 1 to 5){
        
       print("*")
     }
     println()
    }
    
    // Exiting paste mode, now interpreting.
    
    *****
    *****
    *****
    
    scala> for(i <- 1 to 3;j <- 1 to 5){
        print("*");if(j==5) println("*")}
    ******
    ******
    ******
    
    scala>

也可以在一个 for 中通过 `;` 来定义多层嵌套的 for 循环。

**守卫：** for 表达式中，可以添加 if 判断语句，这个 if 判断就称之为守卫。我们可以使用守卫让 for 表达式更简洁。

**语法**

for(i <- 表达式/数组/集合 if 表达式) {
        
        // 表达式
    }

**示例：** 使用 for 表达式打印 1-10 之间能够整除 3 的数字。

**参考代码：**

// 添加守卫，打印能够整除3的数字
    scala> for(i <- 1 to 10 if i % 3 == 0) println(i)
    3
    6
    9

**for 推导式：** 将来可以使用 for 推导式生成一个新的集合(一组数据)。在 for 循环体中，可以使用 yield 表达式构建出一个集合，我们把使用 yield 的 for 表达式称之为推导式。

**示例：** 生成一个 10、20、30…100 的集合。

**参考代码：**

// for推导式：for表达式中以yield开始，该for表达式会构建出一个集合
    scala> val v = for(i <- 1 to 10) yield i * 10
    v: scala.collection.immutable.IndexedSeq[Int] = Vector(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)

yield 推导式就是将循环的每一个返回值都收集起来，收集到一个集合中作为 for 循环的返回值。

### 1.5.2 while 循环 ###

Scala 中 while 循环和 Java 中是一致的。

**示例：** 打印 1-10 的数字。

**参考代码**

scala> :paste
    // Entering paste mode (ctrl-D to finish)
    
    var i = 1
    while(i <= 10){
        
     println(i)
     i += 1
    }
    
    // Exiting paste mode, now interpreting.
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    i: Int = 11
    
    scala>

## 1.6 break 和 continue ##

在 Scala 中，类似 Java 和 C++ 的 **break/continue** 关键字被移除了。如果一定要使用 break/continue，就需要使用 scala.util.control 包的 Break 类的 **breakable** 和 **break** 方法。

### 1.6.1 实现 break ###

**用法**

1.  导入 Breaks 包 `import scala.util.control.Breaks._`。
2.  使用 breakable 将 for 表达式包起来。
3.  for表达式中需要退出循环的地方，添加 `break()` 方法调用。

**示例：** 使用 for 表达式打印 1-100 的数字，如果数字到达 50，退出 for 表达式。

**参考代码**

// 导入scala.util.control包下的Break
    scala> import scala.util.control.Breaks._
    import scala.util.control.Breaks._
    
    scala> breakable{
        
         | for (i <- 1 to 100){
        
         |  if(i >= 50) break()
         |  else println(i)
         | }
         | }

### 1.6.2 实现 continue ###

**用法：** continue 的实现与 break 类似，但有一点不同：实现 break 是用 **breakable\{\}** 将整个 for 表达式包起来，而实现 continue 是用 **breakable\{\}** 将 for 表达式的循环体包含起来就可以了。

**示例：** 打印 1-100 的数字，使用 for 表达式来遍历，如果数字能整除10，不打印。

// 导入scala.util.control包下的Break    
    scala> import scala.util.control.Breaks._
    import scala.util.control.Breaks._
    
    scala> for(i <- 1 to 100){
        
         | breakable{
        
         | if(i%10==0)break()
         | else println(i)
         | }
         | }

解答, 为何 break 功能要包住外面，continue 包住 for 循环体呢？因为，在这两种实现中，break 方法都是跳出了 breakable 包含的代码块，向下继续执行。唯一不同的是，如果 breakable 包住 for 循环，那么跳出的时候，就把 for 循环也跳出了，就向下继续执行了，就实现了类似 java 中 break 的功能。如果 breakable 包住 for 循环的循环体的话，那么跳出的时候，还在 for 循环内，只是当前这一次的循环体执行完成了，所以继续执行就是继续执行下一次的 for 循环。所以，包住的地方不同，实现的功能不同，但是对于 breakable 和 break 来说，他们的功能从未改变。

## 1.7 方法 ##

一个类可以有自己的方法，Scala 中的方法和 Java 方法类似。但 Scala 与 Java 定义方法的语法是不一样的。

### 1.7.1 定义方法 ###

**语法**

def methodName (参数名:参数类型, 参数名:参数类型) : [return type] = {
        
        // 方法体：一系列的代码
    }

1.  参数列表的参数类型不能省略(因为之前定义变量的时候可以省略，这里不要混淆了，因为变量给了初始值，可以根据初始值推断类型)。
2.  返回值类型可以省略，由 Scala 编译器自动推断。
3.  返回值可以不写 return，默认就是 **\{\}块表达式的值。**

**示例：**

1.  定义一个方法，实现两个整形数值相加，返回相加后的结果。
2.  调用该方法。

**参考代码**

scala> def add(a:Int, b:Int) = a + b
    add: (a: Int, b: Int)Int
    
    scala> add(5,6)
    res4: Int = 11

### 1.7.2 返回值类型推断 ###

Scala 定义方法可以省略返回值，由 Scala 自动推断返回值类型。这样方法定义后更加简洁。定义递归方法，不能省略返回值类型。因为，递归调用是一层一层向内走，当前那一层无法推断返回类型，会导致一系列问题。

**示例：** 定义递归方法(求阶乘)，比如求 10 的阶乘，`10 * 9 * 8 * 7 * 6 * ... * 1`

**参考代码**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h3MTY4MA_size_16_color_FFFFFF_t_70]

## 1.8 方法参数 ##

Scala 中的方法参数，使用比较灵活。它支持以下几种类型的参数：默认参数、带名参数、变长参数。

### 1.8.1 默认参数 ###

在定义方法时可以给参数定义一个默认值。

**示例：**

1.  定义一个计算两个值相加的方法，这两个值默认为 0。
2.  调用该方法，不传任何参数。

**参考代码**

// x，y带有默认值为0 
    scala> def add(x:Int = 0, y:Int = 0) = x + y
    add: (x: Int, y: Int)Int
    
    scala> add()
    res5: Int = 0

### 1.8.2 带名参数 ###

在调用方法时，可以指定参数的名称来进行调用。

**示例：**

1.  定义一个计算两个值相加的方法，这两个值默认为 0。
2.  调用该方法，只设置第一个参数的值。

**参考代码：**

scala> def add(x:Int = 0, y:Int = 0) = x + y
    add: (x: Int, y: Int)Int
    
    scala> add(1)
    res6: Int = 1

### 1.8.3 变长参数 ###

如果方法的参数是不固定的，可以定义一个方法的参数是变长参数。语法格式如下：

def 方法名(参数名:参数类型*):返回值类型 = {
        
        方法体
    }

在参数类型后面加一个 `*` 号，表示参数可以是0个或者多个。

**示例：**

1.  定义一个计算若干个值相加的方法。
2.  调用方法，传入以下数据：1,2,3,4,5。

**参考代码：**

scala> def add(num:Int*) = num.sum
    add: (num: Int*)Int
    
    scala> add(1,2,3,4,5)
    res7: Int = 15

其他：Scala 允许指定最后一个参数是可变长度的，或者唯一一个参数。变长参数，在函数体内本质上是一个 Array 实例，也就是除了例子里面的 sum 外，我们也可以用 for 循环迭代它，如：

scala> def add(x:Int*): Int={
        
         | var result=0
         | for(i <- x) result += i
         | result
         | }
    add: (x: Int*)Int
    
    scala> add(1,2,3)
    res8: Int = 6

虽然它本质上是一个 Array，但是你不可以将 Array 对象传递给它，如果要传递需要传递如 array:\_\* 表明将每个元素传递给它，而不是整个数组对象。如：

add(ar:_*)

## 1.9 方法调用方式 ##

在 Scala 中，有以下几种方法调用方式，后缀调用法、中缀调用法、花括号调用法、无括号调用法，在后续编写 Spark、Flink 程序时，会使用到这些方法调用方式。

### 1.9.1 后缀调用法 ###

这种方法与 Java 没有区别。

**语法：**

对象名.方法名(参数)

**示例：** 使用后缀法 `Math.abs` 求绝对值。

**参考代码**

scala> Math.abs(-1)
    res10: Int = 1
    
    scala> Math.abs(-3)
    res11: Int = 3

### 1.9.2 中缀调用法 ###

**语法**

对象名 方法名 参数
    1 to 10 //如果有多个参数，使用括号括起来

**示例：** 使用中缀法 `Math.abs` 求绝对值。

scala> Math abs -3
    res12: Int = 3

### 1.9.3 操作符即方法 ###

来看一个表达式：

1 + 1

大家觉得上面的表达式像不像方法调用？在Scala 中，+ - \* / % 等这些操作符和 Java 一样，但在 Scala 中，所有的操作符都是方法，操作符是一个方法名字是符号的方法。

### 1.9.4 花括号调用法 ###

语法格式如下：

Math.abs{
         
        // 表达式1
        // 表达式2
    }

方法只有一个参数，才能使用花括号调用法，因为块表达式只有一个返回值，所以只能给1个参数用。**示例：** 使用花括号调用法 `Math.abs` 求绝对值。**参考代码如下：**

scala> Math.abs{
        -10}
    res13: Int = 10

### 1.9.5 无括号调用法 ###

如果方法没有参数，可以省略方法名后面的括号。**示例如下：**

1.  定义一个无参数的方法，打印 “hello amo”。
2.  使用无括号调用法调用该方法。

**参考代码：**

scala> def m3()=println("hello amo")
    m3: ()Unit
    
    scala> m3()
    hello amo

## 1.10 函数 – 重点掌握 ##

Scala 支持函数式编程，编写 Spark/Flink 程序中，会大量使用到函数。函数和我们的对象一样, 在 Scala 中都是属于一等公民。

### 1.10.1 定义函数 ###

**简便语法：**

val 函数变量名 = (参数名:参数类型, 参数名:参数类型....) => 函数体

函数是一个 **对象(变量)。** 类似于方法，函数也有输入参数和返回值，函数定义不需要使用 `def` 定义，无需指定返回值类型。

**示例：**

1.  定义一个两个数值相加的函数。
2.  调用该函数。

**参考代码：**

scala> val add = (x:Int, y:Int) => x + y
    add: (Int, Int) => Int = <function2>
    
    scala> add(1,2)
    res3: Int = 3

### 1.10.2 方法和函数的区别 ###

方法是隶属于类或者对象的，在运行时，它是加载到 JVM 的方法区中。但是函数本身就是一个对象，可以将函数对象赋值给一个变量，在运行时，它是加载到 JVM 的堆内存中，函数是一个对象，继承自 FunctionN，函数对象有 apply，curried，toString，tupled 这些方法，方法则没有。通俗来说，从定义的方式就可以看出方法和函数的区别：

1.  一般我们使用 def 定义的为方法。
2.  而通过 val 或者 var 定义一个对象来接收的，一般就是函数。
3.  因为方法无法赋值给对象，但是函数定义的时候，就是直接赋值给了对象的。

**示例：** 方法无法赋值给变量。

scala> def add(x:Int, y:Int)=x+y
    add: (x: Int, y: Int)Int
    
    scala> val a = add
    <console>:18: error: missing argument list for method add
    Unapplied methods are only converted to functions when a function type is expected.
    You can make this conversion explicit by writing `add _` or `add(_,_)` instead of `add`.
           val a = add
                   ^
    
    scala>

### 1.10.3 方法转换为函数 ###

有时候需要将方法转换为函数，作为变量传递，就需要将方法转换为函数。使用 `_` 即可将方法转换为函数。

**示例：**

1.  定义一个方法用来进行两个数相加。
2.  将该方法转换为一个函数，赋值给变量。

**参考代码：**

scala> def add(x:Int,y:Int)=x+y
    add: (x: Int, y: Int)Int
    
    scala> val a = add _
    a: (Int, Int) => Int = $Lambda$1375/1645141562@34696884

不用过多去思考为何加了一个 `_` 就能转换成函数，这里没有什么特殊的意思，就是语法要求而已。

### 1.10.4 完全体函数 ###

前面写的函数，实际上是一种省略了返回值的写法，完全体如下：

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

其中：前面的 (Int, Int) => Int 是对象 func(也就是这个函数)的类型，类型是一个函数，函数的内容格式是两个 int 参数输入，返回一个 int 输出，后面的 (x, y) => x + y 就是定义形参，给形参命名，同时写上函数体，一般我们不写完全体，简略体就够了。**容易混淆的错误写法：**

scala> val addFunc: Int = (x:Int, y:Int) => x + y
    <console>:17: error: type mismatch;
     found   : (Int, Int) => Int
     required: Int
           val addFunc: Int = (x:Int, y:Int) => x + y

对函数 addFunc 的类型定义错误，addFunc 是一个函数，函数的类型必须是能看出什么输入 + 得到什么输出，也就是这里 addFunc 的类型应该是 (Int, Int) => Int 也就是，两个 Int 输入参数，得到一个 Int 输出返回。

## 1.11 数组 – 重点掌握 ##

Scala 中数组的概念是和 Java 类似，可以用数组来存放一组数据。Scala 中，有两种数组，一种是 **定长数组**，另一种是 **变长数组。**

### 1.11.1 定长数组 ###

1.  定长数组指的是数组的 **长度** 是 **不允许改变** 的。
2.  数组的 **元素** 是 **可以改变** 的。

java 中数组是根据类型来定义的比如 int\[\] String\[\]，在 Scala 中, 数组也是一个类，Array 类，存放的内容通过泛型来定义，类似 java 中 List 的定义，**语法格式如下：**

// 通过指定长度定义数组
    val/var 变量名 = new Array[元素类型](数组长度)
    
    // 用元素直接初始化数组
    val/var 变量名 = Array(元素1, 元素2, 元素3...)

在 Scala 中，数组的泛型使用 `[]` 来指定(java <>)，使用 `()` 来获取元素(java \[\])，这两点要注意，不要混淆了。

**示例1：**

1.  定义一个长度为 100 的整型数组。
2.  设置第 1 个元素为 110。
3.  打印第 1 个元素。

**参考代码：**

scala> val a = new Array[Int](100)
    
    scala> a(0) = 110
    
    scala> println(a(0))
    110

**示例2：**

1.  定义一个包含以下元素的数组： java、scala、python。
2.  获取数组长度。

**参考代码：**

// 定义包含jave、scala、python三个元素的数组
    scala> val a = Array("java","scala","python")
    a: Array[String] = Array(java, scala, python)
    
    scala> a.length
    res18: Int = 3

为什么带初值的就不用 new 呢，这里会用到一个 apply 方法，后面会详细说。现在只需要知道，直接 Array(1, 2, 3) 来创建数组，其实就是自动调用了 Array 类中的 apply 方法，apply 方法做的事情就是，new array(3) 然后把 3 个元素放进去，也就是这些工作自动帮我们做了。

### 1.11.2 变长数组 ###

变长数组指的是数组的长度是可变的，可以往数组中添加、删除元素。定义变长数组，创建变长数组，需要提前导入 ArrayBuffer 类 `import scala.collection.mutable.ArrayBuffer`

**语法：**

创建空的 ArrayBuffer 变长数组，语法结构：

val/var a = ArrayBuffer[元素类型]()

创建带有初始元素的 ArrayBuffer

val/var a = ArrayBuffer(元素1，元素2，元素3....)

**示例1：** 定义一个长度为0的整型变长数组

**参考代码：**

val a = ArrayBuffer[Int]()

为什么长度为 0 的就必须加泛型呢? 如果不加就是下面这样：  
![在这里插入图片描述][20210715000504744.png]  
因为没有初值来判断泛型, 所以泛型是 Nothing，同时不要忘记省略()，不要用方法调用的概念认为不带参数就可以不写括号了, 这样是不可以的，如下：  
![在这里插入图片描述][20210715000607343.png]  
就像前面提过一句的 apply 方法，如果不带()，那么就不会调用 apply 方法，不调用 apply 方法，那么就没有 ArrayBuffer 的调用，也就是不知道调用谁了。

**示例2：** 定义一个包含以下元素的变长数组。

"hadoop", "storm", "spark"

**参考代码**

scala> var a2 = ArrayBuffer("hadoop", "storm", "spark")
    a2: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(hadoop, storm, spark)

**添加/修改/删除元素。** 使用 `+=` 添加元素、使用 `-=` 删除元素、使用 `++=` 追加一个数组到变长数组。

**示例：**

1.  定义一个变长数组，包含以下元素: “hadoop”、“spark”、“flink”。
2.  往该变长数组添加一个 “flume” 元素。
3.  从该变长数组删除 “hadoop” 元素。
4.  再将一个数组，该数组包含 “hive”, “sqoop” 追加到变长数组中。

**参考代码**

scala> import scala.collection.mutable.ArrayBuffer
    import scala.collection.mutable.ArrayBuffer
    
    scala> val a = ArrayBuffer("hadoop", "spark", "flink")
    a: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(hadoop, spark, flink)
    
    scala> a += "flume"
    res19: a.type = ArrayBuffer(hadoop, spark, flink, flume)
    
    scala> a -= "hadoop"
    res20: a.type = ArrayBuffer(spark, flink, flume)
    
    scala> val a2 = ArrayBuffer("hive", "sqoop")
    a2: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(hive, sqoop)
    
    scala> a ++= a2
    res21: a.type = ArrayBuffer(spark, flink, flume, hive, sqoop)

### 1.11.3 遍历数组 ###

可以使用以下两种方式来遍历数组：

1.  使用 `for表达式` 直接遍历数组中的元素。
2.  使用 `索引` 遍历数组中的元素。

**示例1：**

1.  定义一个数组，包含以下元素 1,2,3,4,5。
2.  使用 for 表达式直接遍历，并打印数组的元素。

**参考代码**

scala> val a = Array(1,2,3,4,5)
    a: Array[Int] = Array(1, 2, 3, 4, 5)
    
    scala> for(i <- a) println(i)
    1
    2
    3
    4
    5

**示例2：**

1.  定义一个数组，包含以下元素1,2,3,4,5。
2.  使用 for 表达式基于索引下标遍历，并打印数组的元素。

**参考代码**

scala> val a = Array(1,2,3,4,5)
    a: Array[Int] = Array(1, 2, 3, 4, 5)
    
    scala> for(i <- 0 until a.length) print(a(i))
    12345
    scala> for(i <- 0 to a.length-1) print(a(i))
    12345

**0 until n——生成一系列的数字，包含0，不包含n，0 to n ——包含0，也包含n。**

### 1.11.4 数组常用算法 ###

Scala 中的数组封装了一些常用的计算操作，将来在对数据处理的时候，不需要我们自己再重新实现。以下为常用的几个算法：求和——sum方法、求最大值——max方法、求最小值——min方法、排序——sorted方法

**求和：** 数组中的 `sum` 方法可以将所有的元素进行累加，然后得到结果。

**示例：**

1.  定义一个数组，包含以下几个元素（1,2,3,4)。
2.  请计算该数组的和。

**参考代码：**

scala> val a = Array(1,2,3,4)
    a: Array[Int] = Array(1, 2, 3, 4)
    
    scala> a.sum
    res26: Int = 10

**最大值：** 数组中的 `max` 方法，可以获取到数组中的最大的那个元素值。

**示例：**

1.  定义一个数组，包含以下几个元素（4,1,2,4,10）。
2.  获取数组的最大值。

**参考代码：**

scala> val a = Array(4,1,2,4,10)
    a: Array[Int] = Array(4, 1, 2, 4, 10)
    
    scala> a.max
    res27: Int = 10
    
    scala> a.min
    res28: Int = 1
    
    scala> a.reverse
    res29: Array[Int] = Array(10, 4, 2, 1, 4)
    
    scala> a.sorted
    res30: Array[Int] = Array(1, 2, 4, 4, 10)
    
    scala> a.sorted.reverse
    res31: Array[Int] = Array(10, 4, 4, 2, 1)

## 1.12 元组 – 重点掌握 ##

元组可以用来包含一组不同类型的值。例如：姓名，年龄，性别，出生年月。元组的元素是不可变的。数组: 同一类数据成组。元组: 不同的元素成组，并且元组内容(元素)不可变。

### 1.12.1 定义元组 ###

**语法**

方式1: 使用括号来定义元组

val/var 元组 = (元素1, 元素2, 元素3....)

方式2：使用箭头来定义元组(元组只能有两个元素)

val/var 元组 = 元素1->元素2

**示例1：** 定义一个元组，包含一个学生的以下数据。

<table> 
 <thead> 
  <tr> 
   <th>id</th> 
   <th>姓名</th> 
   <th>年龄</th> 
   <th>地址</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>amo</td> 
   <td>18</td> 
   <td>chengdu</td> 
  </tr> 
 </tbody> 
</table>

**参考代码**

scala> val a = (1,"amo",18,"chengdu")
    a: (Int, String, Int, String) = (1,amo,18,chengdu)

**示例2：** 定义一个元组，包含学生的姓名和年龄(paul、26)、分别使用括号、和箭头来定义元组。

**参考代码：**

scala> val a = ("paul", 26)
    a: (String, Int) = (paul,26)
    
    scala>
    
    scala> val b = "paul" -> 20
    b: (String, Int) = (paul,20)

### 1.12.2 访问元组 ###

使用 \_1、\_2、\_3… 来访问元组中的元素，\_1 表示访问第一个元素，依次类推。

**示例：** 定义一个元组，包含一个学生的姓名和性别，“crystal”, “female”，分别获取该学生的姓名和性别。

**参考代码**

scala> val b = "paul" -> 20
    b: (String, Int) = (paul,20)
    
    scala> val a = "crystal" -> "female"
    a: (String, String) = (crystal,female)
    
    scala> a._1
    res32: String = crystal
    
    scala> a._2
    res33: String = female

## 1.13 列表 – List – 重点掌握 ##

列表是 Scala 中最重要的、也是最常用的数据结构。List 具备以下性质：

1.  可以保存重复的值。
2.  有先后顺序。

在 Scala 中，也有两种列表，一种是不可变列表、另一种是可变列表。

### 1.13.1 不可变列表定义 ###

不可变列表就是列表的 **元素、长度** 都是不可变的。

**语法：** 使用 `List(元素1, 元素2, 元素3, ...)` 来创建一个不可变列表，语法格式：

val/var 变量名 = List(元素1, 元素2, 元素3...)

使用 `Nil` 创建一个不可变的空列表：

val/var 变量名 = Nil

使用 `::` 方法创建一个不可变列表：

val/var 变量名 = 元素1 :: 元素2 :: Nil

使用 **::** 拼接方式来创建列表，必须在最后添加一个 **Nil。** 示例代码如下：

//创建一个不可变列表，存放以下几个元素（1,2,3,4）
    scala> val a = List(1,2,3,4)
    a: List[Int] = List(1, 2, 3, 4)
    //使用Nil创建一个不可变的空列表
    scala> val b = Nil
    b: scala.collection.immutable.Nil.type = List()
    //使用`::`方法创建列表，包含-2、-1两个元素
    //注意: `::` 前后的空格不能省略，会报错。
    scala> val c = -2 :: -1 :: Nil
    c: List[Int] = List(-2, -1)

### 1.13.2 可变列表 ###

可变列表就是列表的元素、长度都是可变的。要使用可变列表，先要导入`import scala.collection.mutable.ListBuffer`，可变集合都在 `mutable` 包中，不可变集合都在 `immutable` 包中(默认导入)。使用 **ListBuffer\[元素类型\]()** 创建空的可变列表，语法结构：

val/var 变量名 = ListBuffer[Int]()

使用 ListBuffer(元素1, 元素2, 元素3…) 创建可变列表，语法结构：

val/var 变量名 = ListBuffer(元素1，元素2，元素3...)

示例代码如下：

//创建空的整型可变列表
    scala> import scala.collection.mutable.ListBuffer
    import scala.collection.mutable.ListBuffer
    
    scala> val a = ListBuffer[Int]()
    a: scala.collection.mutable.ListBuffer[Int] = ListBuffer()
    
    //创建一个可变列表，包含以下元素：1,2,3,4
    scala> val a1 = ListBuffer(1,2,3,4)
    a1: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4)

**可变列表操作如下：**

1.  获取元素（使用括号访问`(索引值)`）
2.  添加元素（`+=`）
3.  追加一个列表（`++=`）
4.  更改元素（`使用括号获取元素，然后进行赋值`）
5.  删除元素（`-=`）
6.  转换为List（`toList`）转换为不可变列表
7.  转换为Array（`toArray`）转换为定长数组

//示例
    //1.定义一个可变列表包含以下元素：1,2,3
    scala> import scala.collection.mutable.ListBuffer
    import scala.collection.mutable.ListBuffer
    
    scala> val a = ListBuffer(1,2,3)
    a: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3)
    //2.获取第一个元素
    scala> a(0)
    res34: Int = 1
    //3.添加一个新的元素：4
    scala> a += 4
    res35: a.type = ListBuffer(1, 2, 3, 4)
    //4.追加一个列表，该列表包含以下元素：5,6,7
    scala> a ++= ListBuffer(5,6,7)
    res36: a.type = ListBuffer(1, 2, 3, 4, 5, 6, 7)
    //5.删除元素7
    scala> a -= 7
    res37: a.type = ListBuffer(1, 2, 3, 4, 5, 6)
    //6.将可变列表转换为不可变列表
    scala> a.toList
    res38: List[Int] = List(1, 2, 3, 4, 5, 6)
    //7.将可变列表转换为数组
    scala> a.toArray
    res39: Array[Int] = Array(1, 2, 3, 4, 5, 6)

### 1.13.3 列表常用操作 ###

**以下是列表常用的操作：**

1.  判断列表是否为空（`isEmpty`）  
    ![在这里插入图片描述][20210715004829740.png]
2.  拼接两个列表（`++`）  
    ![在这里插入图片描述][20210715005000203.png]
3.  获取列表的首个元素（`head`）和剩余部分(`tail`)  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h3MTY4MA_size_16_color_FFFFFF_t_70 1]
4.  反转列表（`reverse`）  
    ![在这里插入图片描述][20210715005210660.png]
5.  获取前缀（`take`）、获取后缀（`drop`）  
    ![在这里插入图片描述][20210715005421531.png]
6.  扁平化（`flaten`）。扁平化表示将列表中的列表中的所有元素放到一个列表中。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h3MTY4MA_size_16_color_FFFFFF_t_70 2]
7.  拉链（`zip`）和拉开（`unzip`）。拉链：使用 zip 将两个列表，组合成一个元素为元组的列表。拉开：将一个包含元组的列表，解开成包含两个列表的元组。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h3MTY4MA_size_16_color_FFFFFF_t_70 3]
8.  转换字符串（`toString`）
    
        scala> val a = List(1,2,3,4)
        a: List[Int] = List(1, 2, 3, 4)
        
        scala> a.toString
        res52: String = List(1, 2, 3, 4)
9.  生成字符串（`mkString`）
    
        scala> val a = List(1,2,3,4)
        a: List[Int] = List(1, 2, 3, 4)
        
        scala> a.mkString
        res53: String = 1234
        
        scala> a.mkString(":")
        res54: String = 1:2:3:4
10. 并集（`union`）交集（`intersect`） 差集（`diff`）
    
        scala> val a1 = List(1,2,3,4)
        a1: List[Int] = List(1, 2, 3, 4)
        
        scala> val a2 = List(3,4,5,6)
        a2: List[Int] = List(3, 4, 5, 6)
        
        scala> a1.union(a2)
        res55: List[Int] = List(1, 2, 3, 4, 3, 4, 5, 6)
        
        scala> a1.union(a2).distinct
        res56: List[Int] = List(1, 2, 3, 4, 5, 6)
        
        scala> a1.intersect(a2)
        res57: List[Int] = List(3, 4)
        
        scala> a1.diff(a2)
        res58: List[Int] = List(1, 2)

## 1.14 Set ##

Set(集) 是代表没有重复元素的集合。Set 具备以下性质：

1.  元素不重复。
2.  不保证插入顺序。

和 List 正好相反，List：

1.  元素可以重复。
2.  保证插入顺序。

Scala 中的集也分为两种，一种是不可变集，另一种是可变集。

### 1.14.1 不可变集 ###

**语法格式如下：** 创建一个空的不可变集，语法格式：

val/var 变量名 = Set[类型]()

给定元素来创建一个不可变集，语法格式：

val/var 变量名 = Set(元素1, 元素2, 元素3...)

示例代码如下：

scala> val a = Set[Int]()
    a: scala.collection.immutable.Set[Int] = Set()
    
    scala> val a = Set(1,1,3,2,5,9)
    a: scala.collection.immutable.Set[Int] = Set(5, 1, 9, 2, 3)

**基本操作**

1.  获取集的大小（`size`）
2.  遍历集（`和遍历数组一致`）
3.  添加一个元素，生成一个Set（`+`）
4.  拼接两个集，生成一个Set（`++`）
5.  拼接集和列表，生成一个Set（`++`）

示例代码如下：

scala> val a = Set[Int]()
    a: scala.collection.immutable.Set[Int] = Set()
    
    scala> val a = Set(1,1,3,2,5,9)
    a: scala.collection.immutable.Set[Int] = Set(5, 1, 9, 2, 3)
    
    scala> val s = Set(1,1,2,3,4,5)
    s: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)
    
    scala> s.size
    res59: Int = 5
    
    scala> for(i <- s) print(i)
    51234
    
    scala> s - 1
    res62: scala.collection.immutable.Set[Int] = Set(5, 2, 3, 4)
    
    scala> s ++ Set(6,7,8)
    res63: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 8, 4)
    
    scala> s ++ List(6,7,8,9)
    res64: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 9, 2, 7, 3, 8, 4)

### 1.14.2 可变集 ###

可变集合不可变集的创建方式一致，只不过需要提前导入一个可变集类。手动导入：`import scala.collection.mutable.Set`。示例代码如下：

scala> import scala.collection.mutable.Set
    import scala.collection.mutable.Set
    
    scala> val a = Set(1,2,3,4)
    a: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)
    
    scala> a += 5
    res65: a.type = Set(1, 5, 2, 3, 4)
    
    scala> a -= 1
    res66: a.type = Set(5, 2, 3, 4)

## 1.15 Map 对象 ##

Map 可以称之为映射。它是由键值对组成的集合。在 Scala 中，Map 也分为不可变 Map 和可变 Map。

### 1.15.1 不可变 Map ###

**语法格式如下：**

val/var map = Map(键->值, 键->值, 键->值...)	// 推荐，可读性更好
    val/var map = Map((键, 值), (键, 值), (键, 值), (键, 值)...)

示例代码如下：

scala> val map = Map("zhangsan"->30, "lisi"->40)
    map: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 30, lisi -> 40)
    
    scala> val map = Map(("zhangsan", 30), ("lisi", 30))
    map: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 30, lisi -> 30)
    
    scala> map("lisi")
    res67: Int = 30

### 1.15.2 可变 Map ###

定义语法与不可变 Map 一致。但定义可变 Map 需要手动导入 `import scala.collection.mutable.Map`。示例代码如下：

scala> import scala.collection.mutable.Map
    import scala.collection.mutable.Map
    
    scala> val map = Map("zhangsan"->30, "lisi"->40)
    map: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30)
    
    scala> map("zhangsan") = 20

### 1.15.3 Map 基本操作 ###

**基本操作如下：**

1.  获取值 (`map(key)`)。
2.  获取所有 key（`map.keys`）。
3.  获取所有 value（`map.values`）。
4.  遍历 map 集合。
5.  getOrElse。
6.  增加 key,value 对。
7.  删除 key。

示例代码如下：

scala> import scala.collection.mutable.Map
    import scala.collection.mutable.Map
    //1. 定义一个映射，包含以下学生姓名和年龄数据
    scala> val map = Map("zhangsan"->30, "lisi"->40)
    map: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 3
    //2. 获取zhangsan的年龄
    scala> map("zhangsan")
    res69: Int = 30
    //3. 获取所有的学生姓名
    scala> map.keys
    res70: Iterable[String] = Set(lisi, zhangsan)
    //4. 获取所有的学生年龄
    scala> map.values
    res71: Iterable[Int] = HashMap(40, 30)
    //5. 打印所有的学生姓名和年龄
    scala> for((x,y) <- map) println(s"$x $y")
    lisi 40
    zhangsan 30
    //6. 获取wangwu的年龄，如果wangwu不存在，则返回-1
    scala> map.getOrElse("wangwu", -1)
    res73: Int = -1
    //7. 新增一个学生：wangwu, 35
    scala>  map + ("wangwu"->35)
    res74: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30, wangwu -> 35)
    //scala>  map + ("ppp" ->10, "iii" -> 9)
    scala> map + (("ppp", 10), ("iii", 9))
    res75: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30, ppp -> 10, iii -> 9)
    //8. 将lisi从可变映射中移除
    scala> map - "lisi"
    res77: scala.collection.mutable.Map[String,Int] = Map(zhangsan -> 30)

## 1.16 iterator 迭代器 ##

Scala 针对每一类集合都提供了一个迭代器 (iterator) 用来迭代访问集合。

### 1.16.1 使用迭代器遍历集合 ###

1.  使用 `iterator` 方法可以从集合获取一个迭代器。
2.  迭代器的两个基本操作。
    
     *  hasNext——查询容器中是否有下一个元素
     *  next——返回迭代器的下一个元素，如果没有，抛出 NoSuchElementException，每一个迭代器都是有状态的(只能用一次，内部指针只走一次，走到最后就结束了，不会再回到开头，除非你再取得一个新的迭代器)。
3.  迭代完后保留在最后一个元素的位置。
4.  再次使用则抛出 NoSuchElementException。
5.  可以使用 while 或者 for 来逐个返回元素。

示例代码如下：

scala> val a = List(1,2,3,4,5)
    a: List[Int] = List(1, 2, 3, 4, 5)
    
    scala> val ite = a.iterator
    ite: Iterator[Int] = <iterator>
    
    scala> while(ite.hasNext){
        
         | println(ite.next)
         | }
    1
    2
    3
    4
    5

使用 for 表达式和迭代器，遍历打印该列表，示例代码如下：

scala> val a = List(1,2,3,4,5)
    a: List[Int] = List(1, 2, 3, 4, 5)
    
    scala> for(i <- a) println(i)
    1
    2
    3
    4
    5

[20210714160612631.png]: /images/20221004/2498410d5c314943afdeedbfb298669f.png
[20210714161805646.png]: /images/20221004/da80eb9c509f44b7a645382c78831a96.png
[20210714163609974.png]: /images/20221004/30939719fd2d4d8e91047eadf35c8481.png
[image-20210316205637253]: /images/20221004/05dc401576c048f6b1b79036adfd1af1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h3MTY4MA_size_16_color_FFFFFF_t_70]: /images/20221004/81d367c0ae3247128b7e7f4a85cbc2c0.png
[20210715000504744.png]: /images/20221004/e40b4b6b8ac84d9fb8d0c4feab1da219.png
[20210715000607343.png]: /images/20221004/4808a08b25c1404b923dbefc602c89b6.png
[20210715004829740.png]: /images/20221004/2c4e3e5d953a4198ab0aee08e4579e72.png
[20210715005000203.png]: /images/20221004/bfb7e89cc42249ec9e2c6ac46048fbe9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h3MTY4MA_size_16_color_FFFFFF_t_70 1]: /images/20221004/87baa6a3dfd54539a0d3f6ba1651a138.png
[20210715005210660.png]: /images/20221004/6028866473d74a1fadae6c9c0fdd281b.png
[20210715005421531.png]: /images/20221004/2c05b8ce81c24c9cb0a5ed2676f16333.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h3MTY4MA_size_16_color_FFFFFF_t_70 2]: /images/20221004/c5ea11c55a824685acd4c77ac3a52655.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h3MTY4MA_size_16_color_FFFFFF_t_70 3]: /images/20221004/9810d2fc16bd4bf493df84d4b5d73bd3.png