scala学习复习笔记超详细（集合基础）_scala复习资料-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_46964261/article/details/123987148

本文深入探讨Scala集合框架，包括不可变和可变集合的关系图，重点讲解数组Array与ArrayBuffer、元组Tuple、列表List、ListBuffer、队列Queue、映射Map和集Set的定义、操作及转换。详细阐述了各种集合类型的创建、遍历、修改和删除方法，以及它们在并发访问和数据结构上的特性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

Scala集合基础

Scala同时支持不可变集合和可变集合，不可变集合可以安全的并发访问。Scala默认采用不可变集合，对于几乎所有的集合类，Scala都同时提供了可变(mutable)和不可变(immutable)的版本。
两个主要的包：
不可变集合：scala.collection.immutable
可变集合： scala.collection.mutable

Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质，在Scala中集合有可变（mutable）和不可变（immutable）两种类型。
可变集合和不可变集合举例：
不可变集合：Scala不可变集合，就是这个集合本身不能动态变化。(类似java的数组，是不可以动态增长的)
可变集合：可变集合，就是这个集合本身可以动态变化的。(比如：ArrayList , 是可以动态增长的)

package com.atguigu.chapter10;

import java.util.ArrayList;

/**
 * @Date 2021/4/1 15:07
 * @Version 10.21
 * @Author DuanChaojie
 */
public class JavaCollection {
    public static void main(String[] args) {
        // 不可变集合类似java的数组
        int[] nums = new int[3];
        nums[2] = 11; 
        nums[2] = 22;
        //nums[3] = 90; //报错

        String[] names = {"bj", "sh"};
        System.out.println(nums + " " + names);

        //可变集合举例
        ArrayList al = new ArrayList<String>();
        al.add("zs");
        al.add("zs2");

        System.out.println(al + " 地址= " + al.hashCode()); //地址
        al.add("zs3");
        System.out.println(al + " 地址2=" + al.hashCode()); //地址
    }
}

1. Scala不可变集合继承关系一览图

在这里插入图片描述

对上图的总结：

Set、Map是Java中也有的集合
Seq是Java没有的，我们发现List归属到Seq了，因此这里的List就和java不是同一个概念了
我们前面的for循环有一个 1 to 3 ,就是IndexedSeq 下的Vector
String也是属于IndexedSeq
我们发现经典的数据结构比如Queue 和 Stack被归属到LinearSeq
大家注意Scala中的Map体系有一个SortedMap，说明Scala的Map可以支持排序
IndexSeq 和 LinearSeq 的区别
IndexSeq是通过索引来查找和定位，因此速度快，比如String就是一个索引集合，通过索引即可定位
LineaSeq 是线型的，即有头尾的概念，这种数据结构一般是通过遍历来查找，它的价值在于应用到一些具体的应用场景 (电商网站, 大数据推荐系统 ——最近浏览的10个商品)

2. Scala可变集合继承关系一览图☆

在这里插入图片描述

对上图的小结：

在可变集合中比不可变集合更加丰富
在Seq集合中，增加了Buffer 集合，将来开发中，我们常用的有ArrayBuffer和 ListBuffer
如果涉及到线程安全可以选择使用syn…开头的集合
其它的说明参考不可变集合

3. Scala数组Array和ArrayBuffer

定长数组Array

第一种方式定义数组
这里的数组等同于Java中的数组,中括号的类型就是数组的类型
val arr1 = new Array[Int](10)
赋值——集合元素采用小括号访问 arr1(1) = 7

/**
  * @Date 2021/4/1 15:13
  * @Version 10.21
  * @Author DuanChaojie
  */
object ArrayDemo01 {
  def main(args: Array[String]): Unit = {
    /**
      * 说明
      *  1. 创建了一个Array对象,
      *  2. [Int] 表示泛型，即该数组中，只能存放Int
      *  3. [Any] 表示 该数组可以存放任意类型
      *  4. 在没有赋值情况下，各个元素的值 0
      *  5.  arr(3) = 10 表示修改 第4个元素的值
      */
    val arr = new Array[Int](4) //底层 int[] arr = new int[4]
    println(arr.length) // 4

    println("arr01(0)=" + arr(0)) // 0
    //数据的遍历

    for (i <- arr) {
      println(i)
    }

    println("--------------------")

    arr(3) = 10 //修改
    for (i <- arr) {
      println(i)
    }
  }
}

