Scala集合

最新推荐文章于 2023-10-08 10:20:25 发布

大数据点滴

最新推荐文章于 2023-10-08 10:20:25 发布

阅读量6.2k

点赞数 1

分类专栏： # Scala 文章标签： Scala 集合

本文链接：https://blog.csdn.net/m0_48283915/article/details/108236065

版权

Scala 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

一、集合简介

1）Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质。

2）对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本，分别位于以下两个包

不可变集合：scala.collection.immutable

可变集合：scala.collection.mutable

3）Scala不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而不会对原对象进行修改。类似于java中的String对象

4）可变集合，就是这个集合可以直接对原对象进行修改，而不会返回新的对象。类似于java中StringBuilder对象

建议：在操作集合的时候，不可变用符号，可变用方法

1.1 不可变集合继承图

1）Set、Map是Java中也有的集合

2）Seq是Java没有的，我们发现List归属到Seq了，因此这里的List就和Java不是同一个概念了

3）我们前面的for循环有一个 1 to 3，就是IndexedSeq下的Range

4）String也是属于IndexedSeq

5）我们发现经典的数据结构比如Queue和Stack被归属到LinearSeq(线性序列)

6）大家注意Scala中的Map体系有一个SortedMap，说明Scala的Map可以支持排序

7）IndexedSeq和LinearSeq的区别：

（1）IndexedSeq是通过索引来查找和定位，因此速度快，比如String就是一个索引集合，通过索引即可定位

（2）LinearSeq是线型的，即有头尾的概念，这种数据结构一般是通过遍历来查找

1.2 可变集合继承图

二、数组

2.1 不可变数组

1）数组

定义：val arr1 = new Array[Int](10) （默认0）

（1）new是关键字

（2）[Int]是指定可以存放的数据类型，如果希望存放任意数据类型，则指定Any

（3）(10)，表示数组的大小，确定后就不可以变化

2）案例实操

object Test03 {
  def main(args: Array[String]): Unit = {
    // 1. 创建数组
    // 1.1 直接new
    val arr1: Array[Int] = new Array[Int](5) //数组默认为0

    //1.2 用伴生对象创建
    //val arr2 = Array.apply(1,2,3,4,5)
    val arr2 = Array(1,2,3,4,5)

    //2.访问数组中元素
    println(arr2(4))  //5
    println(arr2.apply(4))  //5

    //3.数组赋值
    arr2(3) = 10
    println(arr2.mkString(",")) //1,2,3,10,5
    arr1(1) = 23
    println(arr1(1)) //23

    //4.遍历
    //4.1 遍历下标
    for( i <- 0 until arr1.length) print(arr1(i))
    for( i <- arr1.indices ) println(arr1(i))
    //4.2直接遍历数组
    for (elem <- arr1 ) println(elem)
    //4.2迭代器
    val iter = arr2.iterator
    while(iter.hasNext)
      println(iter.next())
    //4.3 调用foreach方法
    arr1.foreach((elem: Int) => println(elem))
    arr2.foreach(println)   //简写

    //5 用不可变数组实现添加数组
    //需要定义一个新的数组来接收返回值
    val newArr1 = arr1 .:+ (27)   //追加在后边
    val newArr2 = arr2  .+: (13)   //添加在最前边
    println(newArr1.mkString(","))
    println(newArr2.mkString(","))
    //添加多个元素
    val newArr3 = newArr1 :+ 35 :+ 13
    val newArr4 = 21 +: 19 +: newArr2 :+ 56
    println(newArr3.mkString(","))
    println(newArr4.mkString(","))
  }
}

2.2 可变数组

1）定义变长数组

val arr01 = ArrayBuffer[Any](3, 2, 5)

（1）[Any]存放任意数据类型

（2）(3, 2, 5)初始化好的三个元素

（3）ArrayBuffer需要引入scala.collection.mutable.ArrayBuffer

2）案例实操

（1）ArrayBuffer是有序的集合

（2）增加元素使用的是append方法()，支持可变参数

