第一章.集合

1.集合基本属性

  1. package com.atguigu.chapter07
  2. //集合基本属性
  3. object $12_CollectionFields {
  4.   def main(args: Array[String]): Unit = {
  5.     val list  = List(1,3,2,8,10,12)
  6.     //是否包含某个元素
  7.     println(list.contains(100))
  8.     //获取集合长度
  9.     println(list.length)
  10.     println(list.size)
  11.     //将集合所有元素拼接成字符串
  12.     println(list.mkString("#"))
  13.     //判断集合是否为空
  14.     println(list.isEmpty)
  15.     //集合转迭代器
  16.     val it = list.toIterator
  17.     for (elem <- it) {
  18.       println(s"elem=${elem}")
  19.     }
  20.     println(("-----------------"))
  21.     for (elem <- it) {
  22.       println(s"elem1=${elem}")
  23.     }
  24.     println(("-------------"))
  25.     val it2 = list.toIterable
  26.     for (elem <- it2) {
  27.       println(s"elem=${elem}")
  28.     }
  29.     println("---------------")
  30.     for (elem <- it2) {
  31.       println(s"elem1=${elem}")
  32.     }
  33.   }
  36. }

2.衍生集合

  1. package com.atguigu.chapter07
  2. //衍生集合
  3. object $13_Collection {
  4.   def main(args: Array[String]): Unit = {
  5.     val list = List(1,2,3,1,4,5,6,7,8,9)
  6.     //去重
  7.     val list2 = list.distinct
  8.     println(list2)
  9.     //获取除开前N个元素的其他所有元素
  10.     println(list.drop(3))
  11.     //获取第一个元素
  12.     println(list.head)
  13.     //获取最后一个元素
  14.     println(list.last)
  15.     //获取除开最后一个元素的其他所有元素
  16.     println(list.init)
  17.     //获取除开第一个元素的其他所有元素
  18.     println(list.tail)
  19.     //反转
  20.     println(list.reverse)
  21.     //获取指定角标范围的所有元素
  22.     println(list.slice(2, 5))
  23.     //滑窗
  24.     //sliding(size[,step=1])
  25.     //size: 窗口长度
  26.     //step: 滑动长度
  27.     println(list.sliding(2).toList)
  28.     //获取前n个元素
  29.     println(list.take(3))
  30.     //获取后n个元素
  31.     println(list.takeRight(3))
  32.     //交集:两个集合共同的元素
  33.     val list3 = List(1,2,3,4,5)
  34.     val list4 = List(4,5,6,7,8)
  35.     val list5 = list3.intersect(list4)
  36.     println(list5)
  37.     //差集: A差B的结果就是A中除开交集的所有元素
  38.     val list6 = list3.diff(list4)
  39.     println(list6)
  40.     //并集: 两个集合的所有元素
  41.     val list7 = list3.union(list4)
  42.     println(list7)
  43.     //拉链
  44.     val list8 = List("zhangsan","wangwu","lilei","hanmeimei")
  45.     val list9 = List(20,30,40)
  46.     val list10 = list8.zip(list9)
  47.     println(list10)
  48.     //反拉链
  49.     println(list10.unzip)
  50.     //将元素与角标拉链
  51.     println(list8.zipWithIndex)
  53.   }
  55. }