第二种方式定义数组
在定义数组时，直接赋值
使用apply方法创建数组对象 val arr1 = Array(1, 2)

/**
  * @Date 2021/4/1 15:18
  * @Version 10.21
  * @Author DuanChaojie
  */
object ArrayDemo02 {
  def main(args: Array[String]): Unit = {
    /**
      * 说明
      *  1. 使用的是 object Array 的apply方法
      *  2. 直接初始化数组，这时因为你给了 整数和 "", 这个数组的泛型就Any
      *  3. 遍历方式一样
      */
    var arr = Array(1, 3, "xx")
    arr(1) = "xx"

    // 遍历
    for (i <- arr) {
      println(i)
    }

    // 可以使用我们传统的方式遍历，使用下标的方式遍历
    for (index <- 0 until arr.length) {
      printf("arr(%d) = %s", index, arr(index) + "\t")
    }
  }
}

变长数据ArrayBuffer

基本使用和应用案例

声明val arr2 = ArrayBuffer
追元素 arr2.append(7)
重新赋值 arr2(0) = 7

学习集合的流程(创建–>查询–>修改–>删除)

/**
  * @Date 2021/4/1 15:59
  * @Version 10.21
  * @Author DuanChaojie
  */
object ArrayBufferDemo01 {
  def main(args: Array[String]): Unit = {
    // 创建ArrayBuffer
    val arrBuf = ArrayBuffer[Any](3, 2, 5)

    // 通过下标访问数据
    println("arrBuf(1) = " + arrBuf(1))
    // 遍历arrBuf
    for(item <- arrBuf){
      println(item)
    }

    // arrBuf的长度
    println(arrBuf.length)
    println(arrBuf.hashCode())

    // 使用append方法追加数据，append支持可变参数
    arrBuf.append(11,12,13)

    println("------------------------------------")
    arrBuf(4) = 999
    // 再次遍历arrBuf
    for(item <- arrBuf){
      println(item)
    }

    // 根据下标删除数据
    arrBuf.remove(5)

    println("------------------------------------")

    // 再次遍历arrBuf
    for(item <- arrBuf){
      println(item)
    }
  }
}

变长数组分析小结：

ArrayBuffer是变长数组，类似java的ArrayList
val arr2 = ArrayBuffer[Int]() 也是使用的apply方法构建对象
def append(elems: A*) { appendAll(elems) } 接收的是可变参数
每append一次，arr在底层会重新分配空间，进行扩容，arr2的内存地址会发生变化，也就成为新的ArrayBuffer

Array与ArrayBuffer的转换

在开发中，我们可能使用对定长数组和变长数组，进行转换：

arr1.toBuffer：定长数组转可变数组， arr1本身没有变化
arr2.toArray ：定长数组转可变数组， arr2本身没有变化

package com.atguigu.chapter10.array

import scala.collection.mutable.ArrayBuffer

/**
  * @Date 2021/4/1 18:13
  * @Version 10.21
  * @Author DuanChaojie
  */
object ArrayToToArrayBuffer {
  def main(args: Array[String]): Unit = {
    val arrBuf = new ArrayBuffer[Int]()
    arrBuf.append(1, 2, 3, 4)
    // ArrayBuffer(1, 2, 3, 4)
    println(arrBuf)

    /** ArrayBuffer转Array
      * 1. arrBuf.toArray 调用 arrBuf 的方法 toArray
      * 2. 将 ArrayBuffer ---> Array
      * 3. arrBuf本身没有任何变化
      */
    val arr = arrBuf.toArray
    for (item <- arr) {
      println(item)
    }
    println("arr.length = " + arr.length)

    println("--------------------------------------------------")
    val array = new Array[Int](4)
    for (index <- 0 until array.length) {
      array(index) = index
    }

    for (item <- array) {
      println(item)
    }

    println("-------------------------------------------------")
    /**
       Array 转 ArrayBuffer 底层的实现
       override def toBuffer[A1 >: A]: mutable.Buffer[A1] = {
          val result = new mutable.ArrayBuffer[A1](size)
          copyToBuffer(result)
          result
       }
     */
    val buffer = array.toBuffer
    buffer.append(5, 6, 7, 8)
    for (item <- buffer) {
      println(item)
    }
      
  }
}

