Scala 数据结构-集合

气质&末雨

已于 2023-01-06 11:54:21 修改

阅读量419

点赞数

分类专栏： scala 文章标签： scala java 开发语言

于 2023-01-03 17:44:50 首次发布

本文链接：https://blog.csdn.net/m0_72168501/article/details/128536127

版权

scala 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

文章目录

Scala 数据结构-集合

Scala 数据结构-集合

一、集合简介

1）Scala的集合有三大类：序列seq，集合Set，映射Map，所有的集合都扩展自Iterable特质.
2）对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本，分别位于以下两个包
不可变集合：scala.collection.immutable
可变集合：scala.collection.mutable
3）Scala不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而不会对原对象进行修改，类似于java中的String对象
4）可变集合，就是这个集合可以直接对原对象进行修改，而不会返回新的对象，类似于java中的StringBuilder对象
小窍门建议：在操作集合的时候，不可变用符号，可变用方法
注意：要是不可变的集合类型做操作是赋值给一个新的对象，然后原来的集合是不会有改变的，如果是可变的那么就是在原来的集合上做操作

1、不可变集合继承图

seq 序列相当于替代的是Java里面的list 列表
1）Set，Map是Java中也有的集合
2）Seq是Java中没有的，我们发现List归属到Seq了，因此这里的List就和Java不是同一个概念了
在这里插入图片描述

2、可变集合继承图

在这里插入图片描述

二、数组

Scala 是比较推荐使用不可变数组的，不可变数组是Array 可变数组是ArrayBuffer

1、不可变数组

(1) 创建数组

1）第一种方式定义数组
定义：val arr1 = new Array[Int]（10）
(1) new 是关键字
(2) [Int] 是指可以存放的数据类型，如果希望存放任意数据类型，则指定Any []里面是泛型，只是Java里的是<>
(3) (10)，表示数组的大小，确定后就不可以变化
2）第二种创建数组方式
val arr2 = Array(12,21,23,66,97) //可以直接创建的时候赋值，我比较喜欢这种，其实是Array.apply() 但是apply可以省略
3) 案例示例
这下面说了两种创建数组的方式，第一种是使用泛型，创建的时候，没有赋值，所有的元素都为0，第二种是使用了apply方法，我更喜欢第二种。可以创建的时候直接赋值

package Scala03_shujujiegou
//不可变数组
class test01_bukebian {

}
object test01_bukebian{
  def main(args: Array[String]): Unit = {
    //1、创建一个不可变的数组
    val arr1:Array[Int] = new Array[Int](10)  //创建一个大小为10，长度为10的数组
    //2、另一种创建方式 这种方式比较棒
    val arr2 = Array(5,12,46,58,97)  //可以通过Array.apply(12)方法创建，然后apply可以省略，创建了长度为5的数组
    
  }
}

(2) 访问数组

访问是arr1(0) 括号里面是索引，是() 不是 []，可以对属性值进行修改，但是不可变数组的添加和删除操作做不了

package Scala03_shujujiegou
//不可变数组
class test01_bukebian {

}
object test01_bukebian{
  def main(args: Array[String]): Unit = {
    //1、创建一个不可变的数组
    val arr1:Array[Int] = new Array[Int](10)  //创建一个大小为10，长度为10的数组
    //2、另一种创建方式 这种方式比较棒
    val arr2 = Array(5,12,46,58,97)  //可以通过Array.apply(12)方法创建，然后apply可以省略，创建了长度为5的数组
    println(arr2.apply(1))
    println(arr1.apply(2))

    //3、访问方式  删除数据和插入数据对于不可变数组是做不到的,但是对于改变某个位置上的值是可以做到的
    println(arr1(0)) //访问很简单。直接arr() 里面是索引 是()不是[]
    println(arr2(0))
    //println(arr1(10)) //这里为10的话那么就越界了

    arr1(0) = 12  //赋值也是按照访问的方式，然后进行赋值，再进行访问就可以了
    arr1(4) = 97
    println(arr1(0))
    println(arr1(4))

  }
}

