scala 集合通用方法

​ ​

活动地址：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{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)
  }
}