多维数组的定义和使用

定义 val arr = Array.ofDim[T](3,4)
说明：二维数组中有三个一维数组，每个一维数组中有四个元素
赋值： arr(1)(1) = 11.11

package com.atguigu.chapter10.array

/**
  * @Date 2021/4/1 18:22
  * @Version 10.21
  * @Author DuanChaojie
  */
object MultiplyArray {
  def main(args: Array[String]): Unit = {
    //声明一个二维数组，三行四列
    val arr = Array.ofDim[Int](3, 4)

    // 修改值
    for (i <- 0 until arr.length) {
      for (j <- 0 until arr(i).length) {
        arr(i)(j) = i * j
      }
    }

    // 遍历二维数据arr
    for (i1 <- arr) { //取出二维数组的各个元素（一维数组）
      for (i2 <- i1) {
        print(i2)
      }
      println()
    }

    println("-------------------------------------")
    println(arr(2)(3))

  }
}

Scala数组与Java的List互相转换

/**
  * @Date 2021/4/1 18:36
  * @Version 10.21
  * @Author DuanChaojie
  */
object ArrayBufferToJavaList {
  def main(args: Array[String]): Unit = {
    // Scala集合 和 Java集合互相转换
    val arr = ArrayBuffer("1", "2", "3")
    /**
        implicit def bufferAsJavaList[A](b : scala.collection.mutable.Buffer[A]) : java.util.List[A] = { /* compiled code */ }
     */
    // ProcessBuilder对象，因为这里使用到上面的bufferAsJavaList
    import scala.collection.JavaConversions.bufferAsJavaList
    val javaArr = new ProcessBuilder(arr)
    // 这里arrList 就是java中的List
    val arrList = javaArr.command()

    println(arrList)

    /** asScalaBuffer 是一个隐式函数
    implicit def asScalaBuffer[A](l : java.util.List[A]) : scala.collection.mutable.Buffer[A] = { /* compiled code */ }
     */

    import scala.collection.JavaConversions.asScalaBuffer
    // java.util.List ==> Buffer
    val scalaArr:mutable.Buffer[String] = arrList
    scalaArr.append("jack")
    scalaArr.append("tom")
    scalaArr.remove(0)

    println(scalaArr)

    // 删除
    scalaArr.remove(0)
    println(scalaArr)
  }
}

4. Scala元组Tuple

元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。说的简单点，就是将多个无关的数据封装为一个整体，称为元组, 最多的特点灵活,对数据没有过多的约束。

注意：元组中最大只能有22个元素
元组的创建：
val tuple = (1, 2, 3, "hello", 4)
// Tuple3
final case class Tuple3[+T1, +T2, +T3](_1: T1, _2: T2, _3: T3) 
extends Product3[T1, T2, T3] {
  override def toString() = "(" + _1 + "," + _2 + "," + _3 + ")"
}
访问元组中的数据：

可以采用顺序号（_顺序号）
也可以通过索引（productElement）访问。

Tuple是一个整体，遍历需要调其迭代器tuple.productIterator。

package com.atguigu.chapter10.tuple

/**
  * @Date 2021/4/1 19:29
  * @Version 10.21
  * @Author DuanChaojie
  */
object TupleDemo01 {
  def main(args: Array[String]): Unit = {

    /**
      * 说明
      * 1. tuple 就是一个Tuple类型是Tuple5
      * 2. 简单说明: 为了高效的操作元组 ， 编译器根据元素的个数不同，对应不同的元组类型
      * 3. 分别 Tuple1----Tuple22
      * 4. 元组是只读的不可修改
      */
    val tuple = (1, 2, 3, "hello", 4)


    // 访问元组
    println(tuple)
    // 访问元组的第一个元素，从1开始
    println(tuple._1)
    println(tuple._4)

    /** 访问元组的第一个元素，从0开始
      *
      * @throws(classOf[IndexOutOfBoundsException])
      * override def productElement(n: Int) = n match {
      * case 0 => _1
      * case 1 => _2
      * case 2 => _3
      * case 3 => _4
      * case 4 => _5
      * case _ => throw new IndexOutOfBoundsException(n.toString())
      * }
      */
    println(tuple.productElement(4))

    println("==================遍历元组=========================")
    //遍历元组, 元组的遍历需要使用到迭代器
    for (item <- tuple.productIterator) {
      println(item)
    }

  }
}
/*
final case class Tuple3[+T1, +T2, +T3](_1: T1, _2: T2, _3: T3)
extends Product3[T1, T2, T3] {
  override def toString() = "(" + _1 + "," + _2 + "," + _3 + ")"
}*/