(3) 遍历数组

因为数组只有五个值，一个一个进行访问还是比较简单，但是要是有500个数，不可能一行一行的500行代码，所以要遍历数组
总结：这些遍历的方法不只是数组可以用，其他的数据类型也可以用
下面一共五个遍历数组的方法：
1、普通for循环
for(i <- 0 until arr.length){ println(arr(i)) }
2、增强for循环，不遍历索引，只遍历元素
for(i <- arr){ println(i) }
3、迭代器一般使用while循环，就两个方法，判断写一个元素存不存在，存在就输出下一个元素
val iter = arr.iterator while(iter.hasNext){ println(iter.next) }
4、forEach 方法
arr.forEach((i:Int)=>println(i)) //这个里面的参数是一个函数
arr.forEach(println) //可以简化成直接println，里面参数
5、mkString 将数组里的元素连在一起输出，这个也非常好用，对应的是python里的join
arr.mkString(",")

package Scala03_shujujiegou
//不可变数组
class test01_bukebian {

}
object test01_bukebian{
  def main(args: Array[String]): Unit = {
    //1、创建一个不可变的数组
    val arr1:Array[Int] = new Array[Int](10)  //创建一个大小为10，长度为10的数组
    //2、另一种创建方式 这种方式比较棒
    val arr2 = Array(5,12,46,58,97)  //可以通过Array.apply(12)方法创建，然后apply可以省略，创建了长度为5的数组
    println(arr2.apply(1))
    println(arr1.apply(2))

    //3、访问方式  删除数据和插入数据对于不可变数组是做不到的,但是对于改变某个位置上的值是可以做到的
    println(arr1(0)) //访问很简单。直接arr() 里面是索引 是()不是[]
    println(arr2(0))
    //println(arr1(10)) //这里为10的话那么就越界了

    arr1(0) = 12  //赋值也是按照访问的方式，然后进行赋值，再进行访问就可以了
    arr1(4) = 97
    println(arr1(0))
    println(arr1(4))
    println("====================")

    //4、数组的遍历
    // 1) 普通for循环
    //报黄说明不是最简单的实现方式，但是我比较喜欢这种
    for(i <- 1 until  arr2.length){ //scala里面用until 就可以不用数组-1了
      println(arr2(i))
    }
    println("==================")
    for(i <- arr2.indices){
      println(arr2(i))
    }
    println("=================")

    //2) 增强for循环
    //其实访问一个集合里面的元素，没有必要非要去遍历他的索引，我们根本不去考虑索引，只是想要将所有的数据打印输出
    //直接遍历所有元素，增强for循环
    for(i <- arr2){ //直接从数组里面拿数，就不用索引了
      println(i)

    }

    println("=============")
    //3）迭代器
    val iter = arr2.iterator //定义一个迭代器，数组.iterator方法
    while (iter.hasNext){  //一般迭代器使用while循环，因为就两个方法，如果存在，就输出下一个
      println(iter.next())
    }
    println("=============")

    //4) 调用forEach方法 跟增强for循环完全等价，都是直接输出的元素
    //所有的集合类型都可以调forEach方法,只不过具体的实现，可能略有不同
    arr2.foreach((i:Int) => println(i)) //他这里面的参数应该是一个函数，然后我写的lamdam表达式，i int类型，然后要做的操作是输出元素
    arr2.foreach(println) //可以简化成直接一个println ，因为数组是Int类型那系统可以自己推断，然后变量i可以用_代替
    //5) mkString 方法，将所有数连在一起输出，这个也很方便
    println(arr2.mkString(",")) //要是想把所有数连在一起输出，使用mkString方法


  }
}

(4) 添加元素

