$05[Scala(集合)下_(模式匹配)上]

第一章.集合

1.集合基本属性

package com.atguigu.chapter07
//集合基本属性
object $12_CollectionFields {
  def main(args: Array[String]): Unit = {
    val list  = List(1,3,2,8,10,12)
    //是否包含某个元素
    println(list.contains(100))
    //获取集合长度
    println(list.length)
    println(list.size)
    //将集合所有元素拼接成字符串
    println(list.mkString("#"))
    //判断集合是否为空
    println(list.isEmpty)
    //集合转迭代器
    val it = list.toIterator
    for (elem <- it) {
      println(s"elem=${elem}")
    }
    println(("-----------------"))
    for (elem <- it) {
      println(s"elem1=${elem}")
    }
    println(("-------------"))
    val it2 = list.toIterable
    for (elem <- it2) {
      println(s"elem=${elem}")
    }
    println("---------------")
    for (elem <- it2) {
      println(s"elem1=${elem}")
    }
  }


}

2.衍生集合

package com.atguigu.chapter07
//衍生集合
object $13_Collection {
  def main(args: Array[String]): Unit = {
    val list = List(1,2,3,1,4,5,6,7,8,9)
    //去重
    val list2 = list.distinct
    println(list2)
    //获取除开前N个元素的其他所有元素
    println(list.drop(3))
    //获取第一个元素
    println(list.head)
    //获取最后一个元素
    println(list.last)
    //获取除开最后一个元素的其他所有元素
    println(list.init)
    //获取除开第一个元素的其他所有元素
    println(list.tail)
    //反转
    println(list.reverse)
    //获取指定角标范围的所有元素
    println(list.slice(2, 5))
    //滑窗
    //sliding(size[,step=1])
    //size: 窗口长度
    //step: 滑动长度
    println(list.sliding(2).toList)
    //获取前n个元素
    println(list.take(3))
    //获取后n个元素
    println(list.takeRight(3))
    //交集:两个集合共同的元素
    val list3 = List(1,2,3,4,5)
    val list4 = List(4,5,6,7,8)
    val list5 = list3.intersect(list4)
    println(list5)
    //差集: A差B的结果就是A中除开交集的所有元素
    val list6 = list3.diff(list4)
    println(list6)
    //并集: 两个集合的所有元素
    val list7 = list3.union(list4)
    println(list7)
    //拉链
    val list8 = List("zhangsan","wangwu","lilei","hanmeimei")
    val list9 = List(20,30,40)
    val list10 = list8.zip(list9)
    println(list10)
    //反拉链
    println(list10.unzip)
    //将元素与角标拉链
    println(list8.zipWithIndex)

  }

}

3.集合初级计算函数

package com.atguigu.chapter07
//集合初级计算函数
object $14_CollectionLowFunction {
  def main(args: Array[String]): Unit = {
    val list = List(1,4,2,7,10,8,6)
    //获取最大值
    println(list.max)
    //获取最小值
    println(list.min)
    //根据指定字段获取最大值
    /*
    * maxBy(func:集合元素类型=>B)
      maxBy后续是根据函数的返回值来获取最大的元素
      * maxBy里面的函数是针对集合每个元素操作
     */
    val list2 = List(("zhangsan",20,4500),("wangwu",45,10000),("lisi",18,2000),("wangwu",30,7000))
    //println(list2.max)
    val func = (x:(String,Int,Int))=>x._3
    println(list2.maxBy(func))
    //直接传递函数值
    println(list2.maxBy((x: (String, Int, Int)) => x._3))
    //省略函数类型
    println(list2.maxBy((x) => x._3))
    //函数的参数在函数体中只是使用了一次,可以用_代替
    println(list2.maxBy(_._3))

    /**
     * 根据指定字段获取最小值
     * minBy(func:集合元素类型=>B)
     * minBy后续也是根据函数的返回值获取最小元素
     * minBy里面的函数是针对集合每个元素操作
     */
    println(list2.minBy(_._2))
    //求和
    println(list.sum)
    //排序
    //sorted:直接根据元素本身排序,默认升序
    //升序
    println(list.sorted)
    //降序
    println(list.sorted.reverse)

    println(list2.sorted)

    /**
     * sortBy(func:集合元素类型=>B) 根据指定字段排序,默认升序
     * sortBy是根据函数的返回值排序
     * sortBy里面的函数也是针对集合每个元素操作
     */
    val ordering = new Ordering[Int]{
      override def compare(x: Int, y: Int): Int = {
        if(x>y) -1
        else if(x==y) 0
        else 1
      }
    }
    println(list2.sortBy(x => x._2)(ordering))

    println(list.sortBy(x => x))
    //sortWith:自定义排序规则
    //sortWith(func:(集合元素类型,集合元素类型)=>Boolean)
    //升序
    println(list.sortWith((x: Int, y: Int) => x < y))
    //降序
    println(list.sortWith((x: Int, y: Int) => x > y))

  }

}