object Test04 {
  def main(args: Array[String]): Unit = {
    //1. 创建可变数组
    val arr1: ArrayBuffer[Int] = new ArrayBuffer[Int]()
    val arr2 = ArrayBuffer(1, 2, 3)
    println(arr1) //ArrayBuffer()
    println(arr2) //ArrayBuffer(1, 2, 3)

    //2. 访问数组元素
    println(arr2(2)) //3
    arr2(2) = 15
    arr2.update(1, 27)
    println(arr2) //ArrayBuffer(1, 27, 15)

    // 3. 向数组添加元素
    val newArral1 = arr1 :+ 23
    val newArral2 = 12 +: arr2
    println(arr1) //ArrayBuffer()
    println(arr2) //ArrayBuffer(1, 27, 15)
    println(newArral1) //ArrayBuffer(23)
    println(newArral2) //ArrayBuffer(12, 1, 27, 15)

    println("-------------")
    //调用带英文名称的方法
    arr1.append(13)
    arr2.append(24, 78)
    arr1.prepend(36, 92)
    arr1.insert(1, 22, 18)
    println(arr1) //ArrayBuffer(36, 22, 18, 92, 13)
    println(arr2) //ArrayBuffer(1, 27, 15, 24, 78)

    arr1 += 31
    13 +=: arr1
    println(arr1) //ArrayBuffer(13, 36, 22, 18, 92, 13, 31)

    //4.删除数组元素
    val n = arr1.remove(2)
    println(n) //22
    println(arr1) //ArrayBuffer(13, 36, 18, 92, 13, 31)

    arr1 -= 13
    println(arr1) //ArrayBuffer(36, 18, 92, 13, 31)

    // 还可以用++=进行集合合并
    arr2 ++= ArrayBuffer(23, 45, 67)
    Array(12, 56) ++=: arr2
    println(arr2) //ArrayBuffer(12, 56, 1, 27, 15, 24, 78, 23, 45, 67)

    // 5. 可变数组和不可变数组的转换
    // 5.1 可变转不可变
    val arr: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)
    val newArr: Array[Int] = arr.toArray

    // 5.2 不可变转可变
    val buffer: mutable.Buffer[Int] = newArr.toBuffer
    println(buffer) //ArrayBuffer(1, 2, 3)

    //5.2 不可变转可变(利用空的转变成可变)
    val bArr = ArrayBuffer[Int]()
    bArr ++= newArr
    println(bArr)
  }
}

2.3 不可变数组与可变数组的转换

1）说明

arr1.toBuffer //不可变数组转可变数组

arr2.toArray //可变数组转不可变数组

（1）arr2.toArray返回结果才是一个不可变数组，arr2本身没有变化

（2）arr1.toBuffer返回结果才是一个可变数组，arr1本身没有变化

2）案例实操

    // 5. 可变数组和不可变数组的转换
    // 5.1 可变转不可变
    val arr: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)
    val newArr: Array[Int] = arr.toArray

    // 5.2 不可变转可变
    val buffer: mutable.Buffer[Int] = newArr.toBuffer
    println(buffer) //ArrayBuffer(1, 2, 3)

    //5.2 不可变转可变(利用空的转变成可变)
    val bArr = ArrayBuffer[Int]()
    bArr ++= newArr
    println(bArr)

2.4 多维数组

1）多维数组定义

val arr = Array.ofDim[Double](3,4)

说明：二维数组中有三个一维数组，每个一维数组中有四个元素

2）案例实操

object Test05 {
  def main(args: Array[String]): Unit = {
    // 1. 创建二维数组
    val arr: Array[Array[Int]] = Array.ofDim[Int](2,3)

    // 2. 访问数组元素
    println(arr(0)(1))
    arr(0)(1) = 13
    println(arr(0)(1))

    // 3. 遍历数组
//    for ( i <- 0 until arr.length; j <- 0 until arr(i).length)
      for (i <- arr.indices; j <- arr(i).indices){
        print(arr(i)(j) + "\t")
        if (j == arr(i).length - 1) println()
      }

    arr.foreach(line => line.foreach(println))
 //   arr.foreach(_.foreach(println))
  }
}

三、 Seq集合（List）

3.1 不可变List

1）说明

（1）List默认为不可变集合

（2）创建一个List（数据有顺序，可重复）
（3）遍历List

（4）List增加数据

（5）集合间合并：将一个整体拆成一个一个的个体，称为扁平化
（6）取指定数据
（7）空集合Nil

