Scala基础（2）

1、集合

1.1 数组（Array）

数组中的元素内容要求类型一致
定长数组：数组不可以扩容
不定长数组：数组可以扩容

1.1.1 定长数组

创建一个定长数组的方式：

• 使用new关键字
• 直接使用Array创建并且初始化一个数组
  
  使用Array定义一个定长数组

object ArrayDemo {
def main(args: Array[String]){
//初始化一个长度为8的定长数组，其所有元素均为0
val arr1 = new Array[Int](8)
//直接打印定长数组，内容为数组的hashcode值
println(arr1)
//将数组转换成数组缓冲，就可以看到原数组中的内容了
//toBuffer会将数组转换长数组缓冲
println(arr1.toBuffer)
//注意：如果不使用new获取数组，相当于调用了数组的apply方法，直接为数组赋值
//初始化一个长度为1，值为10的定长数组
val arr2 = Array[Int](10)
//输出数组元素值
println(arr2.toBuffer)
//定义一个长度为3的定长数组
val arr3 = Array("hadoop", "storm", "spark")
//使用()来访问元素
println(arr3(2))
//包含10个整数的数组，初始化值为0
val nums = new Array[Int](10)
//遍历数组
for(i <- 0 until nums.length)
print(s"$i:${nums(i)} ")
println()
//包含10个字符串的数组，初始化值为null
val strs0 = new Array[String](10)
for(i <- 0 until strs0.length)
print(s"$i:${strs0(i)} ")
println()
//赋初值的字符串数组
val strs1 = Array("hello" ,"world")
for(i <- 0 until strs1.length)
print(s"$i:${strs1(i)} ")
println()
//访问并修改元素值
strs1(0) = "byebye"
for(i <- 0 until strs1.length)
print(s"$i:${strs1(i)} ")
println()
}
}

result:

1.1.2 变长数组

定义变长数组的方式：

使用ArrayBuffer定义长度按需变化的数组：

import scala.collection.mutable.ArrayBuffer
object VarArrayDemo {
def main(args: Array[String]){
//定义一个空的可变长Int型数组
val nums = ArrayBuffer[Int]()
//在尾端添加元素
nums += 1
//在尾端添加多个元素
nums += (2,3,4,5)
//使用++=在尾端添加任何集合
nums ++= Array(6,7,8)
//这些操作符，有相应的 -= ，--=可以做数组的删减，用法同+=，++=
执行结果：
4.1.3 定长数组与变长数组的转换
arr1.toBuffer
arr2.toArray
4.1.3. 遍历数组
1.增强for循环,参见变长数组的代码
2.好用的until会生成脚标，0 until 10 包含0不包含10 参见定长数组部分代码4.1.3. 数组转换
4.1.4. 数组转换
yield关键字将原始的数组进行转换会产生一个新的数组，原始的数组不变
//使用append追加一个或者多个元素
nums.append(1)
nums.append(2,3)
//在下标2之前插入元素
nums.insert(2,20)
nums.insert(2,30,30)
//移除最后2元素
nums.trimEnd(2)
//移除最开始的一个或者多个元素
nums.trimStart(1)
//从下标2出移除一个或者多个元素
nums.remove(2)
nums.remove(2,2)
//使用增强for循环进行数组遍历
for(elem <- nums)
println(elem)
//基于下标访问使用增强for循环进行数组遍历
for(i <- 0 until nums.length)
println(nums(i))
}
}

result：

1.1.3 定长数组与变长数组的转换

arr1.toBuffer
arr2.toArray

1.1.4 遍历数组

1.增强for循环,参见变长数组的代码
2.好用的until会生成脚标，0 until 10 包含0不包含10 参见定长数组部分代码

1.1.5 数组转换

使用 yield 关键字将原始的数组进行转换会产生一个新的数组，原始的数组不变

