Scala-集合常用函数的使用

open_test01

已于 2023-03-01 16:03:13 修改

阅读量151

点赞数

分类专栏： Scala 文章标签： java html c++

于 2023-03-01 11:08:25 首次发布

本文链接：https://blog.csdn.net/dafsq/article/details/129273837

版权

Scala 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

集合的基本属性和操作

//定义集合
    val list = List(1,2,3,4,5,6,7,8,9,10)
    val set = Set(9,8,7,4,5,6)
    //获取集合长度
    println(list.length)
    //获取集合大小
    println(set.size)
    //遍历
    for(i <- list){
      println(i)
    }
    list.foreach(println)
    //迭代
    for( i <- list.iterator) println(i)
    //生成字符串
    println(list.mkString(" "))
    //是否包含元素
    println(list.contains(1))

一个集合的基本操作

//定义集合
    val list1 = List(1,2,3,4,5,6,7,8,9,10)
    //获取集合的头元素
    println(list1.head)
    //获取去掉头元素后的集合
    println(list1.tail)
    //获取集合最后一个数据
    println(list1.last)
    //获取去掉最后一个元素后的集合
    println(list1.init)
    //反转集合
    println(list1.reverse)
    //取前n个元素
    println(list1.take(3)) //.take(要取的元素个数)
    //去掉前（后）n个元素
    println(list1.drop(2)) //去掉前2个元素
    println(list1.takeRight(2)) //去掉末尾2个元素

两个集合操作

//定义集合
    val list1 = List(1,2,3,4,5,6,7,8,9,10)
    val list2 = List(10,486,16,1)
    //并集
    val list3 = list1.union(list2) //使用union方法
    println(list1 ::: list2) //使用连接符
    println(list3)
        //如果set集合做并集，则会去重
    val set1 = Set(9,8,7,4,5,6)
    val set2 = Set(26,5,8,9,5,4,6)
    val set3 = set1.union(set2)
    println(set3)
    //交集(公共元素)
    val inter = list1.intersect(list2)
    println(inter)
    //差集（集合独有的元素）
    val diff1 = list1.diff(list2) //属于list1但不属于list2的元素
    val diff2 = list2.diff(list1) //属于list2但不属于list1的元素
    println(diff1)
    println(diff2)
    //拉链 （穿插配对成二元组）
    println(list1.zip(list2))
    println(list2.zip(list1))
    //滑窗
    for(i <- list1.sliding(3)){ //大小为3的滑窗
      println(i)
    }

集合简单的计算函数

//定义集合
    val list = List(1,2,3,4,5,6,7,8,9,10)
    //求和
      //for循环实现
    var sum = 0
    for (i <- list){
      sum += i
    }
    println(sum)
      //函数实现
    println(list.sum)

    //求乘积
    println(list.product)

    //最大值
    println(list.max)
    val list2 = List(("a",1),("b",2),("c",3),("d",4))
    println(list2.max)
    println(list2.maxBy((t : (String,Int)) => t._2))

    //最小值
    println(list.min)
    //排序
      //使用sorted方法
    val sorlist = list.sorted
    println(sorlist)
      //重大到小逆序排列
    println(list.sorted.reverse)
        //传入隐式参数
    println(list.sorted(Ordering[Int]).reverse)
      //sortBy
    println(list2.sortBy((t : (String,Int)) => t._2)) //简写println(list2.sortBy((_._2)) 按照二元组第二位元素进行排序
      //sortBy隐式参数
    println(list2.sortBy(_._2)(Ordering[Int].reverse))
      //sortWith 自定义排序
    println(list.sortWith((a:Int,b:Int) =>{a<b})) //重小到大
    //简写： println(list.sortWith(_<_))

sorted 对一个集合进行自然排序，通过传递隐式的 Ordering
sortBy 对一个属性或多个属性进行排序，通过它的类型。
sortWith 基于函数的排序，通过一个 comparator 函数，实现自定义排序的逻辑。