object Test06 {
  def main(args: Array[String]): Unit = {
    // 1. 创建List
    val list1: List[Int] = List(1, 2, 3, 4)
    println(list1) //List(1, 2, 3, 4)

    // 2. 访问List元素，遍历
    println(list1(3)) //4
    for (elem <- list1) println(elem) // 1  2  3  4
    list1.foreach(println)     // 1  2  3  4

    // 3. 向列表里添加数据
    val list2 = 10 +: list1
    val list3 = list2 :+ 24
    println(list1) //List(1, 2, 3, 4)
    println(list2) //List(10, 1, 2, 3, 4)
    println(list3) //List(10, 1, 2, 3, 4, 24)

    // 4. 特殊的List，以及用它来构建列表
    val list4 = list1.::(52)
    val list5 = Nil.::(12)
    println(list4) //List(52, 1, 2, 3, 4)
    println(list5) //List(12)

    val list6 = 13 :: list5
    val list7 = 15 :: 24 :: 67 :: Nil
    println(list6) //List(13, 12)
    println(list7) //List(15, 24, 67)

    // 5. 扁平化
    val list8: List[Any] = list6 :: list7
    println(list8)    //List(List(13, 12), 15, 24, 67)

    val list9: List[Int] = list6 ::: list7
    println(list9)    //List(13, 12, 15, 24, 67)

    val list10 = list6 ++ list7
    println(list10)   //List(13, 12, 15, 24, 67)
  }
}

3.2 可变ListBuffer

1）说明

（1）创建一个可变集合ListBuffer

（2）向集合中添加数据

（3）打印集合数据

2）案例实操

object Test07 {
  def main(args: Array[String]): Unit = {
    // 1. 创建可变List
    val list1: ListBuffer[Int] = new ListBuffer[Int]()
    val list2 = ListBuffer(1,2,3)

    // 2. 添加数据
    list1.append(12)    //ListBuffer(12)
    list2.append(23,57)  //ListBuffer(1, 2, 3, 23, 57)
    list1.append(13,22)  //ListBuffer(12, 13, 22)

    list1 += 65 += 39   //ListBuffer(12, 13, 22, 65, 39)
    11 +=: list2    //ListBuffer(11, 1, 2, 3, 23, 57)
    println(list1)
    println(list2)

    // 3. 合并List
    val list3 = list1 ++ list2
    list1 ++= list2
    list1 ++=: list2
    println(list1)  //ListBuffer(12, 13, 22, 65, 39, 11, 1, 2, 3, 23, 57)
    println(list2) //ListBuffer(12, 13, 22, 65, 39, 11, 1, 2, 3, 23, 57, 11, 1, 2, 3, 23, 57)
    println(list3)  //ListBuffer(12, 13, 22, 65, 39, 11, 1, 2, 3, 23, 57)

    // 4. 修改元素
    list3(2) = 33
    list3.update(4,55)
    println(list3)  //ListBuffer(12, 13, 33, 65, 55, 11, 1, 2, 3, 23, 57)

    // 5. 删除元素
    list3.remove(6,2)  //ListBuffer(12, 13, 33, 65, 55, 11, 3, 23, 57)
    val list4 = list3 - 33 //ListBuffer(12, 13, 65, 55, 11, 3, 23, 57)
    list3 -= 23  //ListBuffer(12, 13, 33, 65, 55, 11, 3, 57)
    println(list4)
    println(list3)
  }
}

四、Set集合

默认情况下，Scala使用的是不可变集合，如果你想使用可变集合，需要引用 scala.collection.mutable.Set 包

4.1 可变Set与不可变Set

1）说明

（1）Set默认是不可变集合，数据无序，创建可变集合mutable.Set（向集合中添加元素，返回一个新的Set）

（2）数据不可重复

（3）遍历集合

2）案例实操