object ArrayTransfer {
def main(args: Array[String]): Unit = {
//使用for推导式生成一个新的数组
val a = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
val res1 = for(elem <- a) yield 2*elem
for(elem <- res1)
print(elem+" ")
println()
//对原数组元素过滤后生成一个新的数组
//将偶数取出乘以10后再生成一个新的数组
val res2 = for(elem <- a if elem%2 == 0)yield 2*elem
for(elem <- res2)
print(elem+" ")
println()
//使用filter和map转换出新的数组
val res3 = a.filter(_ % 2 == 0).map(2 * _)
for(elem <- res3)
print(elem+" ")
println()
}

result：

1.1.6 数组常用方法

object ArrayAlgorithm {
def main(args: Array[String]): Unit = {
val a = Array(9, 1, 2, 5, 3, 7, 8, 4)
//求和
val res1 = a.sum
println(res1)
//求最大值
val res2 = a.max
println(res2)
//排序

result：

1.2 映射（Map）

在scala中，把哈希表这种结构称为映射

1.2.1 构建映射

在Scala中，有两种Map，一个是immutable包下的Map，该Map中的内容不可变；
另一个是mutable包下的Map，该Map中的内容可变。

//构建一个不可变的map
scala> val scores = Map("zhangsan"->90,"lisi"->80,"wangwu"->70)
scores: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 90, lisi -> 80, wangwu ->
70)

//使用元组方式构建
scala> val scores = Map(("zhangsan",90),("lisi",80),("wangwu",70))
scores: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 90, lisi -> 80, wangwu ->
70)

//构建一个可变的map
scala> val scores = scala.collection.mutable.Map(("zhangsan",90),("lisi",80),("wangwu",70))
scores: scala.collection.mutable.Map[String,Int] = Map(lisi -> 80, zhangsan -> 90, wangwu -> 70)

1.2.2 访问映射中的值

根据键获取map中对应的值，可以有以下三种方法，尤其推荐使用getOrElse方法。

scala> val score1 = scores("lisi")
score1: Int = 80
scala> val score2 = if(scores.contains("lisi")) scores("lisi") else 0
score2: Int = 80
scala> val score3 = scores.getOrElse("lisi",0)
score3: Int = 80

1.2.3 修改可变Map

//修改键对应的值
scala> scores("lisi") = 100

scala> scores
res23: scala.collection.mutable.Map[String,Int] = Map(lisi -> 100, zhangsan -> 90, wangwu -> 70)

scala> scores.update("lisi",50)

scala> scores
res25: scala.collection.mutable.Map[String,Int] = Map(lisi -> 50, zhangsan -> 90, wangwu -> 70)

//添加键值对
scala> scores("zhaoliu") = 88

scala> scores
res27: scala.collection.mutable.Map[String,Int] = Map(lisi -> 50, zhangsan -> 90, zhaoliu -> 88,
wangwu -> 70)

scala> scores +=("tom"->77)
res28: scores.type = Map(lisi -> 50, zhangsan -> 90, tom -> 77, zhaoliu -> 88, wangwu -> 70)

scala> val scores2 = Map(("za",90),("lq",80),("wg",70))
scores2: scala.collection.immutable.Map[String,Int] = Map(za -> 90, lq -> 80, wg -> 70)

scala> scores ++= scores2
res30: scores.type = Map(lisi -> 50, zhangsan -> 90, lq -> 80, tom -> 77, zhaoliu -> 88, za ->
90, wg -> 70, wangwu -> 70)

//移除键值对
scala> scores-"lisi"
res31: scala.collection.mutable.Map[String,Int] = Map(zhangsan -> 90, tom -> 77, lq -> 80,
zhaoliu -> 88, za -> 90, wg -> 70, wangwu -> 70)

scala> scores--List("zhangsan","tom")
res33: scala.collection.mutable.Map[String,Int] = Map(lisi -> 50, lq -> 80, zhaoliu -> 88, za ->
90, wg -> 70, wangwu -> 70)

scala> scores-("lisi","lq")
res34: scala.collection.mutable.Map[String,Int] = Map(zhangsan -> 90, tom -> 77, zhaoliu -> 88,
za -> 90, wg -> 70, wangwu -> 70)

1.2.4 遍历Map

//遍历
//返回一个set集合
scala> val res = scores.keySet
res: scala.collection.Set[String] = Set(lisi, zhangsan, lq, tom, zhaoliu, za, wg, wangwu)

scala> for(elem <- res)
| print(elem + " ")
lisi zhangsan lq tom zhaoliu za wg wangwu

//返回一个迭代器
scala> val ite = scores.keys
ite: Iterable[String] = Set(lisi, zhangsan, lq, tom, zhaoliu, za, wg, wangwu)

scala> for (item <- ite)
| print(item + " ")
lisi zhangsan lq tom zhaoliu za wg wangwu

//返回值的迭代器
scala> val values = scores.values
values: Iterable[Int] = HashMap(50, 90, 80, 77, 88, 90, 70, 70)
//返回键值对

scala> for (item <- scores)
| print(item+" ")
(lisi,50) (zhangsan,90) (lq,80) (tom,77) (zhaoliu,88) (za,90) (wg,70) (wangwu,70)

scala> for ((k,v) <- scores)
| print(k+":"+v+" ")
lisi:50 zhangsan:90 lq:80 tom:77 zhaoliu:88 za:90 wg:70 wangwu:70

1.2.5 HashMap

属于可变的map

import scala.collection.mutable
object MutMapDemo extends App{
val map1 = new mutable.HashMap[String, Int]()
//向map中添加数据
map1("spark") = 1
map1 += (("hadoop", 2))
map1.put("storm", 3)
println(map1)
//从map中移除元素
map1 -= "spark"
map1.remove("hadoop")
println(map1)
}

map在底层实现上和HashMap的区别：
the scala.collection.mutable.Map() factory re- turns a scala.collection.mutable.HashMap.

1.2.6 TreeMap

返回按特定顺序排列的元素集合。

scala> import scala.collection.immutable.TreeMap
import scala.collection.immutable.TreeMap

scala> var tm = TreeMap(3 -> 'x', 1 -> 'x', 4 -> 'x')
tm: scala.collection.immutable.SortedMap[Int,Char] =
Map(1 -> x, 3 -> x, 4 -> x)

scala> tm += (2 -> 'x')

scala> tm
res38: scala.collection.immutable.SortedMap[Int,Char] =
Map(1 -> x, 2 -> x, 3 -> x, 4 -> x)

1.3 元组

1.3.1 创建访问元组

创建元组：使用小括号将多个元素括起来，元素之间用逗号分隔，元素的类型和个数任意，
访问组元：使用_1， _2， _3等访问组元。
第二种方式定义的元组也可以通过a,b,c去访问组元。
另一种定义方式：val tuple3 = new Tuple3(1, 3.14, “Fred”)
元组的实际类型取决于它的元素的类型，比如 (99, “runoob”) 是 Tuple2[Int, String]。 (‘u’, ‘r’, “the”, 1, 4, “me”) 为
Tuple6[Char, Char, String, Int, Int, String]。
目前 Scala 支持的元组最大长度为 22。对于更大长度你可以使用集合，或者扩展元组。

1.3.2 元组访问

//注意元组元素的访问有下划线，并且访问下标从1开始，而不是0

val value1 = tuple3._3
println(value1)

1.3.3 元组遍历

方式1：

for (elem <- tuple1.productIterator) {
print(elem)
}
println()

方式2：

tuple1.productIterator.foreach(i => println(i))
tuple1.productIterator.foreach(print(_))

1.3.4 拉链操作

可以使用zip将元组的多个值绑定在一起，方便使用

注意：如果两个数组的元素个数不一致，拉链操作后生成的数组的长度为较小的那个数组的元素个数

1.4 列表（List）

列表是同质的，列表中的元素类型是一致的。
列表是有序的。

1.4.1 不可变列表

1.4.1.1 不可变列表的构造
不可变的序列 import scala.collection.immutable._

scala> val fruit = List("apples", "oranges", "pears")
fruit: List[String] = List(apples, oranges, pears)

scala> val nums = List(1, 2, 3, 4)
nums: List[Int] = List(1, 2, 3, 4)

scala> val diag3 =
| List(
| List(1, 0, 0),
| List(0, 1, 0),
| List(0, 0, 1)
| )
diag3: List[List[Int]] = List(List(1, 0, 0), List(0, 1, 0), List(0, 0, 1))

scala> val empty = List()
empty: List[Nothing] = List()

//所有的列表可以看做是由两个基础构造快Nil和中缀操作符::构成，::表示从列表前段扩展。
//在Scala中列表要么为空（Nil表示空列表）要么是一个head元素加上一个tail列表。
//9 :: List(5, 2) :: 操作符是将给定的头和尾创建一个新的列表
//注意：:: 操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))
scala> val fruit = "apples" :: ("oranges" :: ("pears" :: Nil))
fruit: List[String] = List(apples, oranges, pears)

scala> val diag3 = (1 :: (0 :: (0 :: Nil))) ::(0 :: (1 :: (0 :: Nil))) ::(0 :: (0 :: (1 ::
Nil))) :: Nil
diag3: List[List[Int]] = List(List(1, 0, 0), List(0, 1, 0), List(0, 0, 1))

scala> val empty = Nil
empty: scala.collection.immutable.Nil.type = List()
//注意：:: 操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))

scala> val nums =1::(2::(3::(4::Nil)))
nums: List[Int] = List(1, 2, 3, 4)

scala> val nums = 1 :: 2 :: 3 :: 4 :: Nil
nums: List[Int] = List(1, 2, 3, 4)

scala> val nums = 1 :: 2 :: 3 :: 4 :: Nil
nums: List[Int] = List(1, 2, 3, 4)

//注意是否加Nil的区别
scala> val nums = 1 :: 2 :: 3 :: 4
:7: error: value :: is not a member of Int
val nums = 1 :: 2 :: 3 :: 4
^
scala> val nums = 1 :: 2 :: 3 :: 4 :: list0
nums: List[Int] = List(1, 2, 3, 4, 5, 6)

scala> val nums = 1 :: 2 :: 3 :: 4 :: list0 :: Nil
nums: List[Any] = List(1, 2, 3, 4, List(5, 6))

1.4.1.2 列表的访问

scala> val nums = 1 :: 2 :: 3 :: 4 :: list0 :: Nil
nums: List[Any] = List(1, 2, 3, 4, List(5, 6))

scala> nums(1)
res22: Any = 2

scala> nums(3)
res23: Any = 4

1.4.1.3 列表的追加

object ImmutListDemo {
def main(args: Array[String]) {
//创建一个不可变的集合
val lst1 = List(1,2,3)
//将0插入到lst1的前面生成一个新的List ::和+：右结合
val lst2 = 0 :: lst1
val lst3 = lst1.::(0)
val lst4 = 0 +: lst1
val lst5 = lst1.+:(0)
//将一个元素添加到lst1的后面产生一个新的集合，:+左结合
val lst6 = lst1 :+ 3
val lst0 = List(4,5,6)
//将2个list合并成一个新的List
val lst7 = lst1 ++ lst0
//将lst1插入到lst0前面生成一个新的集合
val lst8 = lst1 ++: lst0
//将lst0插入到lst1前面生成一个新的集合
val lst9 = lst1.:::(lst0)
println(lst9)
}
}

1.4.1.4 列表的基本操作
对列表的所有操作可以表达为一下三种
head 返回列表的第一个元素。 tail 返回除第一个元素之外所有元素组成的列表。
isEmpty 返回列表是否为空。
注意：其中tail head作用在空列表上，会报异常。

scala> val nums =1::(2::(3::(4::Nil)))
nums: List[Int] = List(1, 2, 3, 4)

scala> nums.head
res5: Int = 1

scala> nums.tail
res6: List[Int] = List(2, 3, 4)

scala> nums.isEmpty
res7: Boolean = false

1.4.1.5 列表的模式拆分
列表可以使用模式匹配进行拆分。

scala> val fruit = List("apples", "oranges", "pears")
fruit: List[String] = List(apples, oranges, pears)

//给出的元素个数与列表的元素个数一致，否则会报错。
scala> val List(a, b, c) = fruit
a: String = apples
b: String = oranges
c: String = pears

//在元素个数不可知的情况下,最好使用::匹配。
scala> val a :: b :: rest = fruit
a: String = apples
b: String = oranges
rest: List[String] = List(pears)

1.4.1.6 列表的常用方法
列表可以使用模式匹配进行拆分。

//连接操作
scala> List(1, 2) ::: List(3, 4, 5)
res8: List[Int] = List(1, 2, 3, 4, 5)

scala> List(1, 2) ::: List(3, 4, 5) ::: List(6,7,8)
res9: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8)