因为不可变数组是不可以直接添加元素的，所以我们赋值个一个新的变量对象，然后就可以进行修改了，然后调用这个新的数组
有两种方式：推荐第二个方法
第一种：
val arr3 = arr2.:+(13) //这样是加在原数组的后面
val arr3 = arr2.+:(14) //吧.+: 这个+和：反过来就是在前面加
第二种：
var arr4 = 66 +: 12+: arr2 :+ 14 :+ 13 // + 在前面的就是加在数组的前面，+在后面的就是加在数组的后面，就非常直观了，不容易搞错，而且还可以一次性添加多个

package Scala03_shujujiegou
//不可变数组
class test01_bukebian {

}
object test01_bukebian{
  def main(args: Array[String]): Unit = {
    //1、创建一个不可变的数组
    val arr1:Array[Int] = new Array[Int](10)  //创建一个大小为10，长度为10的数组
    //2、另一种创建方式 这种方式比较棒
    val arr2 = Array(5,12,46,58,97)  //可以通过Array.apply(12)方法创建，然后apply可以省略，创建了长度为5的数组
    println(arr2.apply(1))
    println(arr1.apply(2))

    //3、访问方式  删除数据和插入数据对于不可变数组是做不到的,但是对于改变某个位置上的值是可以做到的
    println(arr1(0)) //访问很简单。直接arr() 里面是索引 是()不是[]
    println(arr2(0))
    //println(arr1(10)) //这里为10的话那么就越界了

    arr1(0) = 12  //赋值也是按照访问的方式，然后进行赋值，再进行访问就可以了
    arr1(4) = 97
    println(arr1(0))
    println(arr1(4))
    println("====================")

    //4、数组的遍历
    // 1) 普通for循环
    //报黄说明不是最简单的实现方式，但是我比较喜欢这种
    for(i <- 1 until  arr2.length){ //scala里面用until 就可以不用数组-1了
      println(arr2(i))
    }
    println("==================")
    for(i <- arr2.indices){
      println(arr2(i))
    }
    println("=================")

    //2) 增强for循环
    //其实访问一个集合里面的元素，没有必要非要去遍历他的索引，我们根本不去考虑索引，只是想要将所有的数据打印输出
    //直接遍历所有元素，增强for循环
    for(i <- arr2){ //直接从数组里面拿数，就不用索引了
      println(i)

    }

    println("=============")
    //3）迭代器
    val iter = arr2.iterator //定义一个迭代器，数组.iterator方法
    while (iter.hasNext){  //一般迭代器使用while循环，因为就两个方法，如果存在，就输出下一个
      println(iter.next())
    }
    println("=============")

    //4) 调用forEach方法 跟增强for循环完全等价，都是直接输出的元素
    //所有的集合类型都可以调forEach方法,只不过具体的实现，可能略有不同
    arr2.foreach((i:Int) => println(i)) //他这里面的参数应该是一个函数，然后我写的lamdam表达式，i int类型，然后要做的操作是输出元素
    arr2.foreach(println) //可以简化成直接一个println ，因为数组是Int类型那系统可以自己推断，然后变量i可以用_代替
    //5) mkString 方法，将所有数连在一起输出，这个也很方便
    println(arr2.mkString(",")) //要是想把所有数连在一起输出，使用mkString方法

    println("===========")

    //添加元素
    //因为不可变数据是不可以添加数据的
    //我们说的不是直接在当前数组上直接改变这个数组，而是说添加元素之后，我们再把它作为一个新的数组返回
    val arr3 = arr2.:+(17) //.:+() 然后里面是要添加的元素 直接调用的话还是原来的数组，因为不可变数组是不可以改变的，我们把他创建一个新的对象
    println(arr3.mkString(",")) //赋值给新的变量，就可以看到添加成功了

    //不只是可以在最后面进行添加，也可以在前面进行添加
    val arr4 = arr2.+:(18) //把.:+ 改为 .+: 就成在前面添加元素了
    println(arr4.mkString(","))
    arr4.foreach(println)

    println("===============")
    //这个样子看不懂的话，下面这种比较棒 这个有点像链表的那种添加
    val arr5 = 13 +: 12 +: arr2 :+ 15 //这个样子+：然后数字写在前面就是在前面加 :+ 这样就是在后面加
    println(arr5.mkString(","))


  }
}