object Test09 {
  def main(args: Array[String]): Unit = {
    // 1. 不可变Set
    // 1.1 创建
    val set1: Set[Int] = Set(1, 4, 2, 5, 5, 27, 67)
    println(set1)  //Set(5, 1, 2, 27, 67, 4)

    // 1.2 添加元素
    val set2 = set1 + 21
    println(set1)   //Set(5, 1, 2, 27, 67, 4)
    println(set2)   //Set(5, 1, 21, 2, 27, 67, 4)

    //1.3 合并set
    val set3 = Set(1,27,43,79)
    val set4 = set2 ++ set3
    println(set4)   //Set(5, 1, 21, 2, 27, 67, 43, 4, 79)

    // 1.4 删除元素
    val set5 = set4 - 21
    println(set5)   //Set(5, 1, 2, 27, 67, 43, 4, 79)

    // 2. 可变Set
    // 2.1 创建
    val set6: mutable.Set[Int] = mutable.Set(1,2,3,4)

    // 2.2 添加元素
    set6.add(35)
    println(set6.add(1))  //false

    // 2.3 删除元素
    println(set6.remove(2))
    println(set6)   //Set(1, 35, 3, 4)

    set6 -=2
    val set7 = set6 - 2

    // 2.4 合并集合
    val set8 = set6 ++ set1
    println(set6)
    println(set8)

    set6 ++= set1
    println(set6)
  }
}

五、 Map集合

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

5.1 可变Map与不可变Map

1）说明

2）案例实操

object Test08 {
  def main(args: Array[String]): Unit = {
    // 1. 不可变Map
    // 1.1 创建
    val map1: Map[String, Int] = Map("a" -> 1, "b" -> 2, "c" -> 3, "d" -> 4)
    println(map1)

    // 1.2 遍历map元素
    map1.foreach(println) //(a,1)(b,2)(c,3)(d,4)
    map1.keys.foreach(println) //abcd
    map1.values.foreach(println) //1234

    println("*************")
    // 1.3 单独访问元素
    println(map1.get("c").getOrElse(0)) //3
    println(map1.getOrElse("c", 0)) // 3

    // 2. 可变Map
    // 2.1 创建
    val map2: mutable.Map[String, Int] = mutable.Map("a" -> 1, "b" -> 2, "c" -> 3, "d" -> 4)
    // 2.2 添加元素
    map2.put("d", 67)
    map2.put("e", 13)

    map2 += ("f" -> 25)
    println(map2)

    // 2.3 修改和删除
    map2.update("d", 31)
    println(map2("d"))
    map2("b") = 69

    map2.remove("c")
    map2 -= "c"
    map2 .-= ("c","d")
    println(map2)

    // 2.4 合并两个Map
    val map3 = map1 ++ map2
    map2 ++= map1
    println(map1)
    println(map2)
    println(map3)
  }
}

六、元组

1）说明

元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。说的简单点，就是将多个无关的数据封装为一个整体，称为元组。

注意：元组中最大只能有22个元素。

2）案例实操

（1）声明元组的方式：(元素1，元素2，元素3)

（2）访问元组

（3）Map中的键值对其实就是元组,只不过元组的元素个数为2，称之为对偶

object Test08_Tuple {
  def main(args: Array[String]): Unit = {
    // 1. 创建一个元组
    val tuple1: (Int, String, Double, Char) = (100, "hello", 12.3, 'c')
    println(tuple1)

    // 2. 访问元组数据
    //（2.1）通过元素的顺序进行访问，调用方式：_顺序号
    println(tuple1._3)
//    tuple1._2 = ""      // error, 不能重新赋值
                        
    //（2.2）通过索引访问数据
    println(tuple1.productElement(0))

    // 3. 遍历数据
//    for( elem <- tuple1 ) println(elem)    // 元组中没有foreach方法
//    tuple1.foreach()
    //通过迭代器访问数据
    for( elem <- tuple1.productIterator) println(elem)

    // 4. 元组和map的键值对 //Map中的键值对其实就是元组,只不过元组的元素个数为2，称之为对偶       
//    val map1 = Map("a"->1, "b"->2, "c"->3)
//    println(map1)
    val map1 = Map(("a",1), ("b",2), ("c",3))
    map.foreach(tuple=>{println(tuple._1 + "=" + tuple._2)})

    // 5. 嵌套元组
    val tuple2: (Int, Double, String, List[Int], (Char, Int)) = (12, 0.9, "hi", List(1, 2), ('c', 15))
    println(tuple2._5._2)

    val tuple3 = (1,1,2,2)
    val tuple4 = (("a", 1), ("a", 2))
    println(tuple4)

  }
}

七、集合常用函数

7.1 基本属性和常用操作

1）说明

（1）获取集合长度

（2）获取集合大小

（3）循环遍历

（4）迭代器