scala> List(1, 2) ::: (List(3, 4, 5) ::: List(6,7,8))
res10: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8)

//求列表长度
scala> List(1,2,3).length
res11: Int = 3

//与head，tail对应的last init
scala> val abcde = List('a', 'b', 'c', 'd', 'e')
abcde: List[Char] = List(a, b, c, d, e)

scala> abcde.last
res12: Char = e

scala> abcde.init
res13: List[Char] = List(a, b, c, d)

//反转列表
scala> abcde.reverse
res14: List[Char] = List(e, d, c, b, a)

//tail,init的泛化
//提取列表的前n个元素
scala> abcde take 2
res15: List[Char] = List(a, b)

//丢弃列表的前n个元素
scala> abcde drop 2
res16: List[Char] = List(c, d, e)

scala> abcde splitAt 2
res17: (List[Char], List[Char]) = (List(a, b),List(c, d, e))

scala> List(abcde take 2, abcde drop 2)
res18: List[List[Char]] = List(List(a, b), List(c, d, e))

//拉链操作
scala> abcde zip List(1,2,3,4,5)
res22: List[(Char, Int)] = List((a,1), (b,2), (c,3), (d,4), (e,5))

1.4.1.7 列表的高阶方法

//映射：map, flatMap， foreach
scala> List(1,2,3).map(_+1)
res23: List[Int] = List(2, 3, 4)