3.集合初级计算函数

  1. package com.atguigu.chapter07
  2. //集合初级计算函数
  3. object $14_CollectionLowFunction {
  4.   def main(args: Array[String]): Unit = {
  5.     val list = List(1,4,2,7,10,8,6)
  6.     //获取最大值
  7.     println(list.max)
  8.     //获取最小值
  9.     println(list.min)
  10.     //根据指定字段获取最大值
  11.     /*
  12.     * maxBy(func:集合元素类型=>B)
  13.       maxBy后续是根据函数的返回值来获取最大的元素
  14.       * maxBy里面的函数是针对集合每个元素操作
  15.      */
  16.     val list2 = List(("zhangsan",20,4500),("wangwu",45,10000),("lisi",18,2000),("wangwu",30,7000))
  17.     //println(list2.max)
  18.     val func = (x:(String,Int,Int))=>x._3
  19.     println(list2.maxBy(func))
  20.     //直接传递函数值
  21.     println(list2.maxBy((x: (String, Int, Int)) => x._3))
  22.     //省略函数类型
  23.     println(list2.maxBy((x) => x._3))
  24.     //函数的参数在函数体中只是使用了一次,可以用_代替
  25.     println(list2.maxBy(_._3))
  27.     /**
  28.      * 根据指定字段获取最小值
  29.      * minBy(func:集合元素类型=>B)
  30.      * minBy后续也是根据函数的返回值获取最小元素
  31.      * minBy里面的函数是针对集合每个元素操作
  32.      */
  33.     println(list2.minBy(_._2))
  34.     //求和
  35.     println(list.sum)
  36.     //排序
  37.     //sorted:直接根据元素本身排序,默认升序
  38.     //升序
  39.     println(list.sorted)
  40.     //降序
  41.     println(list.sorted.reverse)
  43.     println(list2.sorted)
  45.     /**
  46.      * sortBy(func:集合元素类型=>B) 根据指定字段排序,默认升序
  47.      * sortBy是根据函数的返回值排序
  48.      * sortBy里面的函数也是针对集合每个元素操作
  49.      */
  50.     val ordering = new Ordering[Int]{
  51.       override def compare(x: Int, y: Int): Int = {
  52.         if(x>y) -1
  53.         else if(x==y) 0
  54.         else 1
  55.       }
  56.     }
  57.     println(list2.sortBy(x => x._2)(ordering))
  59.     println(list.sortBy(x => x))
  60.     //sortWith:自定义排序规则
  61.     //sortWith(func:(集合元素类型,集合元素类型)=>Boolean)
  62.     //升序
  63.     println(list.sortWith((x: Int, y: Int) => x < y))
  64.     //降序
  65.     println(list.sortWith((x: Int, y: Int) => x > y))
  67.   }
  69. }

