Scala模式匹配+模式守卫集合——15天语言基础完结

 def main(args: Array[String]): Unit = {
    val list = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
    //1.过滤
    //选取偶数
    println(list.filter(_ % 2 ==0))//选取满足条件的偶数
    println(list.filter(_ % 2 !=0))
    println(list.filter(_ % 2 !=0))

    //2.map
    //把集合中的每个数乘2
    println(list.map(_*2))
    println(list.map(x => x * x))//每项平方

    println("==============")

    //3.扁平化(把嵌套的集合 拆分出来)
    val nestedList:List[List[Int]] = List(List(1,2,3),List(4,5,6),List(7,8,9))
    val flatlist=nestedList(0) ::: nestedList(1) ::: nestedList(2)
    println(flatlist)

    val flatList2=nestedList.flatten
    println(flatList2)


    //4.扁平映射
    //将一组字符串进行分词,并保存单词的列表
    val strings: List[String] =List("Hello world", "hello scala" ,"hello java", "we study")
    val flatmapList =strings.flatMap(_.split(" "))
    println(flatmapList)

  //5.分成奇偶两组
    val groupMap:Map[Int,List[Int]] = list.groupBy(_ % 2)
    println(groupMap)

    //给定一组词汇,按照单词首字母进行分组
    val wordList=List("china","america","alice","canada","cary","bob","japan")
    println(wordList.groupBy(_.charAt(0)))//_表示对象的 首字母

    val wordList1=List("America","alice","bob","lyt","lfy")
    println(wordList1.groupBy(_.charAt(0)))
  }

那人独钓寒江雪 10:14:45
def main(args: Array[String]): Unit = {
    val list=List(1,2,3,4,5)
    println(list.reduce(_+_))
    println(list.reduceLeft(_+_))
    println(list.reduceRight(_+_))

    val list1=List(3,5,8,7,9)
    println(list1.reduce(_-_))
    println(list1.reduceLeft(_-_))
    println(list1.reduceRight(_-_))

    //2.fold
    println(list.fold(10)(_+_))//10+1+2+3+4
    println(list.foldLeft(10)(_-_))//10-1-2-3-4
    println(list.foldRight(11)(_-_))//3-(4-(5-(8-(10-11)))

那人独钓寒江雪 10:14:51
  def main(args: Array[String]): Unit = {
    val map1=Map("a"->1,"b"->3,"c" ->6)
    val map2=mutable.Map("a"->6,"b"->2,"c"->9,"d"->3)//可变集合

    val map3=map1.foldLeft(map2)(
      (mergedmp,kv) => {
        val key =kv._1
        val value=kv._2
        mergedmp(key)=mergedmp.getOrElse(key,0) + value
        mergedmp
      }
    )
    println(map3)
  }
}
  def main(args: Array[String]): Unit = {
    val map1=Map("a"->1,"b"->3,"c" ->6)
    val map2=mutable.Map("a"->6,"b"->2,"c"->9,"d"->3)//可变集合

    val map3=map1.foldLeft(map2)(
      (mergedmp,kv) => {
        val key =kv._1
        val value=kv._2
        mergedmp(key)=mergedmp.getOrElse(key,0) + value
        mergedmp
      }
    )
    println(map3)
  }
}

那人独钓寒江雪 10:15:00
def main(args: Array[String]): Unit = {
    val stringList: List[String] =List(//：后面的可要可不要
      "hello",
      "hello world",
      "hello scala",
      "hello spark from scala",
      "hello flink from scala"
    )
    //1.对字符串进行切分,得到一个打散所有单词的类别
    val wordList1=stringList.flatMap(_.split(" "))
    println(wordList1)

//    2.相同的单词进行分组
    val groupMap=wordList1.groupBy(word => word)//map(x=> x*x) or map(_ % 2 ==0)
    println(groupMap)

    //3.对分组之后的list取长度,得到每个单词的个数
    val countMap=groupMap.map(kv => (kv._1,kv._2.length))//一是键值 二是value值
    println(countMap)

    //4.将map转换为list,并排序前三
    val sortList =countMap.toList
      .sortWith(_._2>_._2)//取value值的前三
      .take(3)
    println(sortList)
  }

