目录
- 10.1、数据结构特点
- 10.2、不可变集合继承层次一览图
- 10.3、可变集合继承层次一览图
- 10.4、数组-定长数组(声明泛型)
- 10.5、数组-变长数组(声明泛型)
- 10.6、数组-Scala数组与Java的List的互转
- 10.6.1、Scala数组转Java的List
- 10.6.2、案例演示
- 10.6.3、补充了一个多态（使用trait来实现的参数多态）的知识点
- 10.6.4、Java的List转Scala数组(mutable.Buffer）
- 10.7、元组Tuple-元组的基本使用
- 10.8、元组Tuple-元组数据的访问
- 10.9、元组Tuple-元组数据的遍历
- 10.10、列表List-创建List
- 10.11、列表List-访问List元素
- 10.12、列表List-元素的追加
- 10.13、ListBuffer
- 10.14、队列Queue-基本介绍
- 10.15、队列Queue-队列的创建
- 10.16、队列Queue-队列元素的追加数据
- 10.17、队列Queue-删除和加入队列元素
- 10.18、队列Queue-返回队列的元素
- 10.19、映射Map-基本介绍
- 10.20、映射Map-构建Map
- 10.21、映射Map-构建Map
- 10.22、映射Map-取值
- 10.22.1、方式1-使用map(key)
- 10.22.2、方式2-使用contains方法检查是否存在key
- 10.22.3、方式3-使用map.get(key).get取值
- 10.22.4、方式4-使用map4.getOrElse()取值
- 10.22.5、如何选择取值的方式
- 10.23、映射Map-对map修改、添加和删除
- 10.24、映射Map-对map遍历
- 10.25、集Set-基本介绍
- 10.26、集Set-创建
- 10.27、集Set-可变集合的元素添加和删除
- 10.28、集Set-更多操作
10.1、数据结构特点
10.1.1、Scala集合基本介绍
uml => 统一建模语言
1、Scala同时支持不可变集合和可变集合，不可变集合可以安全的并发访问
两个主要的包：
不可变集合：scala.collection.immutable
可变集合：scala.collection.mutable
2、Scala默认采用不可变集合，对于几乎所有的集合类，Scala都同时提供了可变(mutable)和不可变(immutable)的版本
3、Scala的集合有三大类：序列Seq(有序的,LinearSeq)、集Set、映射Map【key->value】，所有的集合都扩展自Iterable特质，在Scala中集合有可变（mutable）和不可变（immutable）两种类型。
什么时候，应该使用什么集合？
10.1.2、可变集合和不可变集合举例
1、不可变集合：scala不可变集合，就是这个集合本身不能动态变化。(类似java的数组，是不可以动态增长的)
2、可变集合:可变集合，就是这个集合本身可以动态变化的。(比如:ArrayList,是可以动态增长的)
3、使用java做了一个简单的案例说明
import java.util.ArrayList;
public class JavaCollection {
public static void main(String[] args) {
// 不可变集合类似java数组
int[] nums = new int[3];
nums[2] = 11;
nums[2] = 22;
// num[3] = 90 //?
String [] names = {"bi","sh"};
System.out.println(nums + " " + names);
// 可变集合举例
ArrayList<String> a1 = new ArrayList<String>();
a1.add("zs");
a1.add("zs2");
System.out.println(a1 + "地址=" + a1.hashCode()); // 地址
a1.add("zs3");
System.out.println(a1 + "地址2=" + a1.hashCode());
}
}
10.2、不可变集合继承层次一览图
10.2.1、图
关于这个图务必记住
10.2.2、小结
1.Set、Map是Java中也有的集合
2.Seq是Java没有的，我们发现List归属到Seq了,因此这里的List就和java不是同一个概念了
3.我们前面的for循环有一个1to3,就是IndexedSeq下的Vector
4.String也是属于IndexeSeq
5.我们发现经典的数据结构比如Queue和Stack被归属到LinearSeq
6.大家注意Scala中的Map体系有一个SortedMap,说明Scala的Map可以支持排序
7.IndexSeq和LinearSeq的区别[IndexSeq是通过索引来查找和定位，因此速度快，比如String就是一个索引集合，通过索引即可定位][LineaSeq是线型的，即有头尾的概念，这种数据结构一般是通过遍历来查找，它的价值在于应用到一些具体的应用场景(电商网站,大数据推荐系统:最近浏览的10个商品)
10.3、可变集合继承层次一览图
10.3.1、图
10.3.2、对上图的说明
1、在可变集合中比不可变集合更加丰富
2、在Seq集合中，增加了Buffer集合，将来开发中，我们常用的有ArrayBuffer和ListBuffer
3、如果涉及到线程安全可以选择使用syn…开头的集合
4、其它的说明参考不可变集合
10.4、数组-定长数组(声明泛型)
10.4.1、第一种方式定义数组
说明
这里的数组等同于Java中的数组,中括号的类型就是数组的类型
val arr1=new ArrayInt
//赋值,集合元素采用小括号访问
arr1(1)=7
案例演示：
object ArrayDemo01 {
def main(args: Array[String]): Unit = {
//说明
// 1.创建了Array对象
// 2.[Int]表示泛型，即该数组中，只能存放Int
// 3.[Any]表示 该数组可以存放任意类型
// 4.在没有赋值情况下，各个元素的值 0
// 5. arr01(3) = 10 表示修改第4个元素的值
val arr01 = new Array[Int](4) // 底层 Int [] arr01 = new int[4]
println(arr01.length) // 4
println("arr01(0)=" + arr01(0)) //0
// 数组的遍历
for (i <- arr01) {
println(i)
}
println("===========================")
arr01(3) = 10 //
for (i <- arr01) {
println(i)
}
}
}
10.4.2、第二种方式定义数组
说明
在定义数组时，直接赋值
//使用apply方法创建数组对象
val arr1 = Array(1,2)
案例演示：
object ArrayDemo02 {
def main(args: Array[String]): Unit = {
// 说明
// 1. 使用的是 object Array 的 apply
// 2. 直接初始化数组，这时因为你给了 整合和"" ，这个数组的泛型就是Any
// 3. 遍历方式都一样
var arr02 = Array(1, 2, "xxx")
arr02(1) = "xx"
for (i <- arr02) {
println(i)
}
// 可以使用我们传统的方式遍历， 使用下标的方式遍历
for (index <- 0 until(arr02.length)){
printf("arr02[%d]=%s ",index,arr02(index)+"\t")
}
}
}
10.5、数组-变长数组(声明泛型)
说明
/定义/声明
va larr2= ArrayBufferInt
//追加值/元素
arr2.append(7)
//重新赋值
arr2(0)=7
代码演示
import scala.collection.mutable.ArrayBuffer
object ArrayBufferDemo01 {
def main(args: Array[String]): Unit = {
// 创建ArrayBuffer
val arr01 = ArrayBuffer[Any](3, 2, 5)
// 通过下标访问元素
println("arr01(1) = " + arr01(1)) // 2
// 遍历
for (i <- arr01) {
println(i)
}
println(arr01.length) // 3
println("arr01.hash = " + arr01.hashCode())
// 使用append 追加数据，append支持可变参数
// 可以理解成Java的数组的扩容
arr01.append(90.0, 13) //
println("arr01.hash = " + arr01.hashCode())
println("==================")
arr01(1) = 89 // 修改
println("---------------------------------")
for (i <- arr01) {
println(i)
}
// 删除,是根据下标删除的
arr01.remove(0)
println("-------------------------------------")
for (i <- arr01) {
println(i)
}
println("最新的长度 = " + arr01.length)
}
}
10.5.1、变长数组分析小结
1.ArrayBuffer是变长数组，类似java的ArrayList
2.valarr2=ArrayBufferInt也是使用的apply方法构建对象
3.defappend(elems:A*){appendAll(elems)}接收的是可变参数.
4.每append一次，arr在底层会重新分配空间，进行扩容，arr2的内存地址会发生变化，也就成为新的ArrayBuffer
10.5.2、定长数组与变长数组的转换
说明
在开发中，我们可能使用对定长数组和变长数组，进行转换
arr1.toBuffer //定长数组转可变数组
arr2.toArray //可变数组转定长数组
注意事项
arr2.toArray返回结果才是一个定长数组，arr2本身没有变化
arr1.toBuffer返回结果才是一个可变数组，arr1本身没有变化
代码演示
import scala.collection.mutable.ArrayBuffer
object Array22ArrayBuffer {
def main(args: Array[String]): Unit = {
val arr2 = ArrayBuffer[Int]()
// 追加值
arr2.append(1, 2, 3)
println(arr2)
// 说明
//1. arr2.toArray 调用arr2的方法 toArray
// 2.将ArrayBuffer --> Array
// 3. arr2没有任何的变化
val newarr = arr2.toArray
println(newarr)
// 说明
// 1.newarr.toBuffer 是把Array --> ArrayBuffer
// 2.底层的实现
/*
override def toBuffer[A1 >: A]: mutable.Buffer[A1] = {
val result = new mutable.ArrayBuffer[A1](size)
copyToBuffer(result)
result
}
*/
// 3.newarr本身没有变化
val newArr2 = newarr.toBuffer
newArr2.append(123)
println(newArr2)
}
}
10.5.3、多维数组的定义和使用
说明
//定义
val arr=Array.ofDimDouble
//说明：二维数组中有三个一维数组，
每个一维数组中有四个元素
//赋值
arr(1)(1)=11.11
案例演示
object MultiplyArray {
def main(args: Array[String]): Unit = {
// 创建
val arr = Array.ofDim[Int](3,4)
// 遍历
for (item <- arr ) { // 取出二位数组的各个元素(一维数组)
for (item2<-item){ // 元素(一维数组) 遍历
print(item2 + "\t")
}
println()
}
// 指定取出
println(arr(1)(1)) // 0
// 修改值
arr(1)(1) = 100
println("--------------------------")
// 遍历
for (item <- arr ) { // 取出二位数组的各个元素(一维数组)
for (item2<-item){ // 元素(一维数组) 遍历
print(item2 + "\t")
}
println()
}
// 使用传统下标进行遍历
println("=======================")
for (i<-0 to arr.length -1){
for (j <- 0 to arr(i).length-1){
printf("arr[%d][%d]=%d\t",i,j,arr(i)(j))
}
println()
}
}
}
10.6、数组-Scala数组与Java的List的互转
10.6.1、Scala数组转Java的List
在项目开发中，有时我们需要将Scala数组转成Java数组，看下面案例：
10.6.2、案例演示
import scala.collection.mutable.ArrayBuffer
object ArrayBuffer2JavaList {
def main(args: Array[String]): Unit = {
// Scala集合和Java集合的互转
val arr = ArrayBuffer("1", "2", "3")
/*
implicit def bufferAsJavaList[A](b: mutable.Buffer[A]): ju.List[A] = b match {
case JListWrapper(wrapped) => wrapped
case _ => new MutableBufferWrapper(b)
}
*/
import scala.collection.JavaConversions.bufferAsJavaList
// 对象 ProcessBuilder, 因为 这里使用到上面的隐式函数 bufferAsJavaList
val javaArr = new ProcessBuilder(arr) // 为什么可以这样使用
// 这里arrList 就是java中的List
val arrList = javaArr.command()
println(arrList) // 输出[1,2,3]
}
}
10.6.3、补充了一个多态（使用trait来实现的参数多态）的知识点
object MytraitDemo01 {
def main(args: Array[String]): Unit = {
val a01 = new A
B.test(a01)
}
}
trait Mytrait01 {}
class A extends Mytrait01 {}
object B {
def test(m: Mytrait01): Unit = {
println("b ··ok")
}
}
10.6.4、Java的List转Scala数组(mutable.Buffer）
代码实现
// java的List 转成Scala的ArrayBuffer
// 说明
// 1.asScalaBuffer 是一个隐式函数
/*
implicit def asScalaBuffer[A](l: ju.List[A]): mutable.Buffer[A] = l match {
case MutableBufferWrapper(wrapped) => wrapped
case _ =>new JListWrapper(l)
}
*/
import scala.collection.JavaConversions.asScalaBuffer
import scala.collection.mutable
// java.util.List ==> Buffer
val scalaArr: mutable.Buffer[String] = arrList
scalaArr.append("jack")
scalaArr.append("tom")
scalaArr.remove(0)
println(scalaArr) // (2,3,jack.tom)
10.7、元组Tuple-元组的基本使用
10.7.1、基本介绍
元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。
说的简单点，就是将多个无关的数据封装为一个整体，称为元组,最多的特点灵活,对数据没有过多的约束。
注意：元组中最大只能有22个元素
10.7.2、元组的创建
案例演示
//创建
// 1.tuple1 就是一个Tuple 类型是Tuple5
// 简单说明：为了高效操作元祖，编译器根据元素的个数不同，对应不同的元祖类型
// 分别是Tuple -> Tuple22
//
val tuple1 = (1, 2, 3, "hello", 4)
println(tuple1)
对上述代码的说明
1.t1的类型是Tuple5类是scala特有的类型
2.t1的类型取决于t1后面有多少个元素,有对应关系，比如4个元素=》Tuple4
3.给大家看一个Tuple5类的定义,大家就了然了
/*
final case classTuple5+T1,+T2,+T3,+T4,+T5
extendsProduct5[T1,T2,T3,T4,T5]
{
override deftoString()="("+_1+","+_2+","+_3+","+_4+","+_5+")"
}
*/
4.元组中最大只能有22个元素即Tuple1...Tuple22
10.8、元组Tuple-元组数据的访问
10.8.1、基本介绍
访问元组中的数据,可以采用顺序号（_顺序号），也可以通过索引（productElement）访问。
10.8.2、应用案例
println("===============访问元祖================")
val t1 = (1, "a", "b", true, 2)
println(t1._1) // 1 访问元祖的第一个元素，从1开始
// 访问元祖
println(t1.productElement(0)) //1 访问元祖的第一个元素，从0开始
/*
override def productElement(n:Int)=nmatch{
case0=>_1
case1=>_2
case2=>_3
case3=>_4
case4=>_5
case_=>thrownewIndexOutOfBoundsException(n.toString())
}
*/
println(t1.productElement(0))//0//访问元组的第一个元素，从0开始
10.9、元组Tuple-元组数据的遍历
Tuple是一个整体，遍历需要调其迭代器
// 遍历元祖
println("===============遍历元祖================")
// 元祖的遍历需要使用迭代器
for (item <- t1.productIterator) {
println("item=" + item)
}
10.10、列表List-创建List
10.10.1、基本介绍
Scala中的List和JavaList不一样，在Java中List是一个接口，真正存放数据是ArrayList，而Scala的List可以直接存放数据，就是一个object，默认情况下Scala的List是不可变的，List属于序列Seq。
val List=scala.collection.immutable.List
object List extends SeqFactory[List]
10.10.2、创建List的应用案例
object ListDemo01 {
def main(args: Array[String]): Unit = {
// 说明
// 1.在默认情况下List，是Scala.collect.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 list01 = List(1, 2, 3, "Hello") // 创建时，直接分配元素
println(list01)
val list02 = Nil // 空集合
println(list02)
}
}
10.10.3、创建List的应用案例小结
1、List默认为不可变的集合
2、List在scala包对象声明的,因此不需要引入其它包也可以使用val List=scala.collection.immutable.List
3、List中可以放任何数据类型，比如arr1的类型为List[Any]
4、如果希望得到一个空列表，可以使用Nil对象,在scala包对象声明的,因此不需要引入其它包也可以使用valNil=scala.collection.immutable.Nil
10.11、列表List-访问List元素
// 访问List的元素
val value1 = list01(1) // 1是索引，表示取出第二个元素,从0开始
println("value1=" + value1) // 2
10.12、列表List-元素的追加
10.12.1、基本介绍
向列表中增加元素,会返回新的列表/集合对象。注意：Scala中List元素的追加形式非常独特，和Java不一样。
10.12.2、方式2-在列表的最后增加数据
案例演示
println("=======给List追加元素后的效果=========")
// 通过 :+ 和 +: 给List追加元素(本身的集合并没有变化)
var list1 = List(1, 2, 3, "abc")
// :+ 运算符表示在列表的最后增加数据
val list2 = list1 :+ 4 // (1,2,3,"abc",4)
println("list1=" + list1) // list没有变化(1, 2, 3, "abc"),说明list1还是不可变的
println("list2=" + list2) // 新的列表结果是 [1,2,3,"abc",4]
val list3 = 10 +: list1 // (10,1, 2, 3, "abc")
println("list3=" + list3)
10.12.4、方式3-在列表的最后增加数据
说明:
1符号::表示向集合中新建集合添加元素。
2运算时，集合对象一定要放置在最右边，
3运算规则，从右向左。
4:::运算符是将集合中的每一个元素加入到集合中去
应用案例
// :: 符号的使用 运算规则:从右向左
val list4 = List(1, 2, 3, "abc")
// 说明 val list5 = 4 :: 5 :: 6 :: list4 :: Nil 步骤
// 1.List()
// 2.List(list4(1,2,3,"abc"))
// 3.List(6list4(1,2,3,"abc"))
// 4.List(5,6list4(1,2,3,"abc"))
// 5.List(4,5,6list4(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)
10.12.5、课堂练习题
10.13、ListBuffer
10.13.1、基本介绍
ListBuffer是可变的list集合，可以添加，删除元素,ListBuffer属于序列
//追一下继承关系即可
Seq var listBuffer=ListBuffer(1,2)
10.13.2、应用实例代码
import scala.collection.mutable.ListBuffer
object ListBufferDemo01 {
def main(args: Array[String]): Unit = {
// 创建ListBuffer
val lst0 = ListBuffer[Int](1, 2, 3)
// 如何访问
println("lst0(2)=" + lst0(2)) // 输出 lst0(2)=3
for (item <- lst0) { // 遍历，是有序的
println("item=" + item)
}
// 动态的增加元素，lst1 就会变化，增加一个一个的元素
val lst1 = new ListBuffer[Int] // 空的ListBuffer
lst1 += 4 // lst1 (4)
lst1.append(5) //lst1(4,5)
//
lst0 ++= lst1 // lst0 (1,2,3,4,5)
println("lst0="+lst0)
val lst2 = lst0 ++ lst1 // lst2(1,2,3,4,5,4,5)
println("lst2="+lst2)
val lst3 = lst0 :+ 5 // lst0 不变 lst3(1,2,3,4,5,5)
println("lst3="+lst3)
println("========删除==========")
println("lst1=" + lst1)
lst1.remove(1) // 将下标为1的元素删除
for (item <- lst1) {
println("item=" + item) //4
}
}
}
10.14、队列Queue-基本介绍
10.14.1、队列的应用场景
10.14.2、队列的说明
1.队列是一个有序列表，在底层可以用数组或是链表来实现。
2.其输入和输出要遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取
3.在Scala中，由设计者直接给我们提供队列类型Queue使用。
4.在scala中,有scala.collection.mutable.Queue和scala.collection.immutable.Queue,一般来说，
我们在开发中通常使用可变集合中的队列
10.15、队列Queue-队列的创建
// 创建队列
val q1 = new mutable.Queue[Int]
println(q1)
10.16、队列Queue-队列元素的追加数据
// 给队列增加元素
q1 += 9
println("q1=" + q1) // 9
q1 ++= List(4, 5, 7) // 默认直接加在队列后面
println("q1=" + q1) // (9,4,5,7)
//q1 += List(10,0) // 将List(10,0),作为一个元素加入到队列中,但要求类型是Any
10.17、队列Queue-删除和加入队列元素
在队列中，严格的遵守，入队列的数据，放在队位，出队列的数据是队列的头部取出.
// dequeue 从队列的头部取出元素 q1本身会变化
val queueElement = q1.dequeue()
println("queueElement=" + queueElement + "\tq1=" + q1)
// enQueue 入队列，默认是从队列的尾部加入 .Redis
q1.enqueue(100,10,100,888)
println("q1=" + q1) // Queue(4,5,7,100,10,100,888)
10.18、队列Queue-返回队列的元素
println("==========返回队列的元素============")
// 队列 Queue 返回队列的元素
// 1.获取队列的第一个元素
println(q1.head) // 4 ，对q1没有任何影响
// 2.获取队列的最后一个元素
println(q1.last) // 888，对q1没有任何影响
// 3.取出队尾的数据,即：返回除了第一个意外剩余的元素，可以级联使用
println(q1.tail) // (5,7,100,10,100,888)
println(q1.tail.tail.tail.tail) // (10,100,888)
10.19、映射Map-基本介绍
10.19.1、Java中的Map回顾
HashMap是一个散列表(数组+链表)，它存储的内容是键值对(key-value)映射，Java中的HashMap是无序的，key不能重复。
案例演示
10.19.2、应用案例
import java.util.HashMap;
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); // 更新
System.out.println(hm); // 无序的
System.out.println(hm.get("no2"));
}
}
10.19.3、Scala中的Map介绍
1、Scala中的Map和Java类似，也是一个散列表，它存储的内容也是键值对(key-value)映射，Scala中不可变的Map是有序的，可变的Map是无序的。
2、Scala中，有可变Map(scala.collection.mutable.Map)和不可变Map(scala.collection.immutable.Map)
10.20、映射Map-构建Map
10.20.1、方式1-构造不可变映射
Scala中的不可变Map是有序，构建Map中的元素底层是Tuple2类型。
代码如下：
object MapDemo01 {
def main(args: Array[String]): Unit = {
//1.默认Map是immutable.Map
//2.key-value类型支持Any
//3.在Map的底层，每对key-value是Tuple2
val map1 = Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> "北京")
println(map1)
}
}
10.21、映射Map-构建Map
10.21.1、方式1-构造不可变映射
Scala中的不可变Map是有序，构建Map中的元素底层是Tuple2类型
// 方法1-构建不可变映射
// 1.默认Map是 immutable.Map
// 2.Key-Value 类型支持Any
// 3.在Map的底层，每对key-value是Tuple2
// 4.从输出结果来看，输出顺序和声明顺序一致
val map1 = Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> "北京")
println(map1)
10.21.2、方式2-构造可变映射
// 方法2-构建可变映射
// 1.从输出结果来看，输出顺序和声明顺序不一致
val map2 = mutable.Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> "北京")
map2.+=("a" -> 1)
println(map2)
10.21.3、方式3-创建空的映射
// 方法3-创建空的映射
val map3 = new mutable.HashMap[String, Int]
map3.+=("a" -> 1)
println("map3=" + map3)
10.21.4方式4-对偶元组
说明
即创建包含键值对的二元组，和第一种方式等价，只是形式上不同而已。
对偶元组就是只含有两个数据的元组。
案例演示
//方法4-对偶元祖
val map4 = mutable.Map(("Alice", 10), ("Bob", 20), ("Kotlin", "北京"))
println(map4)
10.22、映射Map-取值
10.22.1、方式1-使用map(key)
val value1=map2(“Alice”)
println(value1)
说明:
1)如果key存在，则返回对应的值
2)如果key不存在，则抛出异常[java.util.NoSuchElementException]
3)在Java中,如果key不存在则返回null
4)代码
// 方式1-使用map(key)
println(map4("Alice")) // 10
//抛出异常 java.util.NoSuchElementException: key not found
// println(map4("Alice~"))
10.22.2、方式2-使用contains方法检查是否存在key
//返回Boolean
//1.如果key存在，则返回true
//2.如果key不存在，则返回false
map4.contains(“B”)
说明
使用containts先判断在取值，可以防止异常，并加入相应的处理逻辑
代码
// 方式2-使用contains方法检查是否存在key
if (map4.contains("Alice")) println("key存在，值=" + map4("Alice"))
else println("key不存在")
10.22.3、方式3-使用map.get(key).get取值
通过映射.get(键)这样的调用返回一个Option对象，要么是Some，要么是None
说明和小结：
1)map.get方法会将数据进行包装
2)如果map.get(key)key存在返回some,如果key不存在，则返回None
3)如果map.get(key).getkey存在，返回key对应的值,否则，抛出异常java.util.NoSuchElementException:None.get
案例演示
// 方法3-使用map.get(key).get取值
// 1.如果key存在 map.get(key) 就会返回Some(值).get,然后就可以取出
// 2.如果key不存在 map.get(key) 就会返回None
// some是Option的子类
println(map4.get("Alice").get)
// println(map4.get("Alice~").get)
// 抛出异常 java.util.NoSuchElementException: None.get
10.22.4、方式4-使用map4.getOrElse()取值
getOrElse方法:defgetOrElseV1>:V
说明：
1)如果key存在，返回key对应的值。
2)如果key不存在，返回默认值。在java中底层有很多类似的操作
3)代码
//方法4-使用map.getOrElse()取值
println(map4.getOrElse("Alice~", "鱼"))
10.22.5、如何选择取值的方式
1)如果我们确定map有这个key,则应当使用map(key),速度快
2)如果我们不能确定map是否有key,而且有不同的业务逻辑，使用map.contains()先判断在加入逻辑
3)如果只是简单的希望得到一个值，使用map4.getOrElse(“ip”,“127.0.0.1”)
10.23、映射Map-对map修改、添加和删除
10.23.1、更新map的元素
案例演示
val map5 = mutable.Map(("A", 1), ("B", "北京"), ("C", 3))
map5("AA") = 20 // 增加
map5("A") = 20 // 修改
println("map5 =" + map5)
小结
1)map是可变的，才能修改，否则报错
2)如果key存在：则修改对应的值,key不存在,等价于添加一个key-val
10.23.2、添加map元素
说明:当增加一个key-value,如果key存在就是更新，如果不存在，这是添加
10.23.3、删除map元素
案例演示
map5 -= ("A", "B") // -=底层做了包装
println("map5 =" + map5)
说明
1)“A”,"B"就是要删除的key,可以写多个.
2)如果key存在，就删除，如果key不存在，也不会报错
10.24、映射Map-对map遍历
对map的元素(元组Tuple2对象)进行遍历的方式很多，具体如下
val map1=mutable.Map((“A”,1),(“B”,“北京”),(“C”,3))
for((k,v)<-map1)println(k+“ismappedto”+v)
for(v<-map1.keys)println(v)
for(v<-map1.values)println(v)
for(v<-map1)println(v)//v是Tuple?
说明
1.每遍历一次，返回的元素是Tuple2
2.取出的时候，可以按照元组的方式来取
代码如下：
// map的遍历
val map6 = mutable.Map(("A", 1), ("B", "北京"), ("C", 3))
println("----(k, v) <- map6----")
for ((k, v) <- map6) println(k + "is mapped to" + v)
println("----v <- map6.keys----")
for (v <- map6.keys) println(v)
println("----v <- map6.values----")
for (v <- map6.values) println(v)
println("----v <- map6----")
// 这样取出方式 v 类型时Tuple2
for (v <- map6) println(v + "key = "+v._1 + "val = "+v._2) // v是Tuple？
10.25、集Set-基本介绍
集是不重复元素的结合。集不保留顺序，默认是以哈希集实现
10.25.1、Java中Set的回顾
java中，HashSet是实现Set接口的一个实体类，数据是以哈希表的形式存放的，里面的不能包含重复数据。Set接口是一种不包含重复元素的collection，HashSet中的数据也是没有顺序的。
10.25.2、案例演示
Scala中Set的说明
import java.util.HashSet;
public class JavaHashSet {
public static void main(String[] args) {
HashSet hs = new HashSet<String>();
// Java中Set的元素 没有顺序 不能重复
hs.add("jack");
hs.add("tom");
hs.add("jack");
hs.add("jack2");
System.out.println(hs);
}
}
默认情况下，Scala使用的是不可变集合，如果你想使用可变集合，需要引用scala.collection.mutable.Set包
10.26、集Set-创建
import scala.collection.mutable
object SetDemo01 {
def main(args: Array[String]): Unit = {
val set = Set(1, 2, 3) // 不可变
println(set)
val set2 = mutable.Set(1, 2, "Hello") // 可变的
println("set2 = " + set2)
println(set.max)
println(set.min)
}
}
10.27、集Set-可变集合的元素添加和删除
10.27.1、可变集合的元素添加
mutableSet.add(4)//方式1
mutableSet+=6//方式2
mutableSet.+=(5)//方式3
说明：如果添加的对象已经存在，则不会重复添加，也不会报错
10.27.2、可变集合的元素删除
val set02=mutable.Set(1,2,4,"abc")
set02-=2//操作符形式
set02.remove("abc")//方法的形式，scala的Set可以直接删除值
println(set02)
//说明：如果删除的对象不存在，则不生效，也不会报错
10.27.3、set集合的遍历操作
val set02=mutable.Set(1,2,4,"abc")
for(x<-set02){
println(x)
}
10.28、集Set-更多操作