5. Scala列表List和ListBuffer

List

Scala中的List 和Java List 不一样，在Java中List是一个接口，真正存放数据是ArrayList，而Scala的List可以直接存放数据，就是一个object，默认情况下Scala的List是不可变的，List属于序列Seq。
val List = scala.collection.immutable.List
object List extends SeqFactory[List]
创建List应用小结：
List默认为不可变的集合
List 在 scala包对象声明的,因此不需要引入其它包也可以使用val List = scala.collection.immutable.List
List 中可以放任何数据类型，比如 arr1的类型为 List[Any]
如果希望得到一个空列表，可以使用Nil对象, 在 Scala包对象声明的,因此不需要引入其它包也可以使用val Nil = scala.collection.immutable.Nil

List的元素追加：
向列表中增加元素, 会返回新的列表/集合对象。注意：Scala中List元素的追加形式非常独特，和Java不一样。
:+ 元素
+: 集合
:: 表示向集合中添加元素（最后生成新集合）。
:::运算符是将集合中的每一个元素加入到空集合中去
::和:::注意事项
运算时，集合对象一定要放置在最右边。
运算规则，从右向左。

/**
  * @Date 2021/4/1 19:41
  * @Version 10.21
  * @Author DuanChaojie
  */
object ListDemo01 {
  def main(args: Array[String]): Unit = {
    /**
      * 说明
      *  1. 在默认情况下 List 是scala.collection.immutable.List,即不可变
      *  2. 在scala中,List就是不可变的，如需要使用可变的List,则使用ListBuffer
      *  3. List 在 package object scala 做了 val List = scala.collection.immutable.List
      *  4. val Nil = scala.collection.immutable.Nil // List()
      */
    // 创建时，直接分配元素
    val list = List(1, 2, 4)
    // List(1, 2, 4)
    println(list)

    // 空集合
    val nil = Nil
    //List()
    println(nil)

    // 取出list的第二个元素
    println(list(1))

    // 目前list(1,3,4)
    println("----------------list追加元素后的效果-------------------------")
    /**
      * 通过 :+ 和 +: 给list追加元素，生成新的集合，源集合没有变化
      */
    val list1 = list :+ 5

    // List(1, 2, 4, 5)
    println(list1)
    val list2 = 0 +: list1
    // List(0, 1, 2, 4, 5)
    println(list2)

    println("----------------:: 符号的使用-------------------------")
    /**
      * :: 符号的使用
      */
    val list4 = List(1, 2, 3, "abc")
    //说明 val list5 = 4 :: 5 :: 6 :: list4 :: Nil 步骤
    //1. List()
    //2. List(List(1, 2, 3, "abc"))
    //3. List(6,List(1, 2, 3, "abc"))
    //4. List(5,6,List(1, 2, 3, "abc"))
    //5. List(4,5,6,List(1, 2, 3, "abc"))
    val list5 = 4 :: 5 :: 6 :: list4 :: Nil
    println("list5=" + list5)

    //说明 val list6 = 4 :: 5 :: 6 :: list4 ::: Nil 步骤
    //1. List()
    //2. List(1, 2, 3, "abc")
    //3. List(6,1, 2, 3, "abc")
    //4. List(5,6,1, 2, 3, "abc")
    //5. List(4,5,6,1, 2, 3, "abc")
    val list6 = 4 :: 5 :: 6 :: list4 ::: Nil
    println("list6=" + list6)
    println("注意::和:::的区别！")
  }
}

在这里插入图片描述

ListBuffer

ListBuffer是可变的list集合，可以添加，删除元素，ListBuffer属于序列。Seq var listBuffer = ListBuffer(1,2)