在这里插入图片描述

2、可变数组

/不可变数组是Array 可变数组是ArrayBuffer

(1) 创建数组

两种创建方式：
第一种：
val arr1 = new ArrayBuffer【Int】() //这个()里面是数组的长度，不传参数默认是16
第二种：
val arr2 = ArrayBuffer(15,23,66,75,89) //跟创建不可变数组的时候一样，创建的时候可以直接赋值
说明：调用的时候，可以至直接输出这个数组，println(arr2) 然后就可以直接取出来了，都不用遍历，因为底层默认有个toString方法，可以写出来，也可以不写出来

package Scala03_shujujiegou

import scala.collection.mutable.ArrayBuffer

//可变数组
class test02_kebian {

}
object test02_kebian{
  def main(args: Array[String]): Unit = {
    //1、创建一个可变数组  创建可变数组也有两种方式
    var arr1:ArrayBuffer[Int] = new ArrayBuffer[Int]()  //[] 泛型，()不传参数默认大小是16
    //2、第二种方法
    val arr2 = ArrayBuffer(12,13,46,47,48) //跟创建不可变数组的第二种方式一样，创建的时候可以直接赋值
    println(arr1.mkString(",")) //arr1 什么都没有，是空的
    println(arr2.mkString(","))
    println(arr2.toString())  //可变数组可以直接这样输出，输出的不是引用地址，因为默认有toString方法
    //toString方法将StringBuffer 类型转换为String类型
    
  }
}

(2) 访问数组

访问数组还是个之前不可变数组一样，直接 println(arr2(2)) 里面直接输出数组，然后括号里面是索引，修改也是一样的，直接赋值就可以了arr2(2) = 66，修改之后再输出就行了
那几种遍历方式在所有的集合类型中都是通用的，这里就不重复了
在这里插入图片描述

(3) 添加元素

添加元素跟之前不可变数组不一样 val arr3 = 12 +: arr2 :+ 13 +在前面的就是把元素添加在数组的前面，+在后面的就是把元素添加在数组的后面。可变数组是直接+=这样就把元素添加到了数组的最后面，把元素添加到数组前面 77 +=: arr1，可变数组不建议把值赋给另外一个新的对象，那样两个对象就指向同一个内存地址了，新的数组改变原数组也会改变，前面这种各种符号容易搞混。推荐使用第二种用方法添加，append() 添加到数组的后面，prepend() 添加到数组的前面
在这里插入图片描述
第二种方法：
使用方法添加，append() 在数组的后面添加，prepend() 在数组的前面添加，而且可以添加多个，insert() 在任意位置添加元素，第一个参数是索引，第二个参数是数值，而且可以传入多个，还有可以传入一个数组进去，arr1.insetrall(1,arr2)第一个参数还是索引，第二个参数是传入数组的位置，appendall(arr2) 还是将数组添加到数组的最后面，prepend(arr2) 将数组添加到数组的最前面
在这里插入图片描述

(4) 删除元素

使用remove()方法，里面一个参数是要删除的元素的索引，两个参数，第一个是索引，第二个是连续删除多少个元素，或者可以使用-=，如果没有这个数那么就相当于没有做操作
在这里插入图片描述

3、可变数组与不可变数组的转化

将可变数组转化为可变数组，toArray方法，就不可变方法转化为可变数组，toBuffer方法
在这里插入图片描述

4、多维数组

创建二维数组，使用Array方法下面的ofDim()方法，里面一个参数就是一维数组，两个参数就是二维数组，最多五维，val arr = Array.ofDim(2)(3) 表示的是一个两行三列的一个二维数组，访问元素跟一维数组是一样的，添加元素还是通过索引赋值，遍历数组要使用双重for循环，还可以使用foreach方法，其他的方法不行，其他的只会打印出引用地址