4.集合高级计算函数

package com.atguigu.chapter07
//集合高级计算函数
object $15_CollectionHightFunction {

  def main(args: Array[String]): Unit = {
    /**
     * map(func:集合元素类型=>B):映射[一对一]
     * val B = A.Map(..)此时B集合的元素个数=A集合的元素个数
     * map里面的函数是针对集合每个元素操作,集合有多少元素,函数就会调用多少次
     * map就相当于for循环的yield表达式
     * map的使用场景:一对一[map主要用于数据类型/值的转换]
     */
    val list = List("spark","hello","hadoop","java")
    val func = (x:String)=>{
      println(s"element=${x}")
      x.length
    }
    val list2 = list.map(func)
    println(list2)

    /**
     * flatten:压平
     * flatten针对集合嵌套集合的场景
     * flatten是将第二层集合压掉
     * flatten的应用场景: 一对多
     */
    val list3:List[List[Int]]=List(
      List(1,2,3),
      List(4,5,6),
      List(7,8)
    )
    val list4 = list3.flatten
    println(list4)
    val list5:List[List[List[Int]]]=List(
      List(
        List(1,2),
        List(3,4)
      ),
      List(
        List(5,6),
        List(7)
      )
    )
    val list6 = list5.flatten
    println(list6)
    val list7 = List("hello","spark")
    println(list7.flatten)

    /**
     * flatMap(func:集合元素类型=>集合) = map + flatten
     * flatMap里面的函数也是针对集合每个元素操作
     * flatMap的应用场景:一对多
     * flatMap与flatten的区别:
     *    a.flatMap是先转换数据之后再压平
     *    b.flatten没有数据转换工作,直接压平
     *
     * val B = A.flatMap 此时B集合的元素个数>=A集合的元素个数
     */
    val list8 = List("hello spark hello hadoop","hello python python hadoop","hadoop flume spark")
    val list9 = list8.map(x=>x.split(" "))
    val list10 = list9.flatten
    println(list10)

    /**
     * foreach(func:集合元素类型=>B):Unit
     * foreach中的函数是针对每个元素操作
     * foreach与map的区别:map会生成新的集合,foreach没有返回值
     */
    list8.foreach(x=>println(x))
    list8.foreach(println(_))
    list8.foreach(println)

    /**
     * filter(func:集合元素类型=>Boolean):根据指定条件过滤
     * filter保留的是函数返回值为true的数据
     * filter里面的函数针对每个元素操作
     */
    val list11 = List(10,2,5,4,3,7,9)
    val list12 = list11.filter(x=>x%2==0)
    println(list12)

    /**
     * groupBy(func:集合元素类型=>K):根据指定字段分组
     * groupBy里面的函数是针对集合每个元素操作
     * groupBy后续是根据函数的返回值进行分组
     * groupBy的结果是Map,map的key是函数返回值,map的value是原集合中key对应的所有元素
     */
    val list13 = List(("zhangsan","man","shenzhen"),("lisi","woman","beijing"),("wangwu","man","beijing"))
    val map = list13.groupBy(x=>x._2)
    println(map)

    /**
     * 聚合
     * reduce(func:(集合元素类型,集合元素类型)=>集合元素类型):从左往右聚合
     * reduce中的函数的第一个参数代表上一次的聚合结果,第二个参数是当前待聚合的元素
     * reduce中的函数的第一个参数在第一次聚合的时候,初始值= 集合第一个元素
     */
    val result =list11.reduce((agg,curr)=>{
      println(s"agg=${agg} curr=${curr}")
      agg+curr
    })
    println(result)

    /**
     * reduceRight(func:(集合元素类型,集合元素类型)=>集合元素类型):从右向左聚合
     * reduceRight中的函数的第一个参数是当前待聚合的元素,第二个参数是代表上一次的聚合结果
     * reduce中的函数的第二个参数在第一次聚合的时候,初始值=集合最后一个元素
     */
    list11.reduceRight((curr,agg)=>{
      println(s"agg=${agg} curr=${curr}")
      agg+curr
    })
    println(("---------------------"))

    /**
     * fold(默认值)(func:(集合元素类型,集合元素类型)=>集合元素类型):从左往右聚合
     * fold中的函数的第一个参数代表的是上一次的聚合结果,第二个参数是当前待聚合的元素
     * fold中的函数的第一个参数在第一次聚合的时候,初始值=默认值
     */
    list11.fold(100)((agg,curr)=>{
      println(s"agg=${agg} curr=${curr}")
      agg+curr
    })

    /**
     * foldRight(默认值)(func:(集合元素类型,集合元素类型)=>集合元素类型):从右向左聚合
     * foldRight函数的第一个参数是当前待聚合的元素,第二个参数代表的是上一次的聚合效果
     * foldRight中的函数的第二个参数在第一次聚合的时候,初始值=默认值
     */
    println(("--------------------------"))
    list11.foldRight(0)((curr,agg)=>{
      println(s"curr=${curr} agg=${agg}")
      agg+curr
    })



  }


}