package com.atguigu.chapter10.list

import scala.collection.mutable.ListBuffer

/**
  * @Date 2021/4/1 20:01
  * @Version 10.21
  * @Author DuanChaojie
  */
object ListBufferDemo01 {
  def main(args: Array[String]): Unit = {

    // 创建ListBuffer
    val listBuf1 = ListBuffer[Int](1, 2, 3)
    // 遍历listBuf,有序
    for (item <- listBuf1) {
      println(item)
    }
    println(listBuf1(2))
    println("listBuf1 = " + listBuf1)

    println("--------------ListBuffer添加元素----------------")
    // 动态的增加元素，listBuf1就会变化
    val listBuf2 = new ListBuffer[Int] // 空的ListBuffer
    listBuf2 += 4
    println("listBuf2 = " + listBuf2)
    listBuf2.append(5)
    println("listBuf2 = " + listBuf2)

    // ListBuffer(1, 2, 3) listBuf1
    //    +
    // ListBuffer(4, 5) listBuf2
    //    ||
    // ListBuffer(4, 5, 1, 2, 3)
    listBuf2 ++= listBuf1
    println("listBuf2 = " + listBuf2)

    val listBuf3 = listBuf1 ++ listBuf2
    // ListBuffer(1, 2, 3, 4, 5, 1, 2, 3)
    println("listBuf3 = " + listBuf3)
    val listBuf4 = listBuf3 :+ 4
    println("listBuf4 = " + listBuf4)

    println("----------------------listBuf4.remove(4)----------------------------")
    listBuf4.remove(4)
    println("listBuf4 = " + listBuf4)


  }
}

6. Scala队列Queue

队列的应用场景——银行排队的案例

队列的说明：

队列是一个有序列表，在底层可以用数组或是链表来实现。
其输入和输出要遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出
在Scala中，由设计者直接给我们提供队列类型使用。
在scala中, 有 scala.collection.mutable.Queue 和 scala.collection.immutable.Queue , 一般来说，我们在开发中通常使用可变集合中的队列。

package com.atguigu.chapter10.queue

import scala.collection.mutable
/**
  * @Date 2021/4/1 20:17
  * @Version 10.21
  * @Author DuanChaojie
  */
object QueueDemo01 {
  def main(args: Array[String]): Unit = {
    // 创建队列
    val queue1 = new mutable.Queue[Any]
    // 给队列增加元素
    queue1 += 9
    println("queue1 = " + queue1)
    // 直接加在队列后面
    queue1 ++= List(8, 7)
    // queue1 = Queue(9,8,7)
    println("queue1 = " + queue1)

    //queue1 += List(6, 5) // 将List(6,5)作为一个元素加入到队列中
    //queue1 = Queue(9, 8, 7, List(6, 5))

    //queue1.enqueue(1,3,4)
    //queue1.dequeue()
    
    println("queue1 = " + queue1)

    queue1 ++= List(6, 5)
    println("============Queue返回队列的元素=================")
    //队列 Queue返回队列的元素

    //1. 获取队列的第一个元素
    println(queue1.head) //对queue1没有任何影响

    //2. 获取队列的最后一个元素
    println(queue1.last) // 对queue1没有任何影响

    //3. 取出队尾的数据 ,即：返回除了第一个以外剩余的元素，可以级联使用
    println(queue1.tail) //Queue(8, 7, 6, 5)
    println(queue1.tail.tail.tail) // Queue(6, 5)

  }
}

Queue创建： val queue1 = new mutable.Queue[Any]
Queue追加元素：
向队列中追加单个元素和List
+=
++=

按照进入队列的顺序删除元素（队列先进先出）queue1.dequeue()
按照队列的算法，会将数据添加到队列的最后。queue1.enqueue(9, 8, 7)

Queue查看元素：
返回队列的第一个元素queue1.head
返回队列最后一个元素queue1.last
返回队列的尾部queue1.tail
返回除了第一个以外剩余的元素，可以级联使用，这个在递归时使用较多。
也可以这样使用queue1.tail.tail

7. Scala映射Map

HashMap 是一个散列表(数组+链表)，它存储的内容是键值对(key-value)映射，Java中的HashMap是无序的，key不能重复。