（5）生成字符串

（6）是否包含

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))
  }
}

7.2 衍生集合

1）说明

（1）获取集合的头

（2）获取集合的尾（不是头的就是尾）

（3）集合最后一个数据

（4）集合初始数据（不包含最后一个）

（5）反转

（6）取前（后）n个元素

（7）去掉前（后）n个元素

（8）并集

（9）交集

（10）差集

（11）拉链

（12）滑窗

2）案例实操

object Test05 {
  def main(args: Array[String]): Unit = {
    val list1 = List(1,2,3,4,5,6,6,7)
    val list2 = List(5,4,6,7,8,9,10,11,12)

    //    （1）获取集合的头
    println(list1.head)   //1
    //    （2）获取集合的尾（不是头的就是尾）
    println(list1.tail)   //List(2, 3, 4, 5, 6, 6, 7)
    //    （3）集合最后一个数据
    println(list1.last)   //7
    //    （4）集合初始数据（不包含最后一个）
    println(list2.init)  //List(5, 4, 6, 7, 8, 9, 10, 11)
    //    （5）反转
    println(list2.reverse)  //List(12, 11, 10, 9, 8, 7, 6, 4, 5)
    //    （6）取前（后）n个元素
    println(list1.take(3))   //List(1, 2, 3)
    println(list2.takeRight(3))  //List(10, 11, 12)
    //    （7）去掉前（后）n个元素
    println(list1.drop(3))   //List(4, 5, 6, 6, 7)
    //    （8）并集
    val union = list1.union(list2)
    println(union) //List(1, 2, 3, 4, 5, 6, 6, 7, 5, 4, 6, 7, 8, 9, 10, 11, 12)
    println(list2.union(list1)) //List(5, 4, 6, 7, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6, 6, 7)

    //set的并集去重的，set本身数据无序，不可重复
    val set1 = Set(1,2,3,4,5,6,7)
    val set2 = Set(4,5,6,7,8,9,10,11,12)
    val unionSet = set1.union(set2)
    println(unionSet)  //Set(5, 10, 1, 6, 9, 2, 12, 7, 3, 11, 8, 4)
    println(set2.union(set1))   //Set(5, 10, 1, 6, 9, 2, 12, 7, 3, 11, 8, 4)

    //    （9）交集
    val intersectionSet: Set[Int] = set1.intersect(set2)
    println(intersectionSet)   //Set(5, 6, 7, 4)

    println(list1.intersect(list2))  //List(4, 5, 6, 7)
    println(list2.intersect(list1))   //List(5, 4, 6, 7)

    //    （10）差集
    println(list1.diff(list2))  //List(1, 2, 3, 6)
    println(list2.diff(list1))  //List(8, 9, 10, 11, 12)

    //    （11）拉链
    //注:如果两个集合的元素个数不相等，那么会将同等数量的数据进行拉链，多余的数据省略不用
    println(list1.zip(list2))

    //    （12）滑窗
    // 12.1 单参数，步长为1
    for(elem <- list2.sliding(5)) println(elem)  //List(5, 4, 6, 7, 8) List(4, 6, 7, 8, 9) List(6, 7, 8, 9, 10) List(7, 8, 9, 10, 11) List(8, 9, 10, 11, 12)
    // 12.2 两参数，size和步长
    for(elem <- list2.sliding(5,3)) println(elem)  //List(5, 4, 6, 7, 8) List(7, 8, 9, 10, 11) List(10, 11, 12)
    // 12.3 整体滑动
    for( elem <- list2.sliding(3,3)) println(elem)  //List(5, 4, 6) List(7, 8, 9) List(10, 11, 12)
    }
}

7.3 集合计算初级函数

1）说明

（1）求和

（2）求乘积

（3）最大值

（4）最小值

（5）排序

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))
  }
}

（1）sorted

对一个集合进行自然排序，通过传递隐式的Ordering

（2）sortBy

对一个属性或多个属性进行排序，通过它的类型。

（3）sortWith

基于函数的排序，通过一个comparator函数，实现自定义排序的逻辑。

7.4 集合计算高级函数

1）说明

（1）过滤

遍历一个集合并从中获取满足指定条件的元素组成一个新的集合

（2）转化/映射（map）

       将集合中的每一个元素映射到某一个函数