4.集合高级计算函数

  1. package com.atguigu.chapter07
  2. //集合高级计算函数
  3. object $15_CollectionHightFunction {
  5.   def main(args: Array[String]): Unit = {
  6.     /**
  7.      * map(func:集合元素类型=>B):映射[一对一]
  8.      * val B = A.Map(..)此时B集合的元素个数=A集合的元素个数
  9.      * map里面的函数是针对集合每个元素操作,集合有多少元素,函数就会调用多少次
  10.      * map就相当于for循环的yield表达式
  11.      * map的使用场景:一对一[map主要用于数据类型/值的转换]
  12.      */
  13.     val list = List("spark","hello","hadoop","java")
  14.     val func = (x:String)=>{
  15.       println(s"element=${x}")
  16.       x.length
  17.     }
  18.     val list2 = list.map(func)
  19.     println(list2)
  21.     /**
  22.      * flatten:压平
  23.      * flatten针对集合嵌套集合的场景
  24.      * flatten是将第二层集合压掉
  25.      * flatten的应用场景: 一对多
  26.      */
  27.     val list3:List[List[Int]]=List(
  28.       List(1,2,3),
  29.       List(4,5,6),
  30.       List(7,8)
  31.     )
  32.     val list4 = list3.flatten
  33.     println(list4)
  34.     val list5:List[List[List[Int]]]=List(
  35.       List(
  36.         List(1,2),
  37.         List(3,4)
  38.       ),
  39.       List(
  40.         List(5,6),
  41.         List(7)
  42.       )
  43.     )
  44.     val list6 = list5.flatten
  45.     println(list6)
  46.     val list7 = List("hello","spark")
  47.     println(list7.flatten)
  49.     /**
  50.      * flatMap(func:集合元素类型=>集合) = map + flatten
  51.      * flatMap里面的函数也是针对集合每个元素操作
  52.      * flatMap的应用场景:一对多
  53.      * flatMap与flatten的区别:
  54.      *    a.flatMap是先转换数据之后再压平
  55.      *    b.flatten没有数据转换工作,直接压平
  56.      *
  57.      * val B = A.flatMap 此时B集合的元素个数>=A集合的元素个数
  58.      */
  59.     val list8 = List("hello spark hello hadoop","hello python python hadoop","hadoop flume spark")
  60.     val list9 = list8.map(x=>x.split(" "))
  61.     val list10 = list9.flatten
  62.     println(list10)
  64.     /**
  65.      * foreach(func:集合元素类型=>B):Unit
  66.      * foreach中的函数是针对每个元素操作
  67.      * foreach与map的区别:map会生成新的集合,foreach没有返回值
  68.      */
  69.     list8.foreach(x=>println(x))
  70.     list8.foreach(println(_))
  71.     list8.foreach(println)
  73.     /**
  74.      * filter(func:集合元素类型=>Boolean):根据指定条件过滤
  75.      * filter保留的是函数返回值为true的数据
  76.      * filter里面的函数针对每个元素操作
  77.      */
  78.     val list11 = List(10,2,5,4,3,7,9)
  79.     val list12 = list11.filter(x=>x%2==0)
  80.     println(list12)
  82.     /**
  83.      * groupBy(func:集合元素类型=>K):根据指定字段分组
  84.      * groupBy里面的函数是针对集合每个元素操作
  85.      * groupBy后续是根据函数的返回值进行分组
  86.      * groupBy的结果是Map,map的key是函数返回值,map的value是原集合中key对应的所有元素
  87.      */
  88.     val list13 = List(("zhangsan","man","shenzhen"),("lisi","woman","beijing"),("wangwu","man","beijing"))
  89.     val map = list13.groupBy(x=>x._2)
  90.     println(map)
  92.     /**
  93.      * 聚合
  94.      * reduce(func:(集合元素类型,集合元素类型)=>集合元素类型):从左往右聚合
  95.      * reduce中的函数的第一个参数代表上一次的聚合结果,第二个参数是当前待聚合的元素
  96.      * reduce中的函数的第一个参数在第一次聚合的时候,初始值= 集合第一个元素
  97.      */
  98.     val result =list11.reduce((agg,curr)=>{
  99.       println(s"agg=${agg} curr=${curr}")
  100.       agg+curr
  101.     })
  102.     println(result)
  104.     /**
  105.      * reduceRight(func:(集合元素类型,集合元素类型)=>集合元素类型):从右向左聚合
  106.      * reduceRight中的函数的第一个参数是当前待聚合的元素,第二个参数是代表上一次的聚合结果
  107.      * reduce中的函数的第二个参数在第一次聚合的时候,初始值=集合最后一个元素
  108.      */
  109.     list11.reduceRight((curr,agg)=>{
  110.       println(s"agg=${agg} curr=${curr}")
  111.       agg+curr
  112.     })
  113.     println(("---------------------"))
  115.     /**
  116.      * fold(默认值)(func:(集合元素类型,集合元素类型)=>集合元素类型):从左往右聚合
  117.      * fold中的函数的第一个参数代表的是上一次的聚合结果,第二个参数是当前待聚合的元素
  118.      * fold中的函数的第一个参数在第一次聚合的时候,初始值=默认值
  119.      */
  120.     list11.fold(100)((agg,curr)=>{
  121.       println(s"agg=${agg} curr=${curr}")
  122.       agg+curr
  123.     })
  125.     /**
  126.      * foldRight(默认值)(func:(集合元素类型,集合元素类型)=>集合元素类型):从右向左聚合
  127.      * foldRight函数的第一个参数是当前待聚合的元素,第二个参数代表的是上一次的聚合效果
  128.      * foldRight中的函数的第二个参数在第一次聚合的时候,初始值=默认值
  129.      */
  130.     println(("--------------------------"))
  131.     list11.foldRight(0)((curr,agg)=>{
  132.       println(s"curr=${curr} agg=${agg}")
  133.       agg+curr
  134.     })
  138.   }
  141. }

5.WordCount普通版

  1. package com.atguigu.chapter07
  3. import scala.io.Source
  5. object $16_WordCountLow {
  6.   def main(args: Array[String]): Unit = {
  7.     //1.读取文件
  8.     val datas = Source.fromFile("datas/wc.txt").getLines().toList
  10.     /**
  11.      * List(
  12.      * "hello spark hello"
  13.      * "python scala spark"
  14.      * "spark kafka flume"
  15.      * "flume kafka scala"
  16.      * )
  17.      */
  18.     //2.切割+压平
  19.     val list = datas.flatMap(line => line.split(" "))
  20.     //List(hello,spark,hello,python,scala,spark,spark,kafka,flume,flume,kafka,scala)
  22.     //3.按照单词分组
  23.     val groupedMap = list.groupBy(x=>x)
  25.     /**
  26.      * Map(
  27.      *  hello->list(hello,hello)
  28.      *  spark->list(spark,spark,spark)
  29.      * )
  30.      */
  31.     //4.聚合
  32.     val result = groupedMap.map(x => {
  33.       (x._1, x._2.length)
  34.     })
  35.     //5.结果展示
  36.     result.foreach(println)
  37.     println("-"*100)
  38.     Source.fromFile("datas/wc.txt")
  39.       .getLines()
  40.       .toList
  41.       .flatMap(_.split(" "))
  42.       .groupBy(x=>x)
  43.       .map(x=>(x._1,x._2.size))
  44.       .foreach(println(_))
  45.   }
  47. }