public class JavaHashMap {
    public static void main(String[] args) {

        HashMap<String, Integer> hm = new HashMap();

        hm.put("no1", 100);
        hm.put("no2", 200);
        hm.put("no3", 300);
        hm.put("no4", 400);
        hm.put("no1", 500); //更新

        // {no2=200, no1=500, no4=400, no3=300}
        System.out.println(hm);//无序的
        System.out.println(hm.get("no2"));

    }
}

Scala中的Map介绍：

Scala中的Map 和Java类似，也是一个散列表，它存储的内容也是键值对(key-value)映射，Scala中不可变的Map(scala.collection.immutable.Map) 是有序的，可变的Map(scala.collection.mutable.Map)是无序的。
构建Map的四种方式：
Scala中的不可变Map是有序，构建Map中的元素底层是Tuple2类型。
Scala中的可变Map是无序，构建Map中的元素底层是Tuple2类型。
创建空的映射 val map = new scala.collection.mutable.HashMap[String, Int]
对偶元组——即创建包含键值对的二元组，和第一种方式等价，只是形式上不同而已。对偶元组就是只含有两个数据的元组。

Map取值：
方式一：使用map(key)
如果key存在，则返回对应的值
如果key不存在，则抛出异常[java.util.NoSuchElementException]
在Java中，如果key不存在则返回null

方式二：使用contains方法检查是否存在key
如果key存在，则返回true
如果key不存在，则返回false
map.contains("B")
使用containts先判断在取值，可以防止异常，并加入相应的处理逻辑

方式三：使用map.get(key).get取值
通过 映射.get(键) 这样的调用返回一个Option对象，要么是Some，要么是None
map.get方法会将数据进行包装
如果 map.get(key) key存在返回some,如果key不存在，则返回None
如果 map.get(key).get key存在，返回key对应的值,否则，抛出异常 java.util.NoSuchElementException: None.get

方式四：使用map.getOrElse()取值
如果key存在，返回key对应的值。
如果key不存在，返回默认值。在java中底层有很多类似的操作。

如何选择取值方式建议：
如果我们确定map有这个key ,则应当使用map(key), 速度快
如果我们不能确定map是否有key ,而且有不同的业务逻辑，使用map.contains() 先判断在加入逻辑
如果只是简单的希望得到一个值，使用map.getOrElse("ip","127.0.0.1")

package com.atguigu.chapter10.map

import scala.collection.mutable

/**
  * @Date 2021/4/1 20:33
  * @Version 10.21
  * @Author DuanChaojie
  */
object MapDemo01 {
  def main(args: Array[String]): Unit = {
    /**
      * 1.默认map是immutable.Map
      * 2.key-value 类型支持Any
      * 3.在Map的底层，每对key-value 是Tuple2类型
      * 3.有序
      */
    val map1 = Map("dd" -> 18, "mm" -> 19, "tom" -> 22)
    println("map1 = " + map1)

    /**
      * 无序
      */
    val map2 = mutable.Map("dd" -> 18, "mm" -> 19, "tom" -> 22)
    println("map2 = " + map2)

    // 创建空的映射
    val map3 = new mutable.HashMap[String, Int]
    println("map3 = " + map3)

    /**
      * 对偶元组
      */
    val map4 = mutable.Map(("dd", 18), ("mm", 19), ("tom", 22))
    println("map4 = " + map4)

    println("------------------------Map中取值--------------------------------")

    //方式1-使用map(key)
    println(map4("dd")) // 18

    //抛出异常（java.util.NoSuchElementException: key not found:）
    //println(map4("DD"))

    //方式2-使用contains方法检查是否存在key
    if (map4.contains("dd")) {
      println("key存在，值=" + map4("dd"))
    } else {
      println("key不存在:)")
    }

    /**
      * 方式3-使用map.get(key).get取值
      * 1. 如果key存在 map.get(key) 就会返回Some(值)  ,然后Some(值).get就可以取出
      * 2. 如果key不存在 map.get(key) 就会返回None
      */

    println(map4.get("dd").get)
    println(map4.get("DD"))
    //println(map4.get("DD").get)  // 抛出异常

    //方式4-使用map4.getOrElse()取值
    println(map4.getOrElse("DD", "默认的值 鱼 <・)))><<"))
  }
}