（3）扁平化

（4）扁平化+映射注：flatMap相当于先进行map操作，在进行flatten操作

        集合中的每个元素的子元素映射到某个函数并返回新集合

（5）分组(group)

按照指定的规则对集合的元素进行分组

（6）简化（归约）

（7）折叠

2）实操

object Test06 {
  def main(args: Array[String]): Unit = {
    val list = List(1,2,3,4,5,6,7,8,9)

    // 1. 过滤
    // 筛选所有的偶数
    val newList: List[Int] = for ( i <- list if i % 2 ==0) yield i
    println(newList)  //List(2, 4, 6, 8)

    val evenList = list.filter(_ % 2 == 0)
    println(evenList) //List(2, 4, 6, 8)

    //2.转化/映射==>map
    println(list.map(_ * 2 + "data"))  //List(2data, 4data, 6data, 8data, 10data, 12data, 14data, 16data, 18data)
    println(list.map(x => x + 1))  //List(2, 3, 4, 5, 6, 7, 8, 9, 10)

    // 3. 扁平化
    val nestedList: List[List[Int]] = List(List(1,2,4),List(3,7,9),List(23,46,67))
    val flatList: List[Int] = nestedList.flatten
    println(flatList)  //List(1, 2, 4, 3, 7, 9, 23, 46, 67)

    //4. 扁平映射 ==> 注：flatMap相当于先进行map操作，在进行flatten操作
    val stringList: List[String] = List("hello scala", "hello world", "hello atguigu")
    println(stringList.map(str => str.split(" ")).flatten)   //List(hello, scala, hello, world, hello, atguigu)
    println(stringList.flatMap(_.split(" ")))  //List(hello, scala, hello, world, hello, atguigu)

    // 5. 分组
    // 按照奇偶性分组

    val groupedMap: Map[String,List[Int]] = list.groupBy(data => if(data % 2 == 0) "偶数" else "奇数")
    println(groupedMap)

    // 按照字符串首字母分组
    val strings: List[String] = List("china","canada","usa","japan","uk")
    println(strings.groupBy(_.charAt(0)))
  }
}

3）Reduce方法

Reduce简化（归约）：通过指定的逻辑将集合中的数据进行聚合，从而减少数据，最终获取结果。

案例实操

object Test07 {
  def main(args: Array[String]): Unit = {
    val list = List(1,2,3,4)
    // 1. reduce
    val res1 = list.reduce((a:Int,b:Int) => a + b)
    val res2 = list.reduce(_ + _)
    val res3 = list.reduceLeft(_+_)
    val res4 = list.reduceRight(_+_)

    println(res1)   //10
    println(res2)   //10
    println(res3)   //10
    println(res4)   //10

     从源码的角度，reduce底层调用的其实就是reduceLeft
    // 关于左右规约，减法规约
    println(list.reduceLeft(_ - _))  //-8
    println(list.reduceRight(_ - _)) //-2

    val list2 = List(3,4,5,8,10)
    println(list2.reduceLeft(_ - _))  // -24  3-4-5-8-10
    println(list2.reduceRight(_ - _))  // 6  3-(4-(5-(8-10)))

    //2.fold
    val res5 = list.fold(10)(_ - _) // 0    10-1-2-3-4
    println(res5)

    println(list2.foldRight(11)(_ - _))   // -5  3-(4-(5-(8-(10-11)))
  }
}

4）Fold方法

Fold折叠：简化的一种特殊情况。

（1）案例实操：fold基本使用

object TestFold {
    def main(args: Array[String]): Unit = {
        val list = List(1,2,3,4)
        // fold方法使用了函数柯里化，存在两个参数列表
        // 第一个参数列表为 ： 零值（初始值）
        // 第二个参数列表为： 简化规则

        // fold底层其实为foldLeft
        val i = list.foldLeft(1)((x,y)=>x-y)

        val i1 = list.foldRight(10)((x,y)=>x-y)

        println(i)
        println(i1)
    }
}

（2）案例实操：两个集合合并

object TestFold {
    def main(args: Array[String]): Unit = {

        // 两个Map的数据合并
        val map1 = mutable.Map("a"->1, "b"->2, "c"->3)
        val map2 = mutable.Map("a"->4, "b"->5, "d"->6)

        val map3: mutable.Map[String, Int] = map2.foldLeft(map1) {
            (map, kv) => {
                val k = kv._1
                val v = kv._2

                map(k) = map.getOrElse(k, 0) + v

                map
            }
        }
        println(map3)
    }
}