package Scala03_shujujiegou
//多维数组
class test03_duoweishuzu {

}
object test03_duoweishuzu{
  def main(args: Array[String]): Unit = {
    //1、创建一个二维数组 使用ofDim()方法
    //这个[]泛型可以指定也可以不指定,2,3表示的是两行三列的二维数组
    val array = Array.ofDim[Int](2,3) //如果传一个参数就是一维数组，两个参数就是二维数组，最多有5维

    //2、二维数组访问元素
    array(0)(2) = 19 //取第一行第三列的那个数，当然也可以直接更改，直接赋值
    //println(array(0)(2))

    array(1)(0)= 12 //第二行的第一个数
    //要想遍历二维数组，得用双重for循环进行遍历，其他的都打印的是引用地址
    for(i <- 0 until array.length){
      for (j <- 0 until array.length){
        println(array(i)(j))
//        print(array(i)(j) + "\t")
//        if(j == array(i).length -1){
//          println() //如果j是这一行的最后一个那么就直接换行
//        }
      }
    }

    println("==============")
    //用foreach 进行遍历
    array.foreach(line => line.foreach(println)) //按行进行输出
  }
}

三、列表 List

在Scala中，列表和数组是两种不同的集合类型，当然了他们也有关系，都属于Seq这个特征，List可以认定为没有索引的线性的一个序列，跟数组相比就不能直接用索引去访问里面的每一个元素，关心的就是头和尾的一些操作，如果想要访问元素就要做遍历操作了

1、不可变列表

(1) 说明

(1) List 默认为不可变集合
(2) 创建一个 List (数据有顺序，可重复)
(3) 遍历 List
(4) List 增加数据
(5) 集合间合并：将一个整体拆成一个一个的个体，称为扁平化
(6) 取指定数据
(7) 空集合 Nil

(2) 创建数据和访问数据

创建列表使用的是数组创建的第二种方式，创建的时候可以直接赋值，列表创建不能new一个新的对象。获取值虽然没有索引但是Scala为了方便，在底层还是做了可以像直接通过索引访问元素一样的操作，但是像数组一样直接通过索引然后进行赋值修改是肯定不可以的，遍历的话之前数组遍历的那五种方式都是可以的

package Scala03_shujujiegou
//不可变列表
class test04_bukebianlist {

}
object test04_bukebianlist{
  def main(args: Array[String]): Unit = {
    //1、创建一个不可变list
    //跟创建数组不一样，不能new一个新的，只能通过伴生对象的方式创建
    val list = List(1,2,3) //可以直接这样用伴生对象apply方法创建跟数组一样
    println(list) //想要访问可以直接输出

    //之前说了list没有索引，但是scala为了方便，底层设置了，让我们也可以通过像索引一样获取元素
    println(list(6)) //要是超出了列表范围的话，一样会报索引越界的错
    //list(1) = 12 //但是想要通过索引修改值是肯定不行的，底层没有update方法

    //一般list列表不是很关心某一个位置的值，关心的是头和尾，或者全部的元素
    //遍历 之前数组遍历的那五种方式都是可以的
    for(i <- list){ //因为没有索引用这种方式是最合适的
      println(i)
    }
    println("==============")
    for(i <- 0 until list.length){ //for循环也可以
      println(list(i))
    }
    println("============")
    list.foreach(println)
    println("===========")
    println(list.mkString(","))
    println("================")
    val iter = list.iterator
    while (iter.hasNext){
      println(iter.next())
    }
  }
}

(3) 添加数据

列表添加数据有两种方式，第一种和之前不可变数组一样的 +: 这种方式比较方便，然后第二种方式是 Nil.:: 这样是创建一个空列表，然后这样Nil在前面调用就必须加上.，然后::Nil要是在后面的话，那么就是就是把数据添加在列表的后面，还是比较推荐第一种添加的方式
在这里插入图片描述