5.WordCount普通版

package com.atguigu.chapter07

import scala.io.Source

object $16_WordCountLow {
  def main(args: Array[String]): Unit = {
    //1.读取文件
    val datas = Source.fromFile("datas/wc.txt").getLines().toList

    /**
     * List(
     * "hello spark hello"
     * "python scala spark"
     * "spark kafka flume"
     * "flume kafka scala"
     * )
     */
    //2.切割+压平
    val list = datas.flatMap(line => line.split(" "))
    //List(hello,spark,hello,python,scala,spark,spark,kafka,flume,flume,kafka,scala)

    //3.按照单词分组
    val groupedMap = list.groupBy(x=>x)

    /**
     * Map(
     *  hello->list(hello,hello)
     *  spark->list(spark,spark,spark)
     * )
     */
    //4.聚合
    val result = groupedMap.map(x => {
      (x._1, x._2.length)
    })
    //5.结果展示
    result.foreach(println)
    println("-"*100)
    Source.fromFile("datas/wc.txt")
      .getLines()
      .toList
      .flatMap(_.split(" "))
      .groupBy(x=>x)
      .map(x=>(x._1,x._2.size))
      .foreach(println(_))
  }

}

6.WordCount高配版

package com.atguigu.chapter07

object $17_WordCountHight {
  def main(args: Array[String]): Unit = {
    val tupleList = List(("Hello Scala Spark World",4),("Hello Scala Spark",3),("Hello Scala",2),("Hello",1))
    //1.切割,赋予单词初始次数+压平
    val list = tupleList.flatMap(x => {
      //x=("Hello Scala Spark World",4)
      val arr = x._1.split(" ")//Array(Hello,Scala,Spark,World)
      val list = arr.map(y => (y, x._2))//Array(Hello->4,Scala->4,Spark->4,World->4)
      list
    })
    //2.按照单词进行分组
    val groupedMap = list.groupBy(_._1)
    //Map(
    //    Hello -> List( Hello->4，Hello->3，Hello->2，Hello->1 )
    //    Scala -> List( Scala->4,Scala->3,Scala->2)
    //    .....
    // )
    //
    //3.聚合
    val result = groupedMap.map(x => {
      val sum = x._2.map(_._2).sum
      (x._1, sum)
    })
    //4.结果展示
    result.foreach(println)

    println("-"*100)
    tupleList.flatMap(line=>line._1.split(" ").map((_,line._2)))
      .groupBy(_._1)
      .map(x=>(x._1,x._2.map(_._2).sum))
      .foreach(println)
  }

}

7.并行集合

package com.atguigu.chapter07

object $18_Par {

  /**
   * scala的集合默认都是单线程操作,如果想要多线程操作,需要转为并行集合
   * 普通集合转并行集合:集合名.par
   */
  def main(args: Array[String]): Unit = {
    val list = List(10,3,2,9,7,4)
    list.foreach(x=>{
      println(s"${Thread.currentThread().getName}---${x}")
    })
    val list2 = list.par
    list2.foreach(x=>{
      println(s"${Thread.currentThread().getName}---${x}")
    })
  }

}

第二章.模式匹配

1.模式匹配定义

package com.atguigu.chapter08

import scala.io.StdIn