7.5 普通WordCount案例

1）需求

单词计数：将集合中出现的相同的单词，进行计数，取计数排名前三的结果

2）需求分析

3）案例实操

object TestWordCount {
    def main(args: Array[String]): Unit = {

        // 单词计数：将集合中出现的相同的单词，进行计数，取计数排名前三的结果
        val stringList = List("Hello Scala Hbase kafka", "Hello Scala Hbase", "Hello Scala", "Hello")

        // 1) 将每一个字符串转换成一个一个单词
        val wordList: List[String] = stringList.flatMap(str=>str.split(" "))
        //println(wordList)

        // 2) 将相同的单词放置在一起
        val wordToWordsMap: Map[String, List[String]] = wordList.groupBy(word=>word)
        //println(wordToWordsMap)

        // 3) 对相同的单词进行计数
        // (word, list) => (word, count)
        val wordToCountMap: Map[String, Int] = wordToWordsMap.map(tuple=>(tuple._1, tuple._2.size))

        // 4) 对计数完成后的结果进行排序（降序）
        val sortList: List[(String, Int)] = wordToCountMap.toList.sortWith {
            (left, right) => {
                left._2 > right._2
            }
        }

        // 5) 对排序后的结果取前3名
        val resultList: List[(String, Int)] = sortList.take(3)

        println(resultList)
    }
}



