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(","))
 }
}

Map 集合

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

操作

通用操作

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

 while (iter.hasNext){
      println(iter.next())
    }

 //（5）生成字符串
 println(list.mkString(","))
 //（6）是否包含
 println(list.contains(3))        //如果存在返回true，不存在返回false
 }
}

衍生集合操作

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）获取集合的头
//获取集合的头使用head方法，可迭代的类型都可以用，一般在有序的类型里面有，无序的不考虑头和尾
 println(list1.head)            //1
 //（2）获取集合的尾（不是头的就是尾）
 println(list1.tail)            //List(2, 3, 4, 5, 6, 7)
 //（3）集合最后一个数据
 println(list1.last)            //7
 //（4）集合初始数据（不包含最后一个）
 println(list1.init)            //List(1, 2, 3, 4, 5, 6)
 //（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))
 println(list1 ::: list2)


/如果是set做并集。那么重复的数据会被去重
    val set = Set(6,12,33,45,56)
    val set2 = Set(32,65,45,46,321,6)
    val union2 = set.union(set2)
    println(union2)
    println(set ++ set2)

 //（9）交集
 println(list1.intersect(list2))
 //（10）差集
 println(list1.diff(list2))
 //（11）拉链 注:如果两个集合的元素个数不相等，那么会将同等数量的数据进行拉链，多余的数据省略不用
 println(list1.zip(list2))
//    (12) 滑窗
    //滑窗的意思是，第一次取123元素，第二次去234，每次取三个这样滑下去，每次取多少可以定义
    println(list.sliding(3)) //滑窗使用sliding方法，里面的参数是每次滑的元素是几个，可以看到是一个迭代器
    for(i <- list.sliding(3)){ //使用类似于迭代器的方式遍历出来
      println(i)
    }
println("================")
    //要是里面有两个参数的话，第二个参数是步长，一个参数的时候默认步长是1
    for(i <- list.sliding(3,2)){
      println(i)
    }
 }
}

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

println(list.sorted) //这是升序，从小到大

println(list.sorted.reverse) //降序可以先排序然后翻转列表，可以达到效果
println(list.sorted(Ordered[Int])) //降序

println(list.sortBy(x => x)) //按照元素大小排序
println(list.sortBy(x => x.abs))  //按照元素的绝对值大小排序

println(list.sortWith((x, y) => x < y)) //按元素大小升序排序
println(list.sortWith((x, y) => x > y)) //按元素大小降序排序

object TestList {
 def main(args: Array[String]): Unit = {
 val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
 val nestedList: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))
 val wordList: List[String] = List("hello world", "hello atguigu", "hello scala")
 //（1）过滤
 println(list.filter(x => x % 2 == 0))
 //（2）转化/映射
 println(list.map(x => x + 1))
 //（3）扁平化
 println(nestedList.flatten)
 //（4）扁平化+映射 注：flatMap 相当于先进行 map 操作，在进行 flatten操作
 println(wordList.flatMap(x => x.split(" ")))
 //（5）分组
 println(list.groupBy(x => x % 2))
 }
}

//reduce
object TestReduce {
 def main(args: Array[String]): Unit = {
 val list = List(1,2,3,4)
 // 将数据两两结合，实现运算规则
 val i: Int = list.reduce( (x,y) => x-y )
 println("i = " + i)
 // 从源码的角度，reduce 底层调用的其实就是 reduceLeft
 //val i1 = list.reduceLeft((x,y) => x-y)
 // ((4-3)-2-1) = -2
 val i2 = list.reduceRight((x,y) => x-y)
 println(i2)
 }
}

//Fold
list(1,2,3,4)
//10+1+2+3+4
println(list.fold(10)(_+_))
//10-1-2-3-4
list.foldLeft(10)(_-_)
//1-(2-(3-(4-10)))
list.foldRight(10)(_-_)

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)
//fold 要求两个（）（）里 的变量相同
 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)
 }
}

package com.qihang.bigdata.spark.core

class Person(){}


object Test {
  def main(args: Array[String]): Unit = {
    //数据
    val stringList:List[String]=List(
      "hello",
      "hello world",
      "hello scala",
      "hello spark from scala",
      "hello flink from scala"
    )
    //对字符串切分,打散所有单词的列表
//    val wordList1 = stringList.map(_.split(" "))
//    val wordList2 = wordList1.flatten
    val wordList = stringList.flatMap(_.split(" "))
    println(wordList) //List(hello, hello, world, hello, scala, hello, spark, from, scala, hello, flink, from, scala)
    val groupMap = wordList.groupBy(word => word)
    println(groupMap) //Map(world -> List(world), flink -> List(flink), spark -> List(spark), scala -> List(scala, scala, scala), from -> List(from, from), hello -> List(hello, hello, hello, hello, hello))
    //对分组之后的list去长度，当成value
    val countMap : Map[String,Int]= groupMap.map(kv => (kv._1, kv._2.length))
    //排序，需要转化为list，进行排序，取前三
    val sortList:List[(String,Int)]=countMap.toList
      .sortWith( _._2 > _._2)
      .take(3)
    println(sortList) 

  }
}

复杂案例

package com.qihang.bigdata.spark.core

class Person(){}


object Test {
  def main(args: Array[String]): Unit = {
    //数据
    val stringList:List[(String,Int)]=List(
      ("hello",1),
      ("hello world",2),
      ("hello scala",3),
      ("hello spark from scala",1),
      ("hello flink from scala",2)
    )
    //思路1：打散，变成上一个案例
    val newStringList:List[String]=stringList.map(
      kv=>{
        (kv._1.trim + " ")*kv._2
      }
    )
    val wordCountList:List[(String,Int)]=newStringList
      .flatMap(_.split(" "))
      .groupBy(word=>word)
      .map(kv=>(kv._1,kv._2.length))
      .toList
      .sortBy(_._2)(Ordering[Int].reverse) //降序排序
      .take(3)
    //2 基于预处理直接进行处理
    //将字符串打散，并和个数包装成二元组
    val preCountList:List[(String,Int)] = stringList.flatMap(
      tuple =>{
          val strings:Array[String]=tuple._1.split(" ")
          strings.map( word => (word, tuple._2) )
      }
    )
    println(preCountList)
    //List((hello,1), (hello,2), (world,2), (hello,3), (scala,3), (hello,1), (spark,1), (from,1), (scala,1), (hello,2), (flink,2), (from,2), (scala,2))

    //对二元组进行分组
    val perCountMap:Map[String,List[(String,Int)]] = preCountList.groupBy( _._1 )
    println(perCountMap)
    //Map(world -> List((world,2)), flink -> List((flink,2)), spark -> List((spark,1)), scala -> List((scala,3), (scala,1), (scala,2)), from -> List((from,1), (from,2)), hello -> List((hello,1), (hello,2), (hello,3), (hello,1), (hello,2)))

    //叠加每个单词预统计的个数值
    //mapValues 将原有的元素集转换成新的元素集
    val countMap = perCountMap.mapValues(
      tupleList => tupleList.map(_._2).sum
    )
    println(countMap)
    //Map(world -> 2, flink -> 2, spark -> 1, scala -> 6, from -> 3, hello -> 9)

    //转List 排序取前三
    val countList = countMap.toList //List((world,2), (flink,2), (spark,1), (scala,6), (from,3), (hello,9))
      .sortWith( _._2 > _._2 )
      .take(3)
    println(countList)
  }
}

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