scala> val words = List("the", "quick", "brown", "fox")
words: List[String] = List(the, quick, brown, fox)

scala> words.map(_.length)
res24: List[Int] = List(3, 5, 5, 3)

scala> words map (_.toList.reverse.toString)
res25: List[String] = List(List(e, h, t), List(k, c, i, u, q), List(n, w, o, r, b), List(x, o,
f))

scala> words map (_.toList.reverse.mkString)
res26: List[String] = List(eht, kciuq, nworb, xof)

scala> words map (_.toList)
res27: List[List[Char]] = List(List(t, h, e), List(q, u, i, c, k), List(b, r, o, w, n), List(f,
o, x))

scala> words flatMap (_.toList)
res28: List[Char] = List(t, h, e, q, u, i, c, k, b, r, o, w, n, f, o, x)

scala> var sum = 0
sum: Int = 0

scala> List(1, 2, 3, 4, 5) foreach (sum += _)
//过滤 filter, partition, find, takeWhile, dropWhile, span

scala> List(1, 2, 3, 4, 5) filter (_ % 2 == 0)
res37: List[Int] = List(2, 4)

scala> words filter (_.length == 3)
res38: List[java.lang.String] = List(the, fox)

scala> List(1, 2, 3, 4, 5) partition (_ % 2 == 0)
res30: (List[Int], List[Int]) = (List(2, 4),List(1, 3, 5))