方式二
object Test13_WordCount {
  def main(args: Array[String]): Unit = {
    // 1. 简单版本
    val stringList = List(
      "hello",
      "hello world",
      "hello scala",
      "hello spark in scala",
      "hello flink in scala"
    )

    // 1.1 按空格切分字符串，得到打散的word
    val wordList0 = stringList.map( str => str.split(" ") )
//    println(wordList0.flatten)

    val wordList = stringList.flatMap( _.split(" ") )
    println(wordList)

    // 1.2 按照单词自身作为key分组
    val groupMap: Map[String, List[String]] = wordList.groupBy( word => word )
    println(groupMap)

    // 1.3 对分组的word列表进行length统计，得到（word，count）
    val countMap: Map[String, Int] = groupMap.map( kv => (kv._1, kv._2.length) )
    println(countMap)

    // 1.4 排序取top3
    val sortList: List[(String, Int)] = countMap
      .toList    // 转换成list
//        .sortWith( (data1, data2) => data1._2 > data2._2 )
      .sortWith( _._2 > _._2 )    // 按照count值从大到小排序
      .take(3)    // 选取前3

    println(sortList)

7.6 复杂WordCount案例

1）方式一

object TestWordCount {

    def main(args: Array[String]): Unit = {

        // 第一种方式（不通用）
        val tupleList = List(("Hello Scala Spark World ", 4), ("Hello Scala Spark", 3), ("Hello Scala", 2), ("Hello", 1))

        val stringList: List[String] = tupleList.map(t=>(t._1 + " ") * t._2)

        //val words: List[String] = stringList.flatMap(s=>s.split(" "))
        val words: List[String] = stringList.flatMap(_.split(" "))

        //在map中，如果传进来什么就返回什么，不要用_省略
        val groupMap: Map[String, List[String]] = words.groupBy(word=>word)
        //val groupMap: Map[String, List[String]] = words.groupBy(_)

        // (word, list) => (word, count)
        val wordToCount: Map[String, Int] = groupMap.map(t=>(t._1, t._2.size))

        val wordCountList: List[(String, Int)] = wordToCount.toList.sortWith {
            (left, right) => {
                left._2 > right._2
            }
        }.take(3)

        //tupleList.map(t=>(t._1 + " ") * t._2).flatMap(_.split(" ")).groupBy(word=>word).map(t=>(t._1, t._2.size))
        println(wordCountList)
    }
}

2）方式二

object TestWordCount {
    def main(args: Array[String]): Unit = {
        val tuples = List(("Hello Scala Spark World", 4), ("Hello Scala Spark", 3), ("Hello Scala", 2), ("Hello", 1))

        // (Hello,4),(Scala,4),(Spark,4),(World,4)
        // (Hello,3),(Scala,3),(Spark,3)
        // (Hello,2),(Scala,2)
        // (Hello,1)
        val wordToCountList: List[(String, Int)] = tuples.flatMap {
            t => {
                val strings: Array[String] = t._1.split(" ")
                strings.map(word => (word, t._2))
            }
        }

        // Hello, List((Hello,4), (Hello,3), (Hello,2), (Hello,1))
        // Scala, List((Scala,4), (Scala,3), (Scala,2)
        // Spark, List((Spark,4), (Spark,3)
        // Word, List((Word,4))
        val wordToTupleMap: Map[String, List[(String, Int)]] = wordToCountList.groupBy(t=>t._1)

        val stringToInts: Map[String, List[Int]] = wordToTupleMap.mapValues {
            datas => datas.map(t => t._2)
        }
        stringToInts

        /*
        val wordToCountMap: Map[String, List[Int]] = wordToTupleMap.map {
            t => {
                (t._1, t._2.map(t1 => t1._2))
            }
        }

        val wordToTotalCountMap: Map[String, Int] = wordToCountMap.map(t=>(t._1, t._2.sum))
        println(wordToTotalCountMap)
        */
    }
}

2）方式三

object Test10 {
  def main(args: Array[String]): Unit = {
    val tupleList: List[(String, Int)] = List(
      ("hello world", 1),
      ("hello scala", 2),
      ("hello spark in scala", 3),
      ("hello flink in scala", 4)
    )

    val wordCountMap1 = tupleList.flatMap(kv =>{
      val strList = kv._1.split(" ")
      strList.map(word => (word,kv._2))
    })                                    //List((hello,1), (world,1), (hello,2), (scala,2), (hello,3), (spark,3), (in,3), (scala,3), (hello,4), (flink,4), (in,4), (scala,4))
        .groupBy(_ ._1 )                 //Map(in -> List((in,3), (in,4)), world -> List((world,1)), flink -> List((flink,4)), spark -> List((spark,3)), scala -> List((scala,2), (scala,3), (scala,4)), hello -> List((hello,1), (hello,2), (hello,3), (hello,4)))
        .toList                         // List((in,List((in,3), (in,4))), (world,List((world,1))), (flink,List((flink,4))), (spark,List((spark,3))), (scala,List((scala,2), (scala,3), (scala,4))), (hello,List((hello,1), (hello,2), (hello,3), (hello,4))))
        .map(kv => {
          (kv._1,kv._2.map(_._2))
        })                                //List((in,List(3, 4)), (world,List(1)), (flink,List(4)), (spark,List(3)), (scala,List(2, 3, 4)), (hello,List(1, 2, 3, 4)))
        .map(kv => (kv._1,kv._2.sum))    //List((in,7), (world,1), (flink,4), (spark,3), (scala,9), (hello,10))
        .sortBy(_._2).reverse            //List((hello,10), (scala,9), (in,7), (flink,4), (spark,3), (world,1))
        .take(3)                        //List((hello,10), (scala,9), (in,7))
    println(wordCountMap1)

  }
}

八、队列

1）说明

Scala也提供了队列（Queue）的数据结构，队列的特点就是先进先出。进队和出队的方法分别为enqueue和dequeue。

2）案例实操

object TestQueue {
    def main(args: Array[String]): Unit = {
        val que = new mutable.Queue[String]()
        que.enqueue("a", "b", "c")

        println(que.dequeue())
        println(que.dequeue())
        println(que.dequeue())
    }
}

九、并行集合

1）说明

Scala为了充分使用多核CPU，提供了并行集合（有别于前面的串行集合），用于多核环境的并行计算。

2）案例实操

object TestPar {
    def main(args: Array[String]): Unit = {

        val result1 = (0 to 100).map{case _ => Thread.currentThread.getName}
        val result2 = (0 to 100).par.map{case _ => Thread.currentThread.getName}

        println(result1)
        println(result2)
    }
}

大数据点滴

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Scala集合

一、集合的简介1）Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质。2）对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本，分别位于以下两个包不可变集合：scala.collection.immutable可变集合：scala.collection.mutable3）Scala不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而不会对原对象进行修改。类似于java中的String对象4）可变集合，就是这个集
复制链接

扫一扫