6.WordCount高配版

  1. package com.atguigu.chapter07
  3. object $17_WordCountHight {
  4.   def main(args: Array[String]): Unit = {
  5.     val tupleList = List(("Hello Scala Spark World",4),("Hello Scala Spark",3),("Hello Scala",2),("Hello",1))
  6.     //1.切割,赋予单词初始次数+压平
  7.     val list = tupleList.flatMap(x => {
  8.       //x=("Hello Scala Spark World",4)
  9.       val arr = x._1.split(" ")//Array(Hello,Scala,Spark,World)
  10.       val list = arr.map(y => (y, x._2))//Array(Hello->4,Scala->4,Spark->4,World->4)
  11.       list
  12.     })
  13.     //2.按照单词进行分组
  14.     val groupedMap = list.groupBy(_._1)
  15.     //Map(
  16.     //    Hello -> List( Hello->4，Hello->3，Hello->2，Hello->1 )
  17.     //    Scala -> List( Scala->4,Scala->3,Scala->2)
  18.     //    .....
  19.     // )
  20.     //
  21.     //3.聚合
  22.     val result = groupedMap.map(x => {
  23.       val sum = x._2.map(_._2).sum
  24.       (x._1, sum)
  25.     })
  26.     //4.结果展示
  27.     result.foreach(println)
  29.     println("-"*100)
  30.     tupleList.flatMap(line=>line._1.split(" ").map((_,line._2)))
  31.       .groupBy(_._1)
  32.       .map(x=>(x._1,x._2.map(_._2).sum))
  33.       .foreach(println)
  34.   }
  36. }

7.并行集合

  1. package com.atguigu.chapter07
  3. object $18_Par {
  5.   /**
  6.    * scala的集合默认都是单线程操作,如果想要多线程操作,需要转为并行集合
  7.    * 普通集合转并行集合:集合名.par
  8.    */
  9.   def main(args: Array[String]): Unit = {
  10.     val list = List(10,3,2,9,7,4)
  11.     list.foreach(x=>{
  12.       println(s"${Thread.currentThread().getName}---${x}")
  13.     })
  14.     val list2 = list.par
  15.     list2.foreach(x=>{
  16.       println(s"${Thread.currentThread().getName}---${x}")
  17.     })
  18.   }
  20. }

第二章.模式匹配

1.模式匹配定义

  1. package com.atguigu.chapter08
  3. import scala.io.StdIn
  5. object $01_MatchDefined {
  6.   /**
  7.    * 模式匹配的语法
  8.    *    变量 match{
  9.    *        case 条件 => {...}
  10.    *        case 条件 => {...}
  11.    *        case 条件 => {...}
  12.    *        case 条件 => {...}
  13.    *        case 条件 => {...}
  14.    *    }
  15.    *    模式匹配有返回值,返回值是符合条件的分支的块表达式的结果值
  16.    */
  17.   def main(args: Array[String]): Unit = {
  18.     val wc = StdIn.readLine("请输入一个单词:")
  19.     val r = wc match {
  20.       case "hadoop" => {
  21.         println("输入的是Hadoop")
  22.         40
  23.       }
  24.       case "spark" => {
  25.         println("输入的是spark")
  26.         30
  27.       }
  28.       //匹配条件后面的{}可以省略
  29.       case "flume" =>
  30.         val a = 10
  31.         val b = 20
  32.         val c = a + b
  33.         println("输入的是flume")
  34.         10
  35.       //case x =>{
  37.       //}
  38.       //如果变量x在=>右边不使用可以用_代替,相当于switch的default
  39.       case _ =>
  40.         println("其他....")
  41.         20
  42.     }
  43.     println(r)
  44.   }
  45. }

