scala 集合通用方法

Posted 2022-08-08 钟钟终

​
​

活动地址：CSDN21天学习挑战赛

元组：

import scala.Boolean
import scala.collection.mutable

object test01 
  def main(args: Array[String]): Unit = 
    val tuple1:(String,Int,Char,Boolean)=("hello",2,'c',true)
    //访问
    println(tuple1._1)
    println(tuple1._2)
    //遍历
    for(elem<-tuple1.productIterator)
      println(elem)

    //嵌套元组
    val mul=(12,0.3,"hello",(23,"scala"),24)
    println(mul._4._1)

  

常用函数(一)

import scala.Boolean
import scala.collection.mutable

object test01 
  def main(args: Array[String]): Unit = 
    //通用操作
    val list=List(1,3,5,7,9)
    val set=Set(23,32,43,34,44)
    //获取长度
    println(list.length)
    println(set.size)
    //循环遍历
    for(elem<- list)
      println(elem)
    set.foreach(println)
    //迭代器
    for (elem<-list.iterator)
      println(elem)
    //生成字符串
    println(list)
    println(set)
    println(list.mkString("|"))
    //是否包含
    list.contains(23) 
  

常用函数(二)

import scala.Boolean
import scala.collection.mutable

object test01 
  def main(args: Array[String]): Unit = 
    val list1=List(1,3,5,7,9)
    val list2=List(3,7,5,7,6,8)

    println(list1.head) //头
    println(list1.tail) //尾
    println(list1.last) //最后一个元素
    println(list1.init) //不包含最后一个元素
    println(list1.reverse)
    println(list1.take(3))
    println(list1.takeRight(3))
    println(list1.drop(3))
    println(list1.dropRight(3))

    val un=list1.union(list2)  //并集
    //如果是Set做并集，会去重、无序
    val it=list1.intersect(list2) //交集
    val diff1=list1.diff(list2) //独属于list1
    val diff2=list2.diff(list1) //读书与list2

    //拉链 对应元素组成一个二元组
    val zip1=list1.zip(list2)
    val zip2=list2.zip(list1)

    //滑窗
    for(elem<-list1.sliding(3,2)) //大小 步长
      println(elem)
  

常用函数(三) 最值、排序

import scala.Boolean
import scala.collection.mutable

object test01 
  def main(args: Array[String]): Unit = 
    val list=List(1,3,4,-44,67,53)
    val list2=List(("a",4),("b",55),("c",43),("d",8))

    println(list.sum)//求和
    println(list.product) //乘积
    println(list.min) //最小值

    println(list.max) //最大值
    println(list2.max)  //默认根据第一个值排序

    println(list2.maxBy((tuple:(String,Int))=>tuple._2))
    println(list2.maxBy(_._2))

    //排序
    val list3=list.sorted sorted默认升序
    println(list3)
    val list4=list.sorted(Ordering[Int].reverse)
    println(list4)

    val list5=list2.sorted
    println(list5)
    val list6=list2.sortBy((tuple:(String,Int))=>tuple._2)
    // list6=sortBy(_._2)
    println(list6)
    val list7=list2.sortBy(_._2)(Ordering[Int].reverse)
    println(list7)

    println(list.sortWith((a:Int,b:Int)=>a<b))
    println(list.sortWith(_>_))
  

fileter、map、reduce、fold高级函数

import scala.Boolean
import scala.collection.mutable

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

    //过滤，遍历一个集合从中获取满足指定条件的元素组成一个新的集合
    val even=list.filter((elem:Int)=>elem %2==0)
    println(list.filter(_%2==1))

    //转化、映射
    println(list.map(elem=>elem*2))
    println(list.map(_*2))
    println(list.map(x=>x*x))

    //扁平化
    val list2=List(List(1,2,3),List(7,8,9),List(4,5,6))
    val list3=list2(0):::list2(1):::list2(2)
    println(list3)
    val list4=list2.flatten
    println(list4)

    //扁平映射  eg:将一组字符串进行分词，并保存成单词的列表
    val s=List("hello world","hello java","hi scala")
    val s1=s.map(_.split(" "))
    val s2=s1.flatten
    println(s2)
    println(s.flatMap(_.split(" ")))

    //分组  按照指定规则
    val group=list.groupBy( _ %2)
    println(group)
    val group2=list.groupBy(x=>if(x%2==0) "even" else "odd")
    println(group2)
    //eg:给定一组词汇，根据首字母进行分组
    val wc=List("china","america","alice","carry")
    println(wc.groupBy(_.charAt(0)))

    //规约 简化 reduce类操作
    println(list.reduce((a,b)=>a+b))
    println(list.reduce(_+_))
    println(list.reduceLeft(_+_))
    println(list.reduceRight(_+_))

    println(list.reduce(_-_)) //-43
    println(list.reduceLeft(_-_)) //-43
    println(list.reduceRight(_-_)) //5

    println(list.fold(45)(_+_)) //传入一个初值
    println(list.fold(45)(_-_))
    println(list.foldRight(2)(_-_))
    
    //折叠

  

eg：应用实例

import scala.Boolean
import scala.collection.mutable

object test01 
  def main(args: Array[String]): Unit = 
    //eg1:map键值对值的合并
    val mp1=Map("a"->1,"b"->4,"c"->6)
    val mp2=mutable.Map("a"->6,"b"->4,"c"->9,"d"->3)
    println(mp1++mp2)
    println(mp2++mp1)
    val mp3=mp1.foldLeft(mp2)(
      (mp,kv)=>
        val key=kv._1
        val value=kv._2
        mp(key)=mp.getOrElse(key,0)+value //值合并
        mp
      
    )
    println(mp3)

    //eg2:合并相同的的单词、计数并取前三 (简易版)
    val s=List("hello world","hello scala",
      "hi world","java scala",
      "flink from scala")
    val s1=s.flatMap(_.split(" "))
    println(s1)
    //分组合并
    val s2=s1.groupBy(x=>x)
    println(s2)
    //个数统计
    val s3=s2.map(kv=>(kv._1,kv._2.size))
    println(s3)
    //只能针对列表，因此先转化为列表，排序
    val s4=s3.toList.sortWith((kv1,kv2)=>kv1._2>kv2._2).take(3)
    println(s4)

    // 复杂版
    val s5=List(("hello world",3),("hello scala",2),
      ("hi world",1),
      ("java scala",2),
      ("flink from scala",3))

    //思路一：直接全部展开
    val s6=s5.map(
      kv=>
        (kv._1+" ")*kv._2
      
    )
    println(s6)
    val s7=s6.flatMap(_.split(" "))
      .groupBy(x=>x)
      .map(kv=>(kv._1,kv._2.size))
      .toList.sortWith(_._2>_._2)
      .take(3)
    println(s7)
    //思路2：
    val s8=s5.flatMap(
      tuple=>
        val st=tuple._1.split(" ").map(x=>(x,tuple._2))
        st
      
    )
    val s9=s8.groupBy(_._1).mapValues(
      list=>list.map(_._2).sum
    ).toList.sortWith(_._2>_._2).take(3)
    println(s9)
  

并行队列

import scala.Boolean
import scala.collection.immutable.Queue
import scala.collection.mutable

object test01 
  def main(args: Array[String]): Unit = 
    //队列
    val q=new mutable.Queue[String]()
    q.enqueue("a","abc","ff")
    println(q)
    q.dequeue()
    println(q)
    //不可变队列
    val q2=Queue("a","b","c")
    q2.enqueue("d")
    println(q2)  //不会变，需要新变量接收

    //并行集合
    val longs = (1 to 100).par.map(
      x => Thread.currentThread.getId
    )
    println(longs)