一、队列（Queue）
1、Queue的基本介绍
队列的说明
1. 队列是一个有序列表，在底层可以用数组或是链表来实现；
2. 其输入和输出要遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出；
3. 在Scala中，由设计者直接给我们提供队列类型使用；
4. 在scala中, 有scala.collection.mutable.Queue和scala.collection.immutable.Queue, 一般来说，我们在开发
中通常使用可变集合（scala.collection.mutable.Queue）中的队列。
2、Queue的基本使用
示例代码：
package com.lj.scala.Gather
import scala.collection.mutable
object GatherTest13 {
def main(args: Array[String]): Unit = {
/**
* 说明：队列的创建（默认是可变的）
* 1. val q01 = new mutable.Queue[Int]() 或者 val q01 = mutable.Queue[Int]()；
* 2. [Int]: 说明队列的泛型类型是Int，要想放多种类型的数据可以设置泛型是Any；
*/
val q01 = new mutable.Queue[Int]() // 创建空的队列，()可以不带
println("空的队列q01：" + q01) // Queue()
/**
* 说明：向队列中追加单个元素和List（默认直接加在队列的后面）
* 1. q02 += 5 // 用 “+=” 符号向队列中添加单个元素；
* 2. 向队列中添加列表List（默认直接加在队列的后面）
* a): 通过‘++=’符号向队列中添加列表，此时对队列的泛型没有要求！
* b): 通过‘+=’符号向队列中添加列表，此时队列的泛型必须为Any才OK！
* 而且加入队列中的元素是一个List列表
*/
// 创建一个新的队列
val q02 = new mutable.Queue[Any]
q02 += 5 // 向队列中添加单个元素
q02 += "Tom"
println("通过‘+=’符号向队列中添加元素的结果：" + q02)
// 方式1：向队列中添加列表List
q02 ++= List(true, 2, "Jack")
println("方式1通过‘++=’符号向队列中添加列表的结果：" + q02)
// 方式2：向队列中添加列表List
q02 += List("Leo", false, 4, 7) // 此时队列的泛型是Any才OK，否则报错！！！
println("方式2通过‘+=’符号向队列中添加列表的结果：" + q02)
println("------------------华丽的分隔符-----------------------")
/**
* 说明：删除队列
* 1. 按照进入队列的顺序删除元素（队列先进先出），即入队列的数据放在队尾，出队列的数据是队列的头部！
* val q02_ele01 = q02.dequeue() // 删除队列的头部元素
* q02.enqueue(100, "Jack", q01) // 向队列中添加元素
*/
println("q02队列的数据：" + q02)
// dequeue：从队列q02的头部取出元素并删除，同时q02本身也会变化
val q02_ele01 = q02.dequeue()
println("队列取出的第一个元素：" + q02_ele01)
println("队列取出元素之后q02队列中剩余的元素：" + q02)
// 按照队列的算法，会将数据添加到队列的尾部
val q03 = new mutable.Queue[Int]()
q03 ++= List(1, 2, 4, 12, 45)
q02.enqueue(100, "Jack", q03)
println("队列添加元素之后q02队列中的元素：" + q02)
println("------------------华丽的分隔符-----------------------")
/**
* 说明：队列的返回（队列的本身没有变化）
* 1. val q02_head = q02.head // 返回队列的第一个元素
* 2. val q02_last = q02.last // 返回队列最后一个元素
* 3. val q02_tail = q02.tail // 返回队列的尾部
* 即：返回除了第一个以外剩余的元素， 可以级联使用，这个在递归时使用较多
* 例如：q02.tail.tail
*
*/
val q02_head = q02.head
println("q02队列的第一个元素：" + q02_head)
val q02_last = q02.last
println("q02队列的最后一个元素：" + q02_last)
val q02_tail = q02.tail
println("返回q02队列除了第一个元素以外的所有元素：" + q02_tail)
}
}
======================运行结果================================
空的队列q01：Queue()
通过‘+=’符号向队列中添加元素的结果：Queue(5, Tom)
方式1通过‘++=’符号向队列中添加列表的结果：Queue(5, Tom, true, 2, Jack)
方式2通过‘+=’符号向队列中添加列表的结果：Queue(5, Tom, true, 2, Jack, List(Leo, false, 4, 7))
------------------华丽的分隔符-----------------------
q02队列的数据：Queue(5, Tom, true, 2, Jack, List(Leo, false, 4, 7))
队列取出的第一个元素：5
队列取出元素之后q02队列中剩余的元素：Queue(Tom, true, 2, Jack, List(Leo, false, 4, 7))
队列添加元素之后q02队列中的元素：Queue(Tom, true, 2, Jack, List(Leo, false, 4, 7), 100, Jack, Queue(1, 2, 4, 12, 45))
------------------华丽的分隔符-----------------------
q02队列的第一个元素：Tom
q02队列的最后一个元素：Queue(1, 2, 4, 12, 45)
返回q02队列除了第一个元素以外的所有元素：Queue(true, 2, Jack, List(Leo, false, 4, 7), 100, Jack, Queue(1, 2, 4, 12, 45))
======================运行结果================================
二、映射（Map）
1、Map的基本介绍
Java中的Map回顾
1. HashMap是一个散列表(数组+链表)，它存储的内容是键值对(key-value)映射，Java中的HashMap是无序
的，key不能重复。
Scala中的Map介绍
1. Scala中的Map和Java类似，也是一个散列表，它存储的内容也是键值对(key-value)映射，Scala中不可变的
Map是有序的，可变的Map是无序的；
2. Scala中，有可变Map (scala.collection.mutable.Map) 和 不可变Map(scala.collection.immutable.Map)。
2、Map的构建
示例代码：
package com.lj.scala.Gather
object GatherTest14 {
def main(args: Array[String]): Unit = {
/**
* 说明：Map构建方式一：构造不可变映射（默认是不可变的映射）
* 1. Scala中的不可变Map是有序，构建Map中的元素底层是Tuple2类型。
*
* 2. 构造不可变映射小结
* a).从输出的结果看到，输出顺序和声明顺序一致;
* b).构建Map集合中，集合中的元素其实是Tuple2类型;
* c).默认情况下（即没有引入其它包的情况下）,Map是不可变map.
*/
val immutable_map01 = Map("Jack" -> 25, "Alice" -> 30)
// 下面输出结果：不可变元素immutable_map01：Map(Jack -> 25, Alice -> 30)
println("不可变元素immutable_map01：" + immutable_map01)
println("-----------------华丽分隔符--------------------")
/**
* 说明：Map构建方式二：构造可变映射
* 1. Scala中的可变Map是无序的，构建Map中的元素底层是Tuple2类型。
*
* 2. 构造可变映射小结
* a). 从输出的结果看到，输出顺序和声明顺序不一致.
*/
val mutable_map01 = scala.collection.mutable.Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> 30)
// 输出结果：可变元素mutable_map01：Map(Bob -> 20, Kotlin -> 30, Alice -> 10)
println("可变元素mutable_map01：" + mutable_map01)
println("-----------------华丽分隔符--------------------")
/**
* 说明：Map构建方式三：创建空的Map映射
* 1. val map02 = new mutable.HashMap[String, Int]{} // 创建空的映射Map需要指定key-value的类型
*/
val map02 = new mutable.HashMap[String, Int]{} // {}可带可不带
println("创建空的映射：" + map02)
println("-----------------华丽分隔符--------------------")
/**
* 说明：对偶元组
* 1. 即：创建包含键值对的二元组， 和第一种方式等价，只是形式上不同而已；
* 2. 对偶元组 就是只含有两个数据的元组。
*/
// 创建对偶元组需要导入包：import scala.collection.mutable
import scala.collection.mutable
val map03 = mutable.Map(("Jack", 16), ("Tom", 15), ("Leo", 20))
println("对偶元组map03:" + map03)
// 创建空的对偶元组
val map04 = mutable.Map()
println("空的对偶元组map04:" + map04)
}
}
======================运行结果================================
不可变元素immutable_map01：Map(Jack -> 25, Alice -> 30)
-----------------华丽分隔符--------------------
可变元素mutable_map01：Map(Bob -> 20, Kotlin -> 30, Alice -> 10)
-----------------华丽分隔符--------------------
创建空的映射：Map()
-----------------华丽分隔符--------------------
对偶元组map03:Map(Tom -> 15, Jack -> 16, Leo -> 20)
空的对偶元组map04:Map()
======================运行结果================================
3、Map的操作
示例代码：
package com.lj.scala.Gather
object GatherTest15 {
def main(args: Array[String]): Unit = {
/**
* 映射Map的取值方式一：
* 1. 使用map(key)取值
* 小结：
* a). 如果key存在，则返回对应的值
* b). 如果key不存在，则抛出异常[java.util.NoSuchElementException]
* c). 在Java中,如果key不存在则返回null
*
*/
// 创建一个Map映射
val map01 = scala.collection.mutable.Map[String, Int]("Jack" -> 20, "Tom" -> 19)
// 通过key取value值
val value01 = map01("Tom")
println("key值Tom对应的value01值：" + value01)
// val value02 = map01("Alice") // java.util.NoSuchElementException: key not found: Alice
/**
* 映射Map的取值方式二：
* 1. 使用contains方法检查是否存在key
* a). 如果key存在，则返回true.
* b). 如果key不存在，则返回false.
*
* 说明：使用containts先判断在取值，可以防止异常，并加入相应的处理逻辑
*/
var value02: Int = 0
if (map01.contains("Alice")) {
value02 = map01("Alice")
} else {
println("映射map01中的key值Alice不存在！！！")
value02 = map01("Jack")
}
println("映射Map通过contains方式取值结果：" + value02)
/**
* 映射Map的取值方式三：
* 1. 使用map.get(key).get取值
* 说明：通过“映射.get(键)”这样的调用返回一个Option对象，要么是Some，要么是None
*
* 小结：
* a). map.get(key)方法会将数据进行包装成Option对象；
* b). 如果 map.get(key) key存在返回some,如果key不存在，则返回None；
* c). 如果 map.get(key).get key存在，返回key对应的值,
* 否则，抛出异常 java.util.NoSuchElementException: None.get.
*
*/
// 创建对偶元组
import scala.collection.mutable
val map02 = mutable.Map(("上海", "复旦"), ("安徽", "少年科技大"), ("北京", "北大"), ("吉林", "吉林大学"))
val map02_value01_some = map02.get("上海") // 取到的值是Some(复旦)
println("map02_value01_some:" + map02_value01_some)
val map02_value01 = map02_value01_some.get // 得到Some再取值，从而取到的是具体的值
println("map02_value01:" + map02_value01) // 复旦
// map02.get("武汉").get // java.util.NoSuchElementException: None.get
/**
* 映射Map的取值方式三：
* 1. 使用map4.getOrElse()取值;
* 2. getOrElse 方法 : def getOrElse[V1 >: V](key: K, default: => V1)
* 说明：
* a). 如果key存在，返回key对应的值;
* b). 如果key不存在，返回默认值,在java中底层有很多类似的操作。
*/
val map02_value02 = map02.getOrElse("北京", "清华")
println("map02_value02:" + map02_value02)
val map02_value03 = map02.getOrElse("四川", "成都大学")
println("map02_value03:" + map02_value03)
/**
* 如何选择取值方式:
* 1. 如果我们确定map有这个key ,则应当使用map(key), 速度快;
* 2. 如果我们不能确定map是否有key ,而且有不同的业务逻辑，使用map.contains() 先判断在加入逻辑;
* 3. 如果只是简单的希望得到一个值，使用map4.getOrElse("四川", "成都大学")
*/
println("----------------------华丽分隔符------------------------")
println("当前map01的值：" + map01)
/**
* 映射Map的修改：
* 说明:
* a). map是可变的，才能修改，否则报错;
* b). 如果key存在,则修改对应的值、key不存在,等价于添加一个key-val.
*
*/
map01("Tom") = 15
map01("Leo") = 17
println("map01的值：" + map01)
/**
* 1. 添加映射Map的元素方式一：增加单个元素
* 说明：如果key存在,则修改对应的值、key不存在,等价于添加一个key-val
*
* 2. 添加映射Map的元素方式一：增加多个元素
* 说明：如果key存在,则修改对应的值、key不存在,等价于添加一个key-val
*
*/
map01 += ("Alice" -> 16)
map01 += ("Tom" -> 21)
println("增加单个元素之后map01的值：" + map01)
val map03 = map01 + ("MaLi" -> 22, "Alex" -> 23, "Tom" -> 26)
println("增加多个元素之后map03的值1：" + map03)
map01 += ("Rose" -> 23, "Marry" -> 30, "Tony" -> 19, "Tom" -> 29)
println("增加多个元素之后map01的值：" + map01)
println("增加多个元素之后map03的值2：" + map01)
/**
* 删除Map元素：map01 -= ("Rose", "Tom", "Seven")
* 说明：
* 1. "Rose", "Tom" 就是要删除的key, 可以写多个；
* 2. 如果key存在，就删除，如果key不存在，也不会报错.
*
*/
map01 -= ("Rose", "Tom", "Seven")
println("删除map01元素之后的值：" + map01)
/**
* Map元素的遍历：对map的元素(元组Tuple2对象 )进行遍历的方式很多种。
*
* 例如：
* for ((k, v) <- map01) println(k + " is mapped to " + v)
* for (v <- map01.keys) println(v)
* for (v <- map01.values) println(v)
* for(v <- map01) println(v) //v是Tuple?
*
* 说明：
* 1. 每遍历一次，返回的元素是Tuple2；
* 2. 取出的时候，可以按照元组的方式来取。
*/
// 遍历方式一：
for ((k, v) <- map01) {
println(k + " is mapped to " + v)
}
}
}
======================运行结果================================
key值Tom对应的value01值：19
映射map01中的key值Alice不存在！！！
映射Map通过contains方式取值结果：20
map02_value01_some:Some(复旦)
map02_value01:复旦
map02_value02:北大
map02_value03:成都大学
----------------------华丽分隔符------------------------
当前map01的值：Map(Tom -> 19, Jack -> 20)
map01的值：Map(Tom -> 15, Jack -> 20, Leo -> 17)
增加单个元素之后map01的值：Map(Tom -> 21, Jack -> 20, Alice -> 16, Leo -> 17)
增加多个元素之后map03的值1：Map(Alex -> 23, Jack -> 20, Tom -> 26, Alice -> 16, MaLi -> 22, Leo -> 17)
增加多个元素之后map01的值：Map(Marry -> 30, Tom -> 29, Jack -> 20, Alice -> 16, Tony -> 19, Rose -> 23, Leo -> 17)
增加多个元素之后map03的值2：Map(Marry -> 30, Tom -> 29, Jack -> 20, Alice -> 16, Tony -> 19, Rose -> 23, Leo -> 17)
删除map01元素之后的值：Map(Marry -> 30, Jack -> 20, Alice -> 16, Tony -> 19, Leo -> 17)
Marry is mapped to 30
Jack is mapped to 20
Alice is mapped to 16
Tony is mapped to 19
Leo is mapped to 17
======================运行结果================================
三、集（Set）
1、Set的基本介绍
集是不重复元素的结合。集不保留顺序，默认是以哈希集实现。
Java中Set的回顾
Java中，HashSet是实现Set<E>接口的一个实体类，数据是以哈希表的形式存放的，里面的不能包含重复
数据。Set接口是一种不包含重复元素的collection，HashSet中的数据也是没有顺序的。
示例：
HashSet hs = new HashSet<String>();
hs.add("jack");
hs.add("tom");
hs.add("jack");
hs.add("jack2");
System.out.println(hs);
Scala中Set的说明
默认情况下，Scala使用的是不可变集合，如果你想使用可变集合，需要引用 scala.collection.mutable.Set 包
2、Set的操作
示例代码：
package com.lj.scala.Gather
object GatherTest16 {
def main(args: Array[String]): Unit = {
/**
* 集Set创建：
* 1. 默认是不可变Set集合
* 2. 创建可变的Set集合，需要先导入包：import scala.collection.mutable.Set
*/
// 创建Set不可变集合
val immutable_set = Set(1, 3, 5, 19) // 不可变
println("不可变集immutable_set：" + immutable_set)
// 创建Set可变集合
import scala.collection.mutable.Set
val mutable_set = Set(4, 6, 10, 13)
println("可变集mutable_set：" + mutable_set)
/**
* 集Set--可变集合的元素添加：
* 1. Set集合添加元素，首先这个Set集合必须是可变
* 2. 如果添加的对象已经存在，则不会重复添加，也不会报错
*
* Set集合添加元素方式有三种：
* 1. // 添加元素方式1：
* mutable_set.add(9)
* 2. // 添加元素方式2：
* mutable_set += 11
* 3. // 添加元素方式3：
* mutable_set.+= (6, 10, 12) // 可以添加多个元素
*/
// 添加元素方式1：
mutable_set.add(9)
// 添加元素方式2：
mutable_set += 11
// 添加元素方式3：
mutable_set.+= (6, 10, 12)
println("添加元素之后的mutable_set集合：" + mutable_set)
/**
* 集Set--可变集合的元素删除：
*
* Set集合删除元素的方式有两种：
* 1. // 删除Set集合中的元素方式1：
* mutable_set -= 11
* 2. // 删除Set集合中的元素方式2：
* mutable_set.remove(10) // 方法的形式直接删除Set集合中元素
*
* 说明：如果删除的对象不存在，则不生效，也不会报错
*
*/
// 删除Set集合中的元素方式1：
mutable_set -= 11
// 删除Set集合中的元素方式2：
mutable_set.remove(10) // 方法的形式直接删除Set集合中元素
println("删除元素之后mutable_set集合的值：" + mutable_set)
/**
* Set集合的遍历
*/
for (ele <- mutable_set) {
println("mutable_set集合中的元素：" + ele)
}
}
}
======================运行结果================================
不可变集immutable_set：Set(1, 3, 5, 19)
可变集mutable_set：Set(13, 6, 10, 4)
添加元素之后的mutable_set集合：Set(12, 9, 13, 6, 10, 4, 11)
删除元素之后mutable_set集合的值：Set(12, 9, 13, 6, 4)
mutable_set集合中的元素：12
mutable_set集合中的元素：9
mutable_set集合中的元素：13
mutable_set集合中的元素：6
mutable_set集合中的元素：4
======================运行结果================================
Set集合的其他操作一览：
对以前的知识回顾，加深基础知识！
学习来自：北京尚硅谷韩顺平老师—尚硅谷大数据技术之Scala
每天进步一点点，也许某一天你也会变得那么渺小！！！
扫一扫
665
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