2.模式匹配守卫

  1. package com.atguigu.chapter08
  3. import scala.io.StdIn
  5. object $02_MatchIf {
  6.   /**
  7.    * 模式匹配守卫语法
  8.    *      变量 match {
  9.    *      case 条件 if(布尔表达式) => ...
  10.    *      case 条件 if(布尔表达式) => ...
  11.    *      case 条件 if(布尔表达式) => ...
  12.    *      case 条件 if(布尔表达式) => ...
  13.    *      case 条件 if(布尔表达式) => ...
  14.    *}
  15.    * 有守卫的时候必须case满足条件并且守卫也满足条件才算匹配上
  16.    */
  17.   def main(args: Array[String]): Unit = {
  18.     val line = StdIn.readLine("请输入一行语句:")
  19.     line match {
  20.       case x if(x.contains("hadoop"))=>
  21.         println("句子包含hadoop")
  22.       case x if(x.contains("spark"))=>
  23.         println("句子包含spark")
  24.       case x if(x.contains("kafka"))=>
  25.         println("句子包含kafka")
  26.       case x =>
  27.         println("其他")
  28.     }
  29.   }
  31. }

3.匹配值

  1. package com.atguigu.chapter08
  3. import scala.io.StdIn
  5. object $03_MatchValue {
  6.   /**
  7.    * 匹配值的语法
  8.    *    变量 match {
  9.    *    case 值 => ...
  10.    *    case 值 => ...
  11.    *    case 值 => ...
  12.    *    case 值 => ...
  13.    *    }
  14.    *  如果需要使用外部变量作为匹配条件,此时该变量首字母必须大写
  15.    */
  16.   def main(args: Array[String]): Unit = {
  17.     val wc = StdIn.readLine("请输入一个单词:")
  18.     val Abc = "kafka"
  19.     wc match {
  20.       case Abc => println("kafka....")
  21.       case "hadoop" => println("hadoop....")
  22.       case "spark" => println("spark....")
  23.       case "flume" => println("flume....")
  24.       case abc => println("其他....")
  25.     }
  26.   }
  28. }

4.匹配类型

  1. package com.atguigu.chapter08
  3. import scala.util.Random
  5. object $04_MatchType {
  6.   /**
  7.    * 匹配类型语法
  8.    *     变量名 match {
  9.    *        case X: 类型1 =>...
  10.    *        case X: 类型2 =>...
  11.    *        case X: 类型3 =>...
  12.    *        case X: 类型4 =>...
  13.    *
  14.    *        ...
  15.    *     }
  16.    */
  17.     class Person
  18.   def main(args: Array[String]): Unit = {
  19.     val list =List(10,2,0,false,"hello",new Person)
  20.     val index = Random.nextInt(list.size)
  21.     println(s"index=${index}")
  22.     list(index) match {
  23.       case  _:String => println("String....")
  24.       case  _:Int => println("Int....")
  25.       case  _:Double => println("Double....")
  26.       case  _:Person => println("Person....")
  27.       case  _:Boolean => println("Boolean....")
  28.     }
  29.   }
  31. }

5.匹配数组

  1. package com.atguigu.chapter08
  3. object $05_MatchArray {
  4.   /**
  5.    * 数组的匹配语法
  6.    *  数组名 match {
  7.    *      case Array(x,y,z..)=>...
  8.    *  }
  9.    */
  10.   def main(args: Array[String]): Unit = {
  11.     val arr = Array("Sxxxxx",10.0,2.5,false,10,1,2,2)
  12.     arr match{
  13.       case Array(x:String,y:Int,_*)=> println("匹配数组中至少有两个元素,第一个元素是String类型,第二个元素类型是Int")
  14.       case Array(_,_*)=> println("匹配数组中至少有一个元素")
  15.       case Array(x) => println("匹配数组中只有一个元素")
  16.       case Array(x,_,z) => println("匹配数组中有三个元素")
  17.     }
  18.   }
  20. }

6.匹配列表

  1. package com.atguigu.chapter08
  3. object $06_MatchList {
  4.   /**
  5.    * List的匹配语法
  6.    */
  7.   def main(args: Array[String]): Unit = {
  8.     val list:List[Any] =List(1,4,3,2)
  9.     //第一种
  10.     list match {
  11.       case List(x)=> println("匹配list只有一个元素")
  12.       case List(_,_,_)=> println("匹配list有三个元素")
  13.       case List(_,_*)=> println("匹配list至少一个元素")
  14.       case List(x:String,_*)=> println("匹配一个list至少一个元素")
  15.     }
  16.     //第二种
  17.     list match{
  18.       case x :: Nil => println("匹配list只有一个元素")
  19.       case x :: _ :: z :: Nil => println("匹配list有三个元素")
  20.       case x :: tail => println("匹配list至少一个元素")
  21.       case (x:String) ::tail => "匹配list至少一个元素"
  22.     }
  23.   }
  25. }