object $01_MatchDefined {
  /**
   * 模式匹配的语法
   *    变量 match{
   *        case 条件 => {...}
   *        case 条件 => {...}
   *        case 条件 => {...}
   *        case 条件 => {...}
   *        case 条件 => {...}
   *    }
   *    模式匹配有返回值,返回值是符合条件的分支的块表达式的结果值
   */
  def main(args: Array[String]): Unit = {
    val wc = StdIn.readLine("请输入一个单词:")
    val r = wc match {
      case "hadoop" => {
        println("输入的是Hadoop")
        40
      }
      case "spark" => {
        println("输入的是spark")
        30
      }
      //匹配条件后面的{}可以省略
      case "flume" =>
        val a = 10
        val b = 20
        val c = a + b
        println("输入的是flume")
        10
      //case x =>{

      //}
      //如果变量x在=>右边不使用可以用_代替,相当于switch的default
      case _ =>
        println("其他....")
        20
    }
    println(r)
  }
}

2.模式匹配守卫

package com.atguigu.chapter08

import scala.io.StdIn

object $02_MatchIf {
  /**
   * 模式匹配守卫语法
   *      变量 match {
   *      case 条件 if(布尔表达式) => ...
   *      case 条件 if(布尔表达式) => ...
   *      case 条件 if(布尔表达式) => ...
   *      case 条件 if(布尔表达式) => ...
   *      case 条件 if(布尔表达式) => ...
   *}
   * 有守卫的时候必须case满足条件并且守卫也满足条件才算匹配上
   */
  def main(args: Array[String]): Unit = {
    val line = StdIn.readLine("请输入一行语句:")
    line match {
      case x if(x.contains("hadoop"))=>
        println("句子包含hadoop")
      case x if(x.contains("spark"))=>
        println("句子包含spark")
      case x if(x.contains("kafka"))=>
        println("句子包含kafka")
      case x =>
        println("其他")
    }
  }

}

3.匹配值

package com.atguigu.chapter08

import scala.io.StdIn

object $03_MatchValue {
  /**
   * 匹配值的语法
   *    变量 match {
   *    case 值 => ...
   *    case 值 => ...
   *    case 值 => ...
   *    case 值 => ...
   *    }
   *  如果需要使用外部变量作为匹配条件,此时该变量首字母必须大写
   */
  def main(args: Array[String]): Unit = {
    val wc = StdIn.readLine("请输入一个单词:")
    val Abc = "kafka"
    wc match {
      case Abc => println("kafka....")
      case "hadoop" => println("hadoop....")
      case "spark" => println("spark....")
      case "flume" => println("flume....")
      case abc => println("其他....")
    }
  }

}

4.匹配类型

package com.atguigu.chapter08

import scala.util.Random

object $04_MatchType {
  /**
   * 匹配类型语法
   *     变量名 match {
   *        case X: 类型1 =>...
   *        case X: 类型2 =>...
   *        case X: 类型3 =>...
   *        case X: 类型4 =>...
   *
   *        ...
   *     }
   */
    class Person
  def main(args: Array[String]): Unit = {
    val list =List(10,2,0,false,"hello",new Person)
    val index = Random.nextInt(list.size)
    println(s"index=${index}")
    list(index) match {
      case  _:String => println("String....")
      case  _:Int => println("Int....")
      case  _:Double => println("Double....")
      case  _:Person => println("Person....")
      case  _:Boolean => println("Boolean....")
    }
  }

}

5.匹配数组

package com.atguigu.chapter08

object $05_MatchArray {
  /**
   * 数组的匹配语法
   *  数组名 match {
   *      case Array(x,y,z..)=>...
   *  }
   */
  def main(args: Array[String]): Unit = {
    val arr = Array("Sxxxxx",10.0,2.5,false,10,1,2,2)
    arr match{
      case Array(x:String,y:Int,_*)=> println("匹配数组中至少有两个元素,第一个元素是String类型,第二个元素类型是Int")
      case Array(_,_*)=> println("匹配数组中至少有一个元素")
      case Array(x) => println("匹配数组中只有一个元素")
      case Array(x,_,z) => println("匹配数组中有三个元素")
    }
  }

}

6.匹配列表

package com.atguigu.chapter08

object $06_MatchList {
  /**
   * List的匹配语法
   */
  def main(args: Array[String]): Unit = {
    val list:List[Any] =List(1,4,3,2)
    //第一种
    list match {
      case List(x)=> println("匹配list只有一个元素")
      case List(_,_,_)=> println("匹配list有三个元素")
      case List(_,_*)=> println("匹配list至少一个元素")
      case List(x:String,_*)=> println("匹配一个list至少一个元素")
    }
    //第二种
    list match{
      case x :: Nil => println("匹配list只有一个元素")
      case x :: _ :: z :: Nil => println("匹配list有三个元素")
      case x :: tail => println("匹配list至少一个元素")
      case (x:String) ::tail => "匹配list至少一个元素"
    }
  }

}