大数据技术之Scala
集合
1、数组
1.1、不可变数组与可变数组的转换
1）说明
arr1.toBuffer //不可变数组转可变数组arr2.toArray //可变数组转不可变数组
arr2.toArray 返回结果才是一个不可变数组，arr2 本身没有变化
arr1.toBuffer 返回结果才是一个可变数组，arr1 本身没有变化
2）案例实操
object TestArrayBuffer {
def main(args: Array[String]): Unit = {
//（1）创建一个空的可变数组
val arr2 = ArrayBuffer[Int]()
//（2）追加值arr2.append(1, 2, 3)
println(arr2) // 1,2,3
//（3）ArrayBuffer ==> Array
//（3.1）arr2.toArray 返回的结果是一个新的定长数组集合
//（3.2）arr2 它没有变化
val newArr = arr2.toArray println(newArr)
//（4）Array ===> ArrayBuffer
//（4.1）newArr.toBuffer 返回一个变长数组 newArr2
//（4.2）newArr 没有任何变化，依然是定长数组val newArr2 = newArr.toBuffer newArr2.append(123)
println(newArr2)
}
}
1.2、多维数组
1）多维数组定义
val arr = Array.ofDim[Double](3,4)
说明：二维数组中有三个一维数组，每个一维数组中有四个元素
2）案例实操
object DimArray {
def main(args: Array[String]): Unit = {
//（1）创建了一个二维数组, 有三个元素，每个元素是，含有 4 个元素一维
数组()
val arr = Array.ofDim[Int](3, 4) arr(1)(2) = 88
//（2）遍历二维数组
for (i <- arr) { //i 就是一维数组
for (j <- i) {
print(j + " ")
}
println()
}
}
}
2、列表List
2.1、不可变List
1)说明
①List 默认为不可变集合
②创建一个 List（数据有顺序，可重复）
③遍历 List
④List 增加数据
⑤集合间合并：将一个整体拆成一个一个的个体，称为扁平化
⑥空集合 Nil
2)案例实操
object TestList {
def main(args: Array[String]): Unit = {
//（1）List 默认为不可变集合
//（2）创建一个 List（数据有顺序，可重复） val list: List[Int] = List(1,2,3,4,3)
//（7）空集合 Nil
val list5 = 1::2::3::4::Nil
//（4）List 增加数据
//（4.1）::的运算规则从右向左
//val list1 = 5::list val list1 = 7::6::5::list
//（4.2）添加到第一个元素位置val list2 = list.+:(5)
//（5）集合间合并：将一个整体拆成一个一个的个体，称为扁平化val list3 = List(8,9)
//val list4 = list3::list1 val list4 = list3:::list1
//（6）取指定数据println(list(0))
//（3）遍历 List
//list.foreach(println)
//list1.foreach(println)
//list3.foreach(println)
//list4.foreach(println) list5.foreach(println)
}
}
2.2、可变ListBuffer
1)说明
①创建一个可变集合 ListBuffer
②向集合中添加数据
2)案例实操
import scala.collection.mutable.ListBuffer object TestList {
def main(args: Array[String]): Unit = {
//（1）创建一个可变集合
val buffer = ListBuffer(1,2,3,4)
//（2）向集合中添加数据buffer.+=(5) buffer.append(6) buffer.insert(1,2)
//（3）打印集合数据buffer.foreach(println)
//（4）修改数据buffer(1) = 6 buffer.update(1,7)
//（5）删除数据buffer.-(5)
buffer.-=(5) buffer.remove(5)
}
}
3、Set集合
默认情况下， Scala 使用的是不可变集合， 如果你想使用可变集合， 需要引用scala.collection.mutable.Set 包
3.1、不可变Set
1)说明
①Set 默认是不可变集合，数据无序
②数据不可重复
③遍历集合
2)案例实操
def main(args: Array[String]): Unit = {
//（1）Set 默认是不可变集合，数据无序
val set = Set(1,2,3,4,5,6)
//（2）数据不可重复
val set1 = Set(1,2,3,4,5,6,3)
//（3）遍历集合for(x<-set1){ println(x)
}
}
}
3.2、可变的mutable.Set
1)说明
①创建可变集合 mutable.Set
②打印集合
③集合添加元素
④向集合中添加元素，返回一个新的 Set
⑤删除数据
2)案例实操
object TestSet {
def main(args: Array[String]): Unit = {
//（1）创建可变集合
val set = mutable.Set(1,2,3,4,5,6)
//（3）集合添加元素set += 8
//（4）向集合中添加元素，返回一个新的 Set val ints = set.+(9)
println(ints) println("set2=" + set)
//（5）删除数据
set-=(5)
//（2）打印集合set.foreach(println) println(set.mkString(","))
}
}
4、Map集合
Scala 中的 Map 和 Java 类似，也是一个散列表，它存储的内容也是键值对（key-value） 映射
4.1、不可变Map
1)说明
①创建不可变集合 Map
②循环打印
③访问数据
④如果 key 不存在，返回 0
2)案例实操
object TestMap {
def main(args: Array[String]): Unit = {
// Map
//（1）创建不可变集合 Map
val map = Map( "a"->1, "b"->2, "c"->3 )
//（3）访问数据
for (elem <- map.keys) {
// 使用 get 访问 map 集合的数据，会返回特殊类型 Option(选项):
有值（Some），无值(None)
println(elem + "=" + map.get(elem).get)
}
//（4） 如 果 key 不 存 在 ， 返 回 0 println(map.get("d").getOrElse(0)) println(map.getOrElse("d", 0))
//（2）循环打印map.foreach((kv)=>{println(kv)})
}
}
4.2、可变Map
1）说明
①创建可变集合
②打印集合
③向集合增加数据
④删除数据
⑤修改数据
2）案例实操
object TestSet {
def main(args: Array[String]): Unit = {
//（1）创建可变集合
val map = mutable.Map( "a"->1, "b"->2, "c"->3 )
//（3）向集合增加数据map.+=("d"->4)
// 将数值 4 添加到集合，并把集合中原值 1 返回
val maybeInt: Option[Int] = map.put("a", 4) println(maybeInt.getOrElse(0))
//（4）删除数据map.-=("b", "c")
//（5）修改数据map.update("d",5) map("d") = 5
//（2）打印集合map.foreach((kv)=>{println(kv)})
}
}
5、元组
1)说明
元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。说的简单点，就是将多个无关的数据封装为一个整体，称为元组。
注意：元组中最大只能有22个元素。
2)案例实操
①声明元组的方式：(元素 1，元素 2，元素 3)
②访问元组
③Map 中的键值对其实就是元组,只不过元组的元素个数为 2，称之为对偶
object TestTuple {
def main(args: Array[String]): Unit = {
//（1）声明元组的方式：(元素 1，元素 2，元素 3)
val tuple: (Int, String, Boolean) = (40,"bobo",true)
//（2）访问元组
//（2.1）通过元素的顺序进行访问，调用方式：_顺序号println(tuple._1)
println(tuple._2) println(tuple._3)
//（2.2）通过索引访问数据println(tuple.productElement(0))
//（2.3）通过迭代器访问数据
for (elem <- tuple.productIterator) { println(elem)
}
//（3）Map 中的键值对其实就是元组,只不过元组的元素个数为 2，称之为
对偶
val map = Map("a"->1, "b"->2, "c"->3) val map1 = Map(("a",1), ("b",2), ("c",3))
map.foreach(tuple=>{println(tuple._1 + "=" + tuple._2)})
}
}
6、集合常用函数
6.1、基本属性和常用操作
1)说明
①获取集合长度
②获取集合大小
③循环遍历
④迭代器
⑤生成字符串
⑥是否包含
2)案例实操
object TestList {
def main(args: Array[String]): Unit = {
val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7)
//（1）获取集合长度println(list.length)
//（2）获取集合大小,等同于 length println(list.size)
//（3）循环遍历list.foreach(println)
//（4）迭代器
for (elem <- list.itera tor) { println(elem)
}
//（5）生成字符串println(list.mkString(","))
//（6）是否包含println(list.contains(3))
}
}
6.2、衍生集合
1)说明
①获取集合的头
②获取集合的尾（不是头的就是尾）
③集合最后一个数据
④集合初始数据（不包含最后一个）
⑤反转
⑥取前（后）n 个元素
⑦去掉前（后）n 个元素
⑧并集
⑨交集
⑩差集
⑪拉链
⑫滑窗
2)案例实操
object TestList {
def main(args: Array[String]): Unit = {
val list1: List[Int] = List(1, 2, 3, 4, 5, 6, 7)
val list2: List[Int] = List(4, 5, 6, 7, 8, 9, 10)
//（1）获取集合的头println(list1.head)
//（2）获取集合的尾（不是头的就是尾）println(list1.tail)
//（3）集合最后一个数据println(list1.last)
//（4）集合初始数据（不包含最后一个） println(list1.init)
//（5）反转println(list1.reverse)
//（6）取前（后）n 个元素
println(list1.take(3)) println(list1.takeRight(3))
//（7）去掉前（后）n 个元素println(list1.drop(3)) println(list1.dropRight(3))
//（8）并集println(list1.union(list2))
//（9）交集println(list1.intersect(list2))
//（10）差集println(list1.diff(list2))
//（11）拉链 注:如果两个集合的元素个数不相等，那么会将同等数量的数据进行拉链，多余的数据省略不用
println(list1.zip(list2))
//（12）滑窗
list1.sliding(2, 5).foreach(println)
}
}
6.3、集合计算简单函数
1）说明
①求和
②求乘积
③最大值
④最小值
⑤排序
2）案例实操
object TestList {
def main(args: Array[String]): Unit = {
val list: List[Int] = List(1, 5, -3, 4, 2, -7, 6)
//（1）求和println(list.sum)
//（2）求乘积println(list.product)
//（3）最大值println(list.max)
//（4）最小值println(list.min)
//（5）排序
// （5.1）按照元素大小排序
println(list.sortBy(x => x))
// （5.2）按照元素的绝对值大小排序
println(list.sortBy(x => x.abs))
// （5.3）按元素大小升序排序
println(list.sortWith((x, y) => x < y))
// （5.4）按元素大小降序排序
println(list.sortWith((x, y) => x > y))
}
}
①Sorted
对一个集合进行自然排序，通过传递隐式的Ordering
②sortBy
对一个属性或多个属性进行排序，通过它的类型。
③sortWith
基于函数的排序，通过一个 comparator 函数，实现自定义排序的逻辑。