scala> List(1,2,3,4,5)find(_%2==0)
res31: Option[Int] = Some(2)

scala> List(1, 2, 3, 4, 5) find (_ <= 0)
res32: Option[Int] = None

scala> List(1, 2, 3, -4, 5) takeWhile (_ > 0)
res33: List[Int] = List(1, 2, 3)

scala> words dropWhile (_ startsWith "t")
res34: List[String] = List(quick, brown, fox)

scala> List(1, 2, 3, -4, 5) span (_ > 0)
res35: (List[Int], List[Int]) = (List(1, 2, 3),List(-4, 5))

//排序sortWith
scala> words.sortWith(_.length > _.length)
res40: List[String] = List(quick, brown, the, fox)

1.4.2 可变列表

import scala.collection.mutable.ListBuffer
object MutListDemo extends App{
//构建一个可变列表，初始有3个元素1,2,3
val lst0 = ListBuffer[Int](1,2,3)
//创建一个空的可变列表
val lst1 = new ListBuffer[Int]
//向lst1中追加元素，注意：没有生成新的集合
lst1 += 4
lst1.append(5)
//将lst1中的元素最近到lst0中， 注意：没有生成新的集合
lst0 ++= lst1
//将lst0和lst1合并成一个新的ListBuffer 注意：生成了一个集合
val lst2= lst0 ++ lst1
//将元素追加到lst0的后面生成一个新的集合
val lst3 = lst0 :+ 5
}

1.5 Set

创建集合
不可变：

import scala.collection.immutable.HashSet
object ImmutSetDemo extends App{
val set = Set(1,2,3)
println(set.getClass.getName) //
val set1 = new HashSet[Int]()
//将元素和set1合并生成一个新的set，原有set不变
val set2 = set1 + 4
//set中元素不能重复
val set2 = set1 + 4
//set中的元素是随机无序的
print(set0)
println(set0.getClass)
}

可变：