(4) 合并列表

如果有两个不同的列表，能不能考虑把他们合并在一起呢?
有三个方法：
三个符号，第一个:: 是以右边那个列表为基准，在左边添加一个列表进来，第二个 ::: 将两个列表拆开成一个一个的元素，然后合并在一个列表里，第三个++ 跟第二个方式 ::: 是一样的效果，推荐使用第二个和第三个方式
在这里插入图片描述

2、可变列表

注意：只有可变的集合类型中才有添加和删除的操作

(1) 创建数组

跟创建数组一样，两种方式，推荐使用第二种伴生对象创建，创建的时候可以直接赋值

package Scala03_shujujiegou

import scala.collection.mutable.ListBuffer

//可变列表 ListBuffer
class test05_kebianlist {

}
object test05_kebianlist{
  def main(args: Array[String]): Unit = {
    // 1、创建可变列表
    val list = new ListBuffer[Int]() //new 一个新的ListBuffer对象
    val list2 = ListBuffer(16,22,23,24) //伴生对象创建直接赋值
    println(list)
    println(list2)

  }
}

(2) 添加元素

对于可变的集合类型，添加元素都是一样的，可以使用那些英文方法。append()在数组后面添加，prepend()在数组前面添加，insert()在数组任意位置添加，第一个参数是索引
在这里插入图片描述

(3) 修改数据

第一个方式是使用索引直接赋值，第二个方式是使用方法update() 第一个参数是索引，第二个参数是要修改的值
在这里插入图片描述

(4) 删除元素

两个方式，第一个 -= ，可以指定删除哪一个元素，第二个方式，remove()方法，两个参数，第一个参数是索引，第二个参数是连续删除多少个元素
在这里插入图片描述

四、Set 集合

1、不可变集合

默认情况下，Scala使用的是不可变集合，如果你想使用可变集合，需要引用scala.collection.mutable.Set 包，集合最大的特点就是 数据是无序的，数据是不可重复的
注意：之前数组和列表的可变不可变名称是不一样的，可Set集合的可变和不可变名称都是一样的，都叫Set，所以叫要注意是哪个包下的Set了
说明：
(1) Set 默认是不可变集合，数据无序
(2) 数据不可重复
(3) 遍历集合

(1) 创建不可变Set集合

创建不可变集合，像之前数组和列表一样直接使用伴生对象创建，可以直接进行赋值，在赋值的时候有相同的元素，输出的时候会自动剔除，因为集合不允许重复的值的

package Scala03_shujujiegou
//不可以变集合
class test06_bukebianSet {

}
object test06_bukebianSet{
  def main(args: Array[String]): Unit = {
    //默认是不可变set
    //1、创建不可变Set
    val set1 = Set(1,2,5,2) //直接使用伴生对象创建
    println(set1)
    
  }
}

在这里插入图片描述

(2) 添加元素

不可变集合添加数据是直接用 +，之前数组的那种+：方式不能用，集合添加元素根本不用考虑是在前面添加还是在后面添加，因为集合是无序的，添加进去的位置是随机的
在这里插入图片描述

(3) 合并集合

使用++ 就可以将两个集合拆分成一个一个元素，然后合并为一个集合
在这里插入图片描述

(4) 删除元素

添加元素用的+，那么删除元素肯定用的是- ，不可变集合操作这些肯定都是创建一个新的集合对象赋值给他，原集合肯定是不会改变的
在这里插入图片描述
可以看到删除元素之后，下面那个集合比上面那个集合少了一个16

2、可变集合

(1) 创建可变集合

因为集合可变和不可变都是一个名称Set，系统默认是创建的不可变集合，所以要是想要创建可变集合的话需要导入一个包 import scala.collection.mutable 在创建的时候前面加一个mutable，例如val set1 = mutable.Set(16,22,83)

package Scala03_shujujiegou

import scala.collection.mutable //使用可变的集合的导入这个mutable包