那人独钓寒江雪 10:15:21
def main(args: Array[String]): Unit = {
    val tupleList: List[(String, Int)] =List(//：后面的可要可不要
      ("hello",1),
      ("hello world",2),
      ("hello scala",3),
      ("hello spark from scala",1),
      ("hello flink from scala",2)
    )
    //思路一：直接展开为普通版本
    val newStringList: List[String] = tupleList.map(
      kv => {
        (kv._1.trim + " ")* kv._2
      }
    )
    println(newStringList)


    //接下来的操作与普通版本完全一致
    val wordcountList : List[(String, Int)]=newStringList
      .flatMap(_.split(" "))//空格分词
      .groupBy(word => word)//按照单词分组
      .map(kv => (kv._1,kv._2.size))// 统计每个单词的个数
      .toList
      .sortBy(_._2)(Ordering[Int].reverse)
      .take(3)
      println(wordcountList)

那人独钓寒江雪 10:15:26
 def main(args: Array[String]): Unit = {
    //Scala也提供了队列的数据结构,队列的特点就是先进先出.进队和出队的方法分别为enqueue和dequeue
    //创建一个可变队列
    val queue:mutable.Queue[String] = new mutable.Queue[String]()/al queue:mutable.Queue[String]

    //出队
    queue.enqueue("a","b","c")
    println(queue)
    println(queue.dequeue())//从左往右取
    println(queue)
    println(queue.dequeue())

    //入队
    queue.enqueue("d","e","f")
    println(queue)

    //不可变队里
    val queue2: Queue[String]= Queue("a","b","c")
    queue2.enqueue("d")
    println(queue2)
    //对不可变队列增加元素

    val queue3=queue2.enqueue("d")
    println(queue3)

  }

那人独钓寒江雪 10:16:44
//  }

那人独钓寒江雪 10:16:57
 def main(args: Array[String]): Unit = {
//    1.基本定义语法
    val x: Int = 8
    val y: String = x match {
      case 1 => "one"
      case 2 => "two"
      case 3 => "three"
      case 4 => "other"
      case _ => "anoher"
    }
    println(y)
    //2.示例:用模式匹配实现简单二元运算
    val a:Int= 25
    val b:Int = 13

    def matchDualOp(oq: Char): Int = oq match { //给函数定义一个参数加类型 oq是满足下面定义条件的参数
      case '+' => a + b  //如果oq等于case后面的值 那么会返回lambda表达式的值
      case '-' => a - b
      case '*' => a * b
      case '/' => a / b
      case '%' => a % b
      case _ => -1
    }

    println(matchDualOp('+'))
    println(matchDualOp('-'))
    println(matchDualOp('*'))

    //3.模式守卫
    //求一个整数的绝对值
    def abs(num: Int): Int = num match {
      case i if i >= 0 => i
      case i if i < 0 => i
    }

    println(abs(67))
    println(abs(0))
    println(abs(-24))

    //模式匹配类型
    //1.匹配常量
    def describeConst(x:Any):String = x match {//Any表示任何类型
      case 1 => "Int one"
      case "hello" =>"String hello"
      case true => "Boolean true"
      case '+' =>""
    }
    println(describeConst("hello"))//输入的值 取出对应的值
    println(describeConst(1))

//    2.匹配类型
    }
    def describeType(x:Any):String =x match {//Any表示case后面的可以是任何类型,：String表示返回的值为字符串类型
      case i:Int => "Int:" + i
      case s:String => "String:" +s
      case list: List[String] => "List:" + list
      case array : Array[Int] => "Array[Int]:" + array.mkString(",")
      case a => "Something else:" +a
    }
    println(describeType(35))
    println(describeType("hello"))
    println(describeType(List("hi","hello")))
    println(describeType(List(2,23)))
    println(describeType(Array(2,23)))
    //3.匹配数组
   for (arr <- List(
     Array(0),
     Array(1,0),
     Array(0,1,0),
     Array(1,1,0),
     Array(2,3,7,15),
     Array("hello",20,30)
   )){
     val result = arr match {
     case Array(0) => "0"
     case Array(1,0) => "Array(1,0)"
     case Array(x,y) => "Array:" + x + ","+y//匹配两元素数组
     case Array(0,_*)=> "以0开头的数组"
     case Array(x,1,z) => "中间为1的三元素组"
     case _=>"something else"
   }}
    println(result)

    //4.匹配列表
    for (list <- List(
      List(0),
      List(1,0),
      List(0,0,0),
      List(1,1,0),
      List(88)
    )){
      val result = list match {
        case List(0) =>"0"
        case List(x,y) =>"List(x,y):" +x +", "+y
        case List(0, _*)=> "List(0,...)"
        case List(a)=> "List(a):" +a
        case _ => "something else"
      }
      println(result)
    }
    //方式二
    val list=List(1,2,5,7,24)
    list match {
      case first :: second :: rest =>println(s"first: $first,second:$second,rest:$rest")
      case _ => println("something else")
}
    println("----")
    //5.匹配元组
    for (tuple <- List(
      (0,1),
      (0,0),
      (0,1,0),
      (0,1,1),
      (1,23,56)
    )){
      val result =tuple match {
        case (a,b) => "" +a +"," +b
        case (0,_) => "(0,_)"
        case(a,1,_)=> "(a,1,_)" + a
        case _ => "something else"
      }
      println(result)
    }
//  }

那人独钓寒江雪 10:17:06
def main(args: Array[String]): Unit = {
    //1.在声明变量时匹配
    val (x,y)=(10,"hello")
    println(s"x: $x,y: $y")

    val List(first,second,_*) =List(23,15,9,78)
    println(s"first: $first,second: $second")

    val fir ::sec ::rest = List(23,15,9,78)
    println(s"first:$fir,second: $second,rest:$rest")

    //2.for推导式种进行模式匹配
    val list:List[(String,Int)]=List(("a",12),("b",35),("c",27))

    //2.1原本的遍历方式
    for (elem <-list){
      println(elem._1 + ":"+ elem._2)
    }


    //2.2将List的元素直接定义为元组,对变量赋值
    for ((word,count) <-list){//for ((word,count)<- list){println(word + ":"+count)}
      println(word + ":" +count)
    }
    //2.3可以不改变某个位置的变量,只遍历key或者value
    for ((word,_) <-list)
      println(word)

    for ((word1,count1)<-list)
      println(word1+" "+count1)
  }