集合高级计算函数

Map类操作

//定义集合
    val list = List(1,2,3,4,5,6,7,8,9,10)
    //过滤 遍历一个集合并从中获取满足指定条件的元素组成一个新的集合
      //需求：选取偶数
    val evenlist = list.filter((i :Int) => {i % 2 == 0})
    println(evenlist)

    //转化/映射（map） 将集合中的每一个元素映射到某一个函数
      //需求：把集合每个数乘二
    println(list.map(i => i * 2))
      //需求：每个数的平方
    println(list.map(x => x * x))

    //扁平化
    val neslist : List[List[Int]] = List(List(1,2,3),List(4,5,6),List(7,8,9))
      //拼接法散合并
    val flatlist1 = neslist(0) ::: neslist(1) ::: neslist(2)
    println(flatlist1)
      //使用flatten函数实现
    val flatlist2 = neslist.flatten
    println(flatlist2)

    //扁平化+映射 集合中的每个元素的子元素映射到某个函数并返回新集合
      //需求： 将一组字符串进行分词 并保存成单词的列表
    val strings : List[String] = List("hello scala","hello java","hello python")
    val splist : List[Array[String]] = strings.map(_.split(" "))//分词
    val flatlist3 = splist.flatten //打散
    println(flatlist3)
      //使用flatMap函数完成上述操作
    val flatlist4 = strings.flatMap(_.split(" "))

    //分组(group) 按照指定的规则对集合的元素进行分组
      //需求：分成奇数偶数两组
    val gp : Map[String,List[Int]] = list.groupBy(i =>{
        if (i % 2 == 0) "偶数"
        else "奇数"
      })
      //  简写  val gp = list.groupBy(_ % 2)
    println(gp)

Reduce类操作

//定义集合
    val list = List(1,2,3,4,5,6)
    //简化（归约）reduce
    println(list.reduce((a: Int, b: Int) => a + b)) //简写reduce(_+_)
    println(list.reduceLeft((a: Int, b: Int) => a + b))//从左往右操作
    println(list.reduceRight((a: Int, b: Int) => a + b))//从右往左操作

    val list2 = List(3,4,5,6,7)
    println(list2.reduceRight((a: Int, b: Int) => a + b)) //最终结果位 3-(4-(5-(6-7)))

    //折叠 fold
    println(list.fold(10)(_ + _)) //10+(1+2+3+4+5+6)
    println(list.foldLeft(10)(_ - _)) //10-1-2-3-4-5-6
    println(list2.foldRight(10)(_ - _)) //3-(4-(5-(6-(7-11))))

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

fold 方法使用了函数柯里化，存在两个参数列表

第一个参数列表为：零值（初始值）
第二个参数列表为：简化规则

合并Map

 //定义集合
    val map1 = Map("a" -> 1,"b" -> 2,"c" -> 3)
    val map2 = mutable.Map("a" -> 5,"b" -> 6,"c" -> 7)

    val map3 = map1.foldLeft(map2)((zmap,kv)=>{
      val key = kv._1
      val value = kv._2
      zmap(key) = zmap.getOrElse(key,0) + value
      zmap
    })
    println(map3)

队列

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

//创建可变队列
    val qu = new mutable.Queue[String]()
    //入队
    qu.enqueue("元素1","元素2","元素3")
    println(qu)

    //出队
    println(qu.dequeue())
    println(qu)

    println(qu.dequeue())
    println(qu)

    println("---------------------------")

    //创建不可变队列
    val qu2 : Queue[String] = Queue("A","B","C")
    val newQue2 = qu2.dequeue
    println(newQue2)

并行集合

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

//串行
    val strings1 : immutable.IndexedSeq[String] = (1 to 10).map { x =>
      Thread.currentThread().getName
    }
    println(strings1)

    //并行
    val strings2: ParSeq[String] = (1 to 10).par.map { x =>
      Thread.currentThread().getName
    }
    println(strings2)