import scala.collection.mutable
object MutSetDemo extends App{
This object provides a set of operations needed to create Set values. The current default
implementation of a Set is one of EmptySet, Set1, Set2, Set3, Set4 in class immutable.Set for
sets of sizes up to 4, and a immutable.HashSet for sets of larger sizes.
val mutableSet = Set(1,2,3)
println(mutableSet.getClass.getName) // scala.collection.mutable.HashSet
//创建一个可变的HashSet
val set1 = new mutable.HashSet[Int]()
//向HashSet中添加元素
set1 += 2
//add等价于+=
set1.add(4)
//删除一个元素
set1 -= 5
set1.remove(2)
println(set1)
}

2. 集合的重要函数

2.1 sum/max/min/count

在序列中查找最大或最小值是一个极常见的需求，较常用于面试问题和算法。还记得 Java 中的代码行吗？如下：

int[] arr = {11, 2, 5, 1, 6, 3, 9};
int to = arr.length - 1;
int max = arr[0];
for (int i = 0; i < to; i++)
{ if (max < arr[i+1]) max = arr[i+1]; }
System.out.println(max);

问题：怎么在 List 中找到最大/最小值呢？
Scala 推荐了一个很赞的解决方案：

val numbers = Seq(11, 2, 5, 1, 6, 3, 9)
numbers.max //11
numbers.min //1

更高级的例子，其中包含一个书的序列：

case class Book(title: String, pages: Int)
val books = Seq( Book("Future of Scala developers", 85),
Book("Parallel algorithms", 240),
Book("Object Oriented Programming", 130),
Book("Mobile Development", 495) )
//Book(Mobile Development,495)
books.maxBy(book => book.pages)
//Book(Future of Scala developers,85)
books.minBy(book => book.pages)

如上所示，minBy & maxBy 方法解决了复杂数据的问题。你只需选择决定数据最大或最小的属性。

2.2 过滤

举个栗子：过滤一个数字 List，只获取奇数的元素。

val numbers = Seq(1,2,3,4,5,6,7,8,9,10) numbers.filter(n => n % 2 == 0)

val books = Seq( Book("Future of Scala developers", 85),
Book("Parallel algorithms", 240),
Book("Object Oriented Programming", 130),
Book("Mobile Development", 495) )
books.filter(book => book.pages >= 120)

还有一个与 filter 类似的方法是 filterNot。它的名字就体现了它的作用。可以用 filterNot 替换 filter 方法试试看

2.3 Flatten

当有一个集合的集合，然后你想对这些集合的所有元素进行操作时，就会用到 flatten。

val abcd = Seq('a', 'b', 'c', 'd')
val efgj = Seq('e', 'f', 'g', 'h')
val ijkl = Seq('i', 'j', 'k', 'l')
val mnop = Seq('m', 'n', 'o', 'p')
val qrst = Seq('q', 'r', 's', 't')
val uvwx = Seq('u', 'v', 'w', 'x')
val yz = Seq('y', 'z')
val alphabet = Seq(abcd, efgj, ijkl, mnop, qrst, uvwx, yz)
//
// List(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t,
// u, v, w, x, y, z)
alphabet.flatten

2.4 集合之间的操作

差集、交集和并集

val num1 = Seq(1, 2, 3, 4, 5, 6)
val num2 = Seq(4, 5, 6, 7, 8, 9)
//List(1, 2, 3)
num1.diff(num2)
//List(4, 5, 6)
num1.intersect(num2)
//List(1, 2, 3, 4, 5, 6, 4, 5, 6, 7, 8, 9)
num1.union(num2)

上述示例中的 union 保留了重复的元素。如果我们不需要重复怎么办？这时可以使用 distinct 函数

//List(1, 2, 3, 4, 5, 6, 7, 8, 9)
num1.union(num2).distinct

2.5 map() 列表元素

map 是 Scala 集合最常用的一个函数。它的功能十分强大

val numbers = Seq(1,2,3,4,5,6)
//List(2, 4, 6, 8, 10, 12)
numbers.map(n => n * 2)
val chars = Seq('a', 'b', 'c', 'd')
//List(A, B, C, D)
chars.map(ch => ch.toUpper)

map 函数的逻辑是遍历集合中的元素并对每个元素调用函数。你也可以不调用任何函数，保持返回元素本身，但
这样 map 无法发挥作用，因为你在映射过后得到的是同样的集合。