更新Map的元素：
map 是可变的，才能修改，否则报错
如果key存在：则修改对应的值，key不存在,等价于添加一个key-val
增加单个元素map += ( "D" -> 4 )
增加多个元素
map4 += ("EE"->1, "FF"->3)
val map5 = map4 + ("E"->1, "F"->3)

删除Map的元素：
map -= ("A", "B")
“A”,“B” 就是要删除的key, 可以写多个
如果key存在，就删除，如果key不存在，也不会报错

Map的遍历：
每遍历一次，返回的元素是Tuple2
取出的时候，可以按照元组的方式来取

package com.atguigu.chapter10.map

import scala.collection.mutable

/**
  * @Date 2021/4/1 20:45
  * @Version 10.21
  * @Author DuanChaojie
  */
object MapDemo02 {
  def main(args: Array[String]): Unit = {
    val map5 = mutable.Map(("A", 1), ("B", "北京"), ("C", 3))
    map5("A") = 20 //修改
    println("map5=" + map5)

    map5 += ("A" -> 100) //修改
    println("map5=" + map5)

    map5 -= ("A", "B", "AAA") //删除map元素，如果没有这个key则忽略
    println("map5=" + map5)

    println("-------------map的遍历-------------------------------")
    val map6 = mutable.Map(("A", 1), ("B", "北京"), ("C", 3))

    println("----(k, v) <- map6--------")
    for ((k, v) <- map6) {
      println(k + "-" + v)
    }

    println("----k <- map6.keys--------")
    for (k <- map6.keys) {
      println(k)
    }
    println("----v <- map6.values--------")
    for (v <- map6.values) {
      println(v)
    }

    //这样取出方式 v 类型是 Tuple2
    println("----v <- map6--------")
    for (v <- map6) {
      println(v + "\t key =" + v._1 + " val=" + v._2) //v是Tuple?
    }

  }
}

8. Scala集Set

集是不重复元素的结合。集不保留顺序，默认是以哈希集实现。
java中，HashSet是实现Set<E>接口的一个实体类，数据是以哈希表的形式存放的，里面的不能包含重复数据。Set接口是一种不包含重复元素的 collection，HashSet中的数据也是没有顺序的。

public class JavaHashSet {
    public static void main(String[] args) {
        // java中的Set的元素 没有顺序，不能重复
        HashSet hs = new HashSet<String>();
        hs.add("jack");
        hs.add("tom");
        hs.add("jack");
        hs.add("jack2");

        // [jack2, tom, jack]
        System.out.println(hs);

    }
}

默认情况下，Scala 使用的是不可变集合，如果你想使用可变集合，需要引用 scala.collection.mutable.Set 包

Set的创建：
val set1 = Set(1, 2, 3) // 不可变
val set2 = mutable.Set(1, 2, "Hello") // 可变

Set的元素追加：
set2.add("tom")
set2 += 3
set2.+=(4)
如果添加的对象已经存在，则不会重复添加，也不会报错

Set元素的删除：
set2 -= 4
set2.remove("hello")

Set集合的遍历

package com.atguigu.chapter10.set

import scala.collection.mutable

/**
  * @Date 2021/4/1 20:51
  * @Version 10.21
  * @Author DuanChaojie
  */
object SetDemo01 {
  def main(args: Array[String]): Unit = {
    val set1 = Set(1, 2, 3) // 不可变
    println("set1 = " + set1)
    println("set1.max = " + set1.max)
    println("set1 min = " + (set1 min))

    val set2 = mutable.Set(1, 2, "Hello") // 可变
    println("set2 = " + set2)

    println("-------------Set添加元素--------------------")
    // 添加元素的三种方式
    set2.add("tom")
    set2 += 3
    set2.+=(4)
    // set2 = Set(1, 2, 3, tom, 4, Hello)
    println("set2 = " + set2)
    println("-------------Set删除元素--------------------")

    set2 -= 4
    println("set2 = " + set2)
    // 方法的形式，scala的Set可以直接删除值
    // 如果删除的对象不存在，则不生效，也不报错
    set2.remove("hello")
    println("set2 = " + set2)

    println("-------------Set集合遍历--------------------")
    for (item <- set2) {
      println(item)
    }
  }
}