1 简介
scala中的集合分为两种 ,可变集合和不可变集合, 不可变集合可以安全的并发的访问!
集合的类主要在一下两个包中
1) 可变集合包 scala.collection.mutable
2) 不可变集合包 scala.collection.immutable
scala默认使用的是不可变的集合 , 因此使用可变的集合需要导入可变集合的包
scala的集合主要分成三大类
- Seq 序列
- Set 不重复集
- Map 键值映射集
注意: 所有的集合都继承自Iterator迭代器这个特质
2 序列
许多数据结构是序列型的，也就是说，元素可以按特定的顺序访问，如：元素的插入顺
序或其他特定顺序。collection.Seq是一个trait，是所有可变或不可变序列类型的抽象，其子trait collection.mutable.Seq及collection.immutable.Seq分别对应可变和不可变序列。
从上面的图中可以看出Array,String ,List都属于序列
2.1 不可变数组
数组的基本操作 , scala中的数组和java中的不太一样 ,这里的数组类似于一个数组对象 .有自己的方法!!
2.1.1 数组的定义
def main(args: Array[String]): Unit = {
// 定义一个通用数组 没有执行数据类型 , 可以存储任意类型
val arr1 = Array("JIM", 12, 12.22, true)
// 指定泛型 约束数组中的数据类型 只能写泛型的子类
val arr2 = Array[Any]("JIM", 12, 12.22, true)
// 定义数组 定义数据类型 只能存储Int类型
val arr3 = Array[Int](1, 2, 3, 4)2,1,2 数组的基本操作
// 数组的取值
println(arr3(0))
//数组元素重新赋值
arr3(0) = 100
// 数组的遍历 方式一
for(e <- arr3){
println(e)
}
// 方式二
for (i <- 0 until arr3.length){
println(arr3(i))
}
// 方式三 仅仅用于打印
arr3.foreach(e=>print(e+" "))
// 方式四 map方法会取出来每个元素进行操作
arr3.map(println(_))
}2.1.3 数组中的基本方法
val arr = Array(1,3,5,7,9,2,6,4)
// 数组中的最大和最小值
val min: Int = arr.min
val max: Int = arr.max
// 首个元素
val head: Int = arr.head
//最后一个元素
val last: Int = arr.last
// 去除首个元素的子数组
val arr11: Array[Int] = arr.tail
// 将数组转换成List集合
val list: List[Int] = arr.toList
// 获取和后面数组中不同的元素
val diff: Array[Int] = arr.diff(Array(1,111,222))
//求数组元素的和
val sum: Int = arr.sum
// 默认排序
val sorted: Array[Int] = arr.sorted
// 数组的长度
arr.length
//修改指定位置的元素
arr.update(1,100)
// 取出数组中的前n个元素
val arr3: Array[Int] = arr.take(3)
// 后面添加一个元素 生成 新的数组
val arr2: Array[Int] = arr.:+(11)
// 后面添加一个数组
val res = arr:++arr3
// 统计符合条件的个数
val i: Int = arr.count(_>2)
// 数组反转
arr.reverse
// 将不可变数组转换成可变数组
val buffer: mutable.Buffer[Int] = arr.toBuffer2.1.4 例子
/**
* 数组的定义和遍历
* 在scala中数组是一个对象
* 数组是不可变 , 定义好以后数组的长度就固定了
*/
object ArrayDemo1 {
def main(args: Array[String]): Unit = {
// 数组的定义 没有指定泛型 自动推导
val arr = Array(1,2,3,4,45,6,7)
// 不可变转可变
val buffer = arr.toBuffer
val arr2 = Array[String]("xx" , "yy" ,"zz")
// 根据数组角标的值获取元素
val firstElement = arr(0)
// 1 数组的遍历
for (elem <- arr) {
//遍历数组中的乜咯元素
}
// 2 使用角标遍历数组 注意取值
for(index <- 0 until arr.size){
println(arr(index))
}
// 3 使用方法 foreach 遍历数组 foreach 方法没有返回值 一般用于打印
arr2.foreach(x=>println(x))
}
}/**
* 数组默认是不可变的数组 数组的长度
* 不可变: 长度
*/
object ArrayDemo2 {
def main(args: Array[String]): Unit = {
val arr = Array("java" , "js" ,"linux" ,"hive" , "hbase")
// 数组的长度
println(arr.length)
println(arr.size)
// 打印角标为0的元素
println(arr(0))
// 在给标为0的元素重新赋值 更新元素
arr(0) = "JAVA"
println(arr(0))
}
}/**
* 数组一个对象
* 方法 对数组进行操作
* length 数组长度
* size 数组长度
* 1 update(index,newVal) 更新元素
* 2 reverse 空参的方法 将数组反转
*/
object ArrayDemo3 {
def main(args: Array[String]): Unit = {
// 通过方法的调用返回数组
val arr: Array[String] = "hello tom jim cat jiji mm xd xe".split("\\s+")
// 遍历数组
/*for(index <- 0 until arr.length){
println(index+"-->"+arr(index))
}*/
//更新指定位置的元素 参数一 角标参 数二新值
arr.update(0,"doit14") // arr(0) = "doit14"
// 遍历数组
/* for(index <- 0 until arr.length){
println(index+"-->"+arr(index))
}*/
arr.foreach(e=>print(e+" "))
// 将原来的数组反转 返回新的数组
val arr2: Array[String] = arr.reverse
println()
// 打印每个元素
arr2.foreach(e=>print(e+" "))
}
}**
* 数组一个对象
* 方法 对数组进行操作
* length 数组长度
* size 数组长度
* 1 update(index,newVal) 更新元素
* 2 reverse 空参的方法 将数组反转
* 3 reduce 每个元素累计操作 聚合操作
* 4 max 获取数组中的最大元素
* 5 min 获取数组中最小的元素
* 6 sorted 将数组中的元素按照默认的排序 数值(小--->大) 字符串(字段的先后排序) 自定义的类???
* 7 exists 判断是否有符合要求的元素
* 8 drop(num) 删除n个元素
* 9 distinct 去除数组中重复的元素
* 10 sum 求和
*/
object ArrayDemo4 {
def main(args: Array[String]): Unit = {
val arr = Array(1, 2, 3, 4, 33, 21, 11, 22,2,22,22)
// reduc单词的意思是集合 方法的参数是一个函数 a1数组中的前面一个元素 a2代表后一个元素
val res = arr.reduce((a1, a2) => a1 + a2) // (((1+2)+3)+4)
println(res)
val max = arr.max
println(max) // 最大元素
println(arr.min) // 最小元素
val newArr1 = arr.sorted // 默认排序 小 --> 大
val newArr2 = arr.sorted.reverse // 方法的连续调用
newArr1.foreach(e => print(e + " "))
newArr2.foreach(e => print(e + " "))
println()
// 定义一个函数
val f = (e: Int) => {
e == 1111
}
// 方法的参数中是一个函数 p:Int=>Boolean
println(arr.exists(f))
arr.exists((e: Int) => {
e == 11
}) // 知道签名固定的p:Int=>Boolean
arr.exists(e => e == 11) // 一个参数() 省略 函数体一行代码 {} 省略
// 从0位置开始删除元素 之后 返回一个新的数组 参数是 删除元素的个数
val ints = arr.drop(4)
println()
arr.foreach(e => print(e + " "))
println()
ints.foreach(e => print(e + " "))
// 去除数组中重复的元素
val distincts: Array[Int] = arr.distinct
println()
distincts.foreach(e => print(e + " "))
// 数字类型的数组元素累加求和
distincts.sum
}
}/**
* 数组一个对象
* 方法 对数组进行操作
* -------length 数组长度
* -------size 数组长度
* 1 update(index,newVal) 更新元素
* -------2 reverse 空参的方法 将数组反转
* 3 reduce 每个元素累计操作 聚合操作
* 4 max 获取数组中的最大元素
* 5 min 获取数组中最小的元素
* -------6 sorted 将数组中的元素按照默认的排序 数值(小--->大) 字符串(字段的先后排序) 自定义的类???
* 7 exists 判断是否有符合要求的元素
* 8 drop(num) 从0的位置删除n个元素
* -------9 distinct 去除数组中重复的元素
* -------10 sum 求和
* -------11 map 遍历数组中的每个元素 分别处理 将处理的结果返回到一个新的数组中
* -------12 foreach 遍历数组中的每个元素 没有返回值 一般用于打印
* -------13 contains(elem) 判断数组中是否包含某个元素 和exists氛 条件的 ==
* -------数组的定义
* -------数组的遍历
*/
object ArrayDemo5 {
def main(args: Array[String]): Unit = {
val arr1 = Array(1,2,3,4,5,6,6)
val arr2 = Array("a" ,"b" , "c" , "f")
//foreach[U](f:Int=>U) foreach[U](f:String=>U)
/**
* 遍历每个元素 依次赋值给e => 处理每个元素 没有返回值 一般用于打印
*/
arr1.foreach(e =>println(e))
// map(f:Int=>B) map(f:String=>{}) B block U unit
/**
* 遍历数组中的每个元素 对每个元素依次处理 将处理后的结果返回到一个新的数组中
*/
val arr: Array[Int] = arr1.map(e => e * 10)
for (elem <- arr) {
println(elem)
}
val res = arr2.map(e => e.toUpperCase())
res.foreach(e=>print(e+" "))
// 判断数组中是否包含某个元素
val b: Boolean = arr1.contains(6)
println(b)
}
}2.2 可变数组
导入可变数组 : import scala.collection.mutable.ArrayBuffer ,可以修改元素的数组为可变数组
private val arr = ArrayBuffer(12,23,34,45,56,67)
val arr1 = Array(101, 102)
// 数组中添加一个元素
arr += 78
// 数组中合并一个数组的数据
arr++=arr1
// 除去数组中的一个元素
arr-=78
// 移出一个数组的元素
arr--=arr1
//移出角标位置为2 的数据
arr.remove(2)
// 从0位置删除2个元素 参数一 坐标 参数2 删除元素的个数
arr.remove(0,2)
//将可变数组转换成不可变数组
arr.toArray2.2.1 例子
// 导包 可以在任意的位置 ._ 包内的所有的内容
import scala.collection.mutable._
/**
* 可变数组
* 数组内的元素的可数可变变化
* scala.collection.mutable 包中是可变的集合
*
* 可变数组中的方法
* 1 +=
* 2 -=
* 3 remove(index) 删除指定位置的元素
* 4 remove(index , num)定位置开始 删除num个元素
*
*/
object ArrayBufferDemo {
def main(args: Array[String]): Unit = {
// 定义一个可变的数组 atl+enter 快速导包
val arrayBuffer = ArrayBuffer(1, 3, 5, 7, 9)
// 可变数组拥有不可变数组中所有的方法和遍历方式
arrayBuffer.foreach(e=>print(e+" "))
println()
arrayBuffer.map(e=>print(e+" "))
println()
for (elem <- arrayBuffer) {print(elem+" ")}
println()
for(index <- 0 to arrayBuffer.length-1){print(arrayBuffer(index)+" ")}
println()
// 可变数组的长度可变 添加元素 删除元素 添加一个子数组
arrayBuffer+=10
for(index <- 0 to arrayBuffer.length-1){print(arrayBuffer(index)+" ")}
println()
// 删除一个元素
arrayBuffer-=1
for(index <- 0 to arrayBuffer.length-1){print(arrayBuffer(index)+" ")}
println()
arrayBuffer.remove(2) // 3 5 7 9 10 删除角标为2 的元素3 5 9 10
for(index <- 0 to arrayBuffer.length-1){print(arrayBuffer(index)+" ")}
println()
// 参数一 数组的索引 参数二 删除元素的个数
arrayBuffer.remove(0,2)
for(index <- 0 to arrayBuffer.length-1){print(arrayBuffer(index)+" ")}
println()
}
}/**
* 可变数组
* 数组内的元素的可数可变变化
* scala.collection.mutable 包中是可变的集合
*
* 可变数组中的方法
* 1 +=
* 2 -=
* 3 remove(index) 删除指定位置的元素
* 4 remove(index , num)定位置开始 删除num个元素
*
* 5 ++= 添加一个子数组 不会去重重复数据
* 6 --=
* 7 clear 清除数组中所有的元素
*
*/
object ArrayBufferDemo2 {
def main(args: Array[String]): Unit = {
// 定义可变的数组
val arr1 = ArrayBuffer("a", "b", "c", "e", "f")
val arr2 = ArrayBuffer( "e", "f")
arr1++=arr2
arr1.foreach(e=>print(e+" "))
arr1--=arr2
println()
arr1.foreach(e=>print(e+" "))
val newarr = arr1.+:("hello") // 头部添加一个元素 返回新的数组
println()
newarr.foreach(e=>print(e+" "))
// 清除数组中所有的元素
arr1.clear()
// 可变数组 转成不可变数组
arr1.toArray
}
}2.3 List
2.3.1 不可变List
/ 不可变的List集合 数据不允许被修改
private val ls1 = List("SCALA", "HDP", "SPARK" , 12 , 34)
// 向Nil空队列中添加元素组成新的队列
val ls2 = "HIVE" :: "MYSQL" :: "HBASE" :: Nil
// Nil 和 List.empty[Nothing]是等价的
private val ll = List.empty[Nothing]
ls1(0) // 获取指定位置元素
// 添加一个元素生成新的List
val ls3 = ls1 :+ "PYTHON"
//合并两个集合 生成新的集合
val ls4 = ls1 ++ ls2
ls1.foreach(println)
// 获取前两个元素 组成新的List
ls1.take(2)
println(ls1.take(2))
println(ls1.takeRight(2)) // 从右边取数据
// 遍历每个元素 参数是一个偏函数
ls1.collect({ case x: Int => x })
// 查找匹配的元素 仅仅返回一个元素
ls1.find(x=>x.toString.startsWith("S"))
// 判断是否为null集合
ls1.isEmpty
// 转换成可变List集合
ls1.toBuffer
2.3.2 可变List
val ls1 = ListBuffer(1, 3, 5, 7)
val ls2 = ListBuffer(2, 4, 6, 8)
ls1 += 9
ls1 -= 9
//并入一个list
ls1 ++= ls2
ls1 --= ls2
// ls1.clear()
ls1.size
ls1.length
// 转换成不可变集合
ls1.toList
// ls1.update(1,100)
ls1.head
ls1.tail
// 合并两个集合
val ls3 = ls1 ++ ls2
println(ls3)2.3.2 例子
/**
* 定义和遍历
* 不可变的List集合 : list 列表
* 一 list集合的定义
* 1. List("java", "scala", "js", "css", "SQL")
* 2."HDP" :: "HBASE" :: "HIVE" :: Nil
* 3 其他集合额的转换 toList
* 二 list集合的遍历 和 数组的遍历方式一样
* 1 for (elem <- list1)
* 2 for (i <- 0 to list1.size - 1) {list1(i)}
* 3 foreach
* 4 map
* list1(1) 取值
*/
object ListDemo1 {
def main(args: Array[String]): Unit = {
// 创建不可变的list集合
val list1 = List("java", "scala", "js", "css", "SQL")
// list1+=""
//list集合的定义
val list2 = "HDP" :: "HBASE" :: "HIVE" :: Nil
/* for (elem <- list1) {
println(elem)
}
for (elem <- list2) {
println(elem)
}
list1.size
// 根据索引获取list集合中的元素 和java中的get(0)
val str = list1(1) // 和数组的取值
println(str)
println()
// 遍历list 索引
for (i <- 0 to list1.size - 1) {
println(list1(i))
}
*/
list1.foreach(e=>print(e+" "))
println()
list2.map(e=>print(e+" "))
}
}/**
* 1 arr.toList 数组转list
* 2 :+ e 在list集合的后面添加一个元素返回新的集合
* 3 ++ ls2 在list集合的后面添加一个子list集合返回新的集合
* 4 take(n) 从头开始取n个元素 返回新的list 当值大于list的长度 获取所有的数据
* 5 takeRight 从尾部(右边)开始取n个元素 返回新的list 当值大于list的长度 获取所有的数据
* 6 takeWhile 从头获取符合条件的数据 返回到新的集合中 如果元素不满足终止
* 7 isEmpty 判断集合是否是空集合
*/
object ListDemo2 {
def main(args: Array[String]): Unit = {
val arr = "hello him cat tom jerry doit".split(" ")
//数组转换成list集合
val ls: List[String] = arr.toList
val ls2 = List("a" ,"b")
ls.foreach(x=>print(x+" "))
println()
// 向list集合中添加元素 返回一个新的list
val res1= ls :+ "hgy" // 尾部
// 向;list集合中添加一个子list 返回一个新的list
val res2 = ls ++ ls2
res2.foreach(x=>print(x+" "))
println()
// 从头开始取两个元素 返回新的list
val res3 = ls.take(20)
res3.foreach(x=>print(x+" "))
println()
// 从右边取两个
val res4 = ls.takeRight(2)
res4.foreach(x=>print(x+" ")) // jerry doit
println()
// 从头获取符合条件的数据 返回到新的集合中 如果元素不满足终止
val res5 = ls.takeWhile(e => e.startsWith("h"))
res5.foreach(x=>print(x+" ")) // jerry doit
println()
println(ls.isEmpty)
}
}import scala.collection.mutable._
/**
* 可变的list结合
* 里面的元素可变 长度
*
* 1 += 添加一个元素
* 2 -= 删除一个元素
* 3 remove(1) 删除指定位置的元素
* 4 remove(1, num) 从指定位置开始删除n个元素
* 5 ++= 添加一个子集合中所有的元素
* 6 --= 移出在自己和中出现的元素
* 7 ++ 两个集合合并返回一个新的集合
* 8 drop(num) 从头删除元素的个数 返回一个新的集合
* 9 update(index , newval) 更新指定位置的元素
*/
object ListBufferDemo {
def main(args: Array[String]): Unit = {
val ls1 = ListBuffer(1, 2, 3, 4, 5)
val ls2 = ListBuffer(5, 6, 7, 100)
// 可变list集合的遍历和数组 不可变的list集合遍历方式一样
// ls1+=11 // 添加一个元素
//ls1-=5 // 移除一个元素
// ls1.remove(1) // 移出指定位置的元素
//添加一个子集合
// ls1 ++= ls2
// ls1 --= ls2
// 两个集合合并返回一个新的集合
//val res = ls1 ++ ls2
// val res = ls1.drop(2)
ls1.update(0,1111)
ls1.foreach(e => print(e + " "))
}
}import java.util
object ListBufferDemo2 {
def main(args: Array[String]): Unit = {
val list = new util.ArrayList[String] ()
list.add("hello")
}
}
3 Set
Set和list的最大区别在于Set中不可以存储重复数据 ,通常使用Set来实现元素的去重!!
Set集合也分为可变Set和不可变的Set,使用包名来区分可变和不可变
// 不可变集合
val s = Set(1, 2, 3, 4, 4, 5)
s.exists(x=>x>1)
// 可变se
import scala.collection._
val set = new mutable.HashSet[Int]()
set.add(12)
set += 21
set.remove(12)
set.foreach(println)3.1 例子
/**
* Set集合和List集合的最大区别在于Set集合可以去除重复数据
* 可变的Set
* 不可变的Set 默认的
*/
object SetDemo1 {
def main(args: Array[String]): Unit = {
//定义了一个不可变的Set集合 默认的不可变 自定的去除重复的元素 , 不保顺序
val s1 = Set(1,2,3,4,4,5,6)
// 遍历方式和list Array一致
s1.foreach(e=>println(e+" "))
s1.size
val res = s1 + 11
println(s1(2))// 判断Set集合中是否有2元素
}
}/**
* 可变Set集合定义的时候指定包名 , 建议指定泛型
* mutable.Set[Int]()
* 1 += e
* 2 -= e
* 3 remove()
* 4 add()
* 5 clear() 清空集合
* 6 ++= 添加一个新的set集合
* 7 --=
* 8 ++ 合并两个集合 返回新的集合
* 9 -- 返回新的集合
*
*/
object SetDemo2 {
def main(args: Array[String]): Unit = {
val set1 = mutable.Set[Int](1,2,3)
val set2 = mutable.Set[Int](3, 4,5,6)
val res = set1 ++ set2
println(set1.size)
/* println(set.size)
println(set.isEmpty)
// 向可变的Set中添加元素
set+=12
set+=11
// 添加
set.add(110)
set.remove(11)
set-=12
set.clear()
println(set.size)
println(set.isEmpty)*/
println(set1(1))
println(set1.contains(1))
// 不是很强指定位置的元素 不是Seq 没有index索引 hashcode
set1(1)
}
}object SetDemo3 {
def main(args: Array[String]): Unit = {
val list = List(1,2,3,4,4,5,6,6,6,6,7)
list.distinct.foreach(e=>print(e+" "))
println()
val set = list.toSet
set.foreach(e=>print(e+" "))
}
}/**
* HashSet
* immutable.HashSet 默认的不可变的
* mutable.HashSet 可变的
* 创建对象集合
* 1 mutable.HashSet[Int]()
* 2 new mutable.HashSet[Int]()
*/
object HashSetDemo {
def main(args: Array[String]): Unit = {
// 可变的hashset集合
val hset = mutable.HashSet[String]()
hset.add("12")
hset.add("121")
hset.add("122")
val iterator = hset.toIterator
while(iterator.hasNext){
println(iterator.next())
}
Array().toIterator
List().toIterator
Seq().toIterator
}
}4 特殊集合元组
scala中存在一种特殊的集合元组, 元组中可以存储任意类型的元素 ,但是只能存储22个 , 其中对偶元组经常用作键值映射
与列表一样，元组也是不可变的，但与列表不同的是元组可以包含不同类型的元素。
注意productIterator的用法
// 创建一个三个元素的元组
val tp = new Tuple3(1,3,4)
val tuple: (Int, Double, String) = (1, 3.14, "Fred")
// 获取指定位置的元素
tuple._2
// 迭代元组
tuple.productIterator.foreach(println)
// 元组转换成字符串
val str: String = tuple.toString()
println(str)
// 对偶元组
val tuple2: ((String, String), (String, String), (String, String), (String, String)) = (("wd", "zsf"), ("sl", "fsy"), ("em", "shit"), ("huashan", "lhc"))
// 获取对偶元组第一个元素的key的值
println(tuple2._1._1)
val tp = (String, String)
// 交换位置
tp.swap/**
* 特殊的集合 元组
* 普通的元组
* 定义
* 1 Tuple4("a", "b","c" ,"d")
* 2 (.....22个)
* 3 取值 ._n
* 4 遍历
* productIterator 迭代器遍历
*/
object TupleDemo1 {
def main(args: Array[String]): Unit = {
// 定义一个元组 元素只能存储三个
val tuple = Tuple4("a", "b","c" ,"d")
// 取值 ._n
println(tuple._3)
// 元组定义
val tuple1: (Int, Int, Int, Int, Int, String) = (1, 2, 3, 4, 5, "hello")
println(tuple1._2)
// val s = tuple1.toString()
println(tuple1)
// 遍历元组
val iterator = tuple1.productIterator
for (elem <- iterator) {println(elem)}
}
}/**
* 对偶元素
* 元组中的每个元素是 一对值 KV
* MapReduce KV
*/
object TupleDemo2 {
def main(args: Array[String]): Unit = {
val tuple = (("hgy", 29), ("taoge", 41), ("nana", 28))
println(tuple._1._2) // hgy
println(tuple._2._2) // 41
println(tuple._3._1) // nana
/* val iterator: Iterator[Any] = tuple.productIterator
while(iterator.hasNext){
val arr: Any = iterator.next()
}
}
}5 Map
Map集合也是分为可变Map和不可变Map , 使用包名来区分是可变M安排还是不可变Map
// 不可变的Map
val map1 = Map[String, Int](
("n1", 10),
("n2", 11),
("n3", 12)
)
val map2 = Map[String, Int](
"n1" -> 10,
"n2" -> 11,
"n3" -> 12
)
val m: HashMap[String, Int] = HashMap[String, Int]("n3" -> 12)
//不可变的map没有put方法
// 定义可变的集合
import scala.collection._
val map = new mutable.HashMap[String, String]()
map.put("wd", "ssf")
map.put("sl", "fsy")
// 根据key获取元素 , 没有给默认值
map.getOrElse("", "")
// 根据key更新数据 没有不做操作
val str: String = map.getOrElseUpdate("s2", "haha")
// 删除key
map.remove("")
map.get("")
map.+=(("",""))
map.update("","")
val arr: Array[(String, String)] = map.toArray
//是否包含
map.contains("")
// 返回迭代器
map.keys
//返回set
map.keySet
map.take(1)Map的遍历
map的遍历方式多种多样
val map = Map[String, Int](
("n1", 10),
("n2", 11),
("n3", 12)
)
// 循环获取键值对
for (e <- map) {
val key = e._1
val value = e._2
}
// 元组的形式接受键值对
for ((k, v) <- map) {
println(k)
println(v)
}
// 只接受key
for ((k, _) <- map) {
println(k)
}
// 只接受value
for ((_, v) <- map) {
println(v)
}
//返回所有的key
val keys: Iterable[String] = map.keys
val set: Set[String] = map.keySet
for (key <- keys) {
// 根据key获取value
val value: Option[Int] = map.get(key)
val v = value.get
}
for (key <- set) {
val value: Option[Int] = map.get(key)
val v = value.get
}
// 获取所有的values
val values: Iterable[Int] = map.values
// map转换成对偶元组的List和Array
val list: List[(String, Int)] = map.toList
val array: Array[(String, Int)] = map.toArray/**
* Map集合存储的是键值对的数据
* 对偶元组
*/
object MapDemo1 {
def main(args: Array[String]): Unit = {
// 定义一个不可变的Map集合
val mp1 = Map[String, Int](("zss", 21), ("zwj", 33), ("zcs", 55))
//可变的Map
val mp2 = mutable.Map[String, Int]()
// 向可变的map中添加元素
mp2.put("zsf" ,100)
mp2.put("zyr",10000000)
mp2.put("zmm",23)
// Map的定义方式
val mp3 = Map[String, String](
"A" -> "a",
"B" -> "b",
"C" -> "c")
// 可变的哈市Map
val hashMap = mutable.HashMap[String, Double]()
hashMap.put("李现",88)
hashMap.put("李沁",77)
hashMap.put("李纯",88)
}
}/**
* Map集合的遍历
*/
object MapDemo2 {
def main(args: Array[String]): Unit = {
val hashMap = mutable.HashMap[String, Double]()
hashMap.put("李现",88)
hashMap.put("李沁",77)
hashMap.put("李纯",68)
hashMap.put("李晨",18)
hashMap.put("李宇",58)
// 1 遍历Map
/* for (elem <- hashMap) { // Map继承自迭代器 elem每个键值对
// key value
println(elem._1 +"------"+ elem._2)
}*/
// 2 将Map转换成迭代器 获取每个对偶元组
/* val iterator = hashMap.toIterator
while(iterator.hasNext){
// 获取每个元素 对偶元组
val tuple: (String, Double) = iterator.next()
tuple._1
tuple._2
}*/
// 3 遍历 使用kv变量分别接受 key 和 value
/* for((k,v)<- hashMap){
println(k)
println(v)
}*/
// 4 遍历 只接受 k 或者只接受value
/* for((k,_)<-hashMap){
println(k)
}
for((_,v)<-hashMap){
println(v)
}*/
// val v = hashMap.get("孙悟空")
// 5 遍历 通过遍历所有的key 遍历value
/* val keys = hashMap.keySet
for (key <- keys) {
val v = hashMap.get(key)
println(key+"----"+v.get)
}*/
// 6 遍历
// 6.1 获取所有的keys 和 keySet所用一样
val ks: Iterable[String] = hashMap.keys
for (elem <- ks) {
println(elem)
}
// 6.2 获取所有的value
hashMap.values.foreach(v=>println(v))
}
}
/**
* Map中的方法
*/
object MapDemo3 {
def main(args: Array[String]): Unit = {
val mp = Map[String ,Int]("A"->23 ,"B"->33)
val mp2= mutable.Map[String, Double]()
// 添加元素
mp2.put("x",11d)
/**
* 在map中根据key去获取value的时候
* 1) 有可能是没有值 获取不到内容 None
* 2) 有值 返回value值 Some(11)
* Option就是对两种情况的封装
*/
val option: Option[Double] = mp2.get("y")
// 如果Option中是Some 返回true
val b: Boolean = option.isDefined
if(b){
val value = option.get
println(value)
}else{
println("没有这个key")
}
// 根据key获取value值 如果能获取到值返回 没有值给默认的 联想java中的getOrDefault()
val v = mp2.getOrElse("oo", "默认值")
println(v)
// 判断map中是否存在这个key 如果存在返回true
val bb = mp2.contains("x")
//根据key删除一个元素 如果这个key不存在 不操作
mp2.remove("o")
println(mp2.size)
// 清空集合
mp2.clear()
// 更新指定key的值
mp2.update("x",23)
// 将map转换成 Array List Set 迭代器
val ls: immutable.Seq[(String, Int)] = mp.toList
}
}
6 Option
Option(选项)类型用来表示一个值是可选的（有值或无值)。
Option[T] 是一个类型为 T 的可选值的容器： 如果值存在， Option[T] 就是一个 Some[T] ，如果不存在， Option[T] 就是对象 None 。
Option 有两个子类别，一个是 Some，一个是 None，当他回传 Some 的时候，代表这个函式成功地给了你一个 String，而你可以透过 get() 这个函式拿到那个 String，如果他返回的是 None，则代表没有字符串可以给你。
val myMap: Map[String, String] = Map("key1" -> "value")
val value1: Option[String] = myMap.get("key1")
val value2: Option[String] = myMap.get("key2")
println(value1) // Some("value1")
println(value2) // None