object TestSet {
 def main(args: Array[String]): Unit = {
 //（1）創(chuàng)建可變集合
 val set = mutable.Set(1,2,3,4,5,6)
 //（3）集合添加元素
 set += 8
 //（4）向集合中添加元素，返回一個(gè)新的 Set
 val ints = set.+(9)
 println(ints)
 println("set2=" + set)
 //（5）刪除數(shù)據(jù)
 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）訪問(wèn)元組
 //（2.1）通過(guò)元素的順序進(jìn)行訪問(wèn)，調(diào)用方式：_順序號(hào)
 println(tuple._1)
 println(tuple._2)
 println(tuple._3)
 //（2.2）通過(guò)索引訪問(wèn)數(shù)據(jù)
 println(tuple.productElement(0))
 //（2.3）通過(guò)迭代器訪問(wèn)數(shù)據(jù)
 for (elem <- tuple.productIterator) {
 println(elem)
 }
 //（3）Map 中的鍵值對(duì)其實(shí)就是元組,只不過(guò)元組的元素個(gè)數(shù)為 2，稱之為
對(duì)偶
 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）獲取集合長(zhǎng)度
 println(list.length)
 //（2）獲取集合大小,等同于 length
 println(list.size)
 //（3）循環(huán)遍歷
 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方法，可迭代的類型都可以用，一般在有序的類型里面有，無(wú)序的不考慮頭和尾
 println(list1.head)            //1
 //（2）獲取集合的尾（不是頭的就是尾）
 println(list1.tail)            //List(2, 3, 4, 5, 6, 7)
 //（3）集合最后一個(gè)數(shù)據(jù)
 println(list1.last)            //7
 //（4）集合初始數(shù)據(jù)（不包含最后一個(gè)）
 println(list1.init)            //List(1, 2, 3, 4, 5, 6)
 //（5）反轉(zhuǎn)
 println(list1.reverse)
 //（6）取前（后）n 個(gè)元素
 println(list1.take(3))
 println(list1.takeRight(3))
 //（7）去掉前（后）n 個(gè)元素
 println(list1.drop(3))
 println(list1.dropRight(3))


//兩個(gè)集合的操作 

 //（8）并集
 println(list1.union(list2))
 println(list1 ::: list2)


/如果是set做并集。那么重復(fù)的數(shù)據(jù)會(huì)被去重
    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）拉鏈 注:如果兩個(gè)集合的元素個(gè)數(shù)不相等，那么會(huì)將同等數(shù)量的數(shù)據(jù)進(jìn)行拉鏈，多余的數(shù)據(jù)省略不用
 println(list1.zip(list2))
//    (12) 滑窗
    //滑窗的意思是，第一次取123元素，第二次去234，每次取三個(gè)這樣滑下去，每次取多少可以定義
    println(list.sliding(3)) //滑窗使用sliding方法，里面的參數(shù)是每次滑的元素是幾個(gè)，可以看到是一個(gè)迭代器
    for(i <- list.sliding(3)){ //使用類似于迭代器的方式遍歷出來(lái)
      println(i)
    }
println("================")
    //要是里面有兩個(gè)參數(shù)的話，第二個(gè)參數(shù)是步長(zhǎng)，一個(gè)參數(shù)的時(shí)候默認(rèn)步長(zhǎng)是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) //降序可以先排序然后翻轉(zhuǎn)列表，可以達(dá)到效果
println(list.sorted(Ordered[Int])) //降序

println(list.sortBy(x => x)) //按照元素大小排序
println(list.sortBy(x => x.abs))  //按照元素的絕對(duì)值大小排序

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）過(guò)濾
 println(list.filter(x => x % 2 == 0))
 //（2）轉(zhuǎn)化/映射
 println(list.map(x => x + 1))
 //（3）扁平化
 println(nestedList.flatten)
 //（4）扁平化+映射 注：flatMap 相當(dāng)于先進(jìn)行 map 操作，在進(jìn)行 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)
 // 將數(shù)據(jù)兩兩結(jié)合，實(shí)現(xiàn)運(yùn)算規(guī)則
 val i: Int = list.reduce( (x,y) => x-y )
 println("i = " + i)
 // 從源碼的角度，reduce 底層調(diào)用的其實(shí)就是 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 = {
 // 兩個(gè) Map 的數(shù)據(jù)合并
 val map1 = mutable.Map("a"->1, "b"->2, "c"->3)
 val map2 = mutable.Map("a"->4, "b"->5, "d"->6)
//fold 要求兩個(gè)（）（）里 的變量相同
 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 = {
    //數(shù)據(jù)
    val stringList:List[String]=List(
      "hello",
      "hello world",
      "hello scala",
      "hello spark from scala",
      "hello flink from scala"
    )
    //對(duì)字符串切分,打散所有單詞的列表
//    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))
    //對(duì)分組之后的list去長(zhǎng)度，當(dāng)成value
    val countMap : Map[String,Int]= groupMap.map(kv => (kv._1, kv._2.length))
    //排序，需要轉(zhuǎn)化為list，進(jìn)行排序，取前三
    val sortList:List[(String,Int)]=countMap.toList
      .sortWith( _._2 > _._2)
      .take(3)
    println(sortList) 

  }
}

復(fù)雜案例

package com.qihang.bigdata.spark.core

class Person(){}


object Test {
  def main(args: Array[String]): Unit = {
    //數(shù)據(jù)
    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：打散，變成上一個(gè)案例
    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 基于預(yù)處理直接進(jìn)行處理
    //將字符串打散，并和個(gè)數(shù)包裝成二元組
    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))

    //對(duì)二元組進(jìn)行分組
    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)))

    //疊加每個(gè)單詞預(yù)統(tǒng)計(jì)的個(gè)數(shù)值
    //mapValues 將原有的元素集轉(zhuǎn)換成新的元素集
    val countMap = perCountMap.mapValues(
      tupleList => tupleList.map(_._2).sum
    )
    println(countMap)
    //Map(world -> 2, flink -> 2, spark -> 1, scala -> 6, from -> 3, hello -> 9)

    //轉(zhuǎn)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}