//可变集合
class test07_kebianSet {

}
object test07_kebianSet{
  def main(args: Array[String]): Unit = {
    // 1、创建可变Set
    val set1 = mutable.Set(16,28,99,16) //因为集合的可变和不可变名称都是一样的，所以使用不可以得导个包
    println(set1)
  }
}

(2) 添加元素

可变集合添加元素三种方法，第一种跟不可变集合一样可以创建一个新的对象赋值，然后原数组的元素也会发生改变，但是这样不好，因为是可变集合我们希望可以直接做更改，所以还有两种方法，第二种 += 赋值，第三种add()方法，推荐使用第三种，因为可变集合类型推荐使用方法
在这里插入图片描述

(3) 删除元素

可变集合删除元素两个方式，第一个添加元素是+=，那么删除元素肯定就是-=了，还有第二种方式，remove()方法，跟数组和列表一样，可变的集合类型建议使用方法
` 在这里插入图片描述

(4) 合并可变集合

两种方式，第一种和之前不可变集合合并一样，直接++ 第二种方式，要是不想要赋值给一个新的对象的话，比如说想把set2 的元素合并在set1里面，那么就++=，例如 se1 ++= set2，那么set2的就元素就合并在set1里面了
在这里插入图片描述

五、Map集合

Scala 中的Map和Java类似，也是一个散列表，他存储的内容也是键值对(key-value)映射

1、不可变 Map

注意：不可变Map集合是不能添加元素的，要想添加元素只能使用可变Map集合
说明：
(1) 创建不可变集合 Map
(2) 循环打印
(3) 访问数据
(4) 如果key不存在，返回0

(1) 创建 Map

创建Map还是使用伴生对象进行创建，但是他是键值对的形式，所以对象定义类型的时候，他就有两个，比如我们这里是统计单词出现的次数，第一个是键那就是String类型，第二个是值那就是Int类型的，然后定义键值对的时候中间连接的符号是->
例如：val map[String,Int] = Map('hello' -> 3，'word' -> 6，'bigdata' -> 5)

package Scala03_shujujiegou
//不可变Map集合
class test08_bukebianMap {

}
object test08_bukebianMap{
  def main(args: Array[String]): Unit = {
    //1、创建不可变Map 默认创建的就是不可变的
    val map:Map[String,Int] = Map("a" -> 13,"b" -> 12,"hello" -> 3) //把value定义为String类型的，key定义为Int类型的
    println(map) //直接这样输出
    println(map.getClass) //看到当前的类

    //2、遍历Map集合中元素
    map.foreach(println) //使用foreach()方法是最简单方便的
    map.foreach((kv:(String,Int)) => println(kv)) //(Stromh，Int)这个是元组，完整的写出来
  }
}

(2) Map 访问元素

Map 获取某一个键的值，一共有三种方法：第一种直接println(map("a"))，直接输出键然后会得到对应的值。第二种使用get()方法，他会返回对应的value值，第三种还有一个getOrElse()方法里面两个参数，第一个是键第二个是初始值，如果这个键值不存在的话，那么就会返回初始值。
然后想要遍历，获取全部的key，或者全部的value的话，首先遍历foreach() 是最方便的，然后获取全部的key使用keys方法，获取全部的值，直接在for循环遍历全部的键可以，然后使用get方法获取对应的值，就全部遍历出来了
推荐：获取单个的元素，推荐使用第一种方法和第三种getOrElse()，遍历推荐使用foreach()，或者增强for循环

package Scala03_shujujiegou
//不可变Map集合
class test08_bukebianMap {

}
object test08_bukebianMap{
  def main(args: Array[String]): Unit = {
    //1、创建不可变Map 默认创建的就是不可变的
    val map:Map[String,Int] = Map("a" -> 13,"b" -> 12,"hello" -> 3) //把value定义为String类型的，key定义为Int类型的
    println(map) //直接这样输出
    println(map.getClass) //看到当前的类

    //2、遍历Map集合中元素
    map.foreach(println) //使用foreach()方法是最简单方便的
    map.foreach((kv:(String,Int)) => println(kv)) //(Stromh，Int)这个是元组，完整的写出来

    println("==============")
    //3、访问Map元素
    //比如像访问Map里面某一个元素，或者想获取Map中所有的key
    //访问某一个key的value
    println(map.get("a")) //获取某一个key的value直接使用get方法
    println(map.getOrElse("a",0)) //getOrElse,设置一个初始值如果没有这个元素那么就返回这个初始值

    //取Map中所有的key，或者value
    for(i <- map){ //遍历了键值
      println(i)
    }
    //取键
    for(key <- map.keys){ //keys方法取的是键，然后后面get方法，再把这个键放进去获取的是值
      println(s"map keys:${key} values is:${map.get(key)}")
    }

  }
}

2、可变 Map

(1) 创建可变 Map

跟之前Set结合一样的，Map集合的可变和不可变也是一样的名称，所以创建的时候要导入一个import scala.collection.mutable包
例如：val map = mutable.Map("hello" -> 3，"word" -> 4)

package Scala03_shujujiegou

import scala.collection.mutable //导入mutable包

//可变Map集合
class test09_kebianMap {

}
object test09_kebianMap{
  def main(args: Array[String]): Unit = {
    //1、创建可变Map 默认创建的就是不可变的，所以要把mutable包导入
    val map:mutable.Map[String,Int] = mutable.Map("a" -> 13,"b" -> 12,"hello" -> 3) //把value定义为String类型的，key定义为Int类型的
    println(map) //直接这样输出
    println(map.getClass) //看到当前的类


  }
}

(2) 添加元素

添加元素使用put方法，两个参数第一个参数是key，第二个参数是value，可变的Map 集合是HashMap 所以不用去考虑添加位置和顺序。还有一种方法+=，后面赋值式两个()，因为是底层设计的时候调用所设置的，推荐使用put方法，因为可变都推荐使用方法
在这里插入图片描述

(3) 删除元素

删除元素两种方法：首先添加元素可以 += 那么删除元素对应的肯定就可以 -=，第二种方法，remove() 方法，添加的时候是键值对，删除的时候只需要一个key
在这里插入图片描述

(4) 修改元素

修改元素使用update()方法，里面两个参数，第一个是要修改的键，第二个参数是要修改的值，修改元素有两种情况，如果这个键是存在的话那么就是修改，如果不存在的话那么就相当于添加

在这里插入图片描述

(5) 合并两个可变 Map集合

跟之前Set集合一样，合并Map集合有两种方式一种++然后赋值给一个新的集合对象，第二种++=这个是相当于把后面那么集合合并到第一个集合里面去了，推荐使用第二个，第一个个也行
在这里插入图片描述

六、元组(Tuple)

说明：
元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。说的简单点，就是将多个无关的数据封装为一个整体，称为元组
注意：元组总最大只能有22个元素
案例示例
(1) 声明元组的方式：(元素1，元素2，元素3)
(2) 访问元组
(3) Map中的键值对其实就是元组，只不过元组的元素个数为2，称之为对偶

1、创建元组

创建元组很简单，直接用()然后里面赋值就行了，元组里面可以有各种不同类型的值，要是创建的时候要写出类型的话，那么就是元组中，按照顺序对应的每一个值

package Scala03_shujujiegou
//元组
class test10_yuanzu {

}
object test10_yuanzu{
  def main(args: Array[String]): Unit = {
    //1、创建元组
    //要是创建的时候要元组的类型话，那么就是元组里面的对应的每一个值的类型
    val tuple:(String,Int,Char,Boolean) =("hello",16,'a',true) //元组创建非常简单。直接用括号括起来就可以了，然后里面可以存放各种不同类型的值
    println(tuple) //输出也很简单，直接这样输出就可以了
    
   
  }
}