大数据系列修炼-Scala课程06

关于Scala中的正则表达式与模式匹配结合的正则表达式Reg

正则表达式的实现：正则表达式的定义与其它语言差不多，只需在表达式后加一个.r,并且可以遍历相应的表达式进行匹配

    //定义的正则表达式
    val regex="""([0-9]+) ([a-z]+)""".r //由数字与字母组成的常量
    val numPattern = "[0-9]+".r //由数字组成的常量
    val numberPattern = """s+[0-9]+s+""".r //由s与数字+s组成的正则表达式
    println(regex);
    // findAllIn方法返回遍历所有匹配项的迭代器
    for (matchString <- numPattern.findAllIn("99345 Scala, 22298 Spark")) println(matchString)
    // 找到首个匹配项
    println(numberPattern.findFirstIn("99ss java, 222 hadoop"))

与模式匹配结合的Reg实现:在今后可能会经常使用正则表达式与模式匹配进行组合

 //正则表达式与模式匹配结合
    val numitemPattern="""([0-9]+) ([a-z]+)""".r //正则表达式
    val numitemPattern(num, item) = "99 hadoop" //规定模式
    val line = "93459 spark"
    line match{
      case numitemPattern(num, blog) => println(num + "	" + blog)
      case _ => println("Oops...")
    }

Scala中本地函数与一等公民函数

本地函数实现：就是函数中包括函数，这样使函数更加安全。

  //本地函数 就是函数中包含函数 这样就可以使里面的函数使用外面函数的参数
def processData(filename: String,  Int) {
    def processLine(line: String) {
      if (line.length > width)
        println(filename +": "+ line)
    }
    val source = Source.fromFile(filename)
    for (line <- source.getLines)
      processLine(line)
  }
}

作为一等公民函数实现;能让函数表示式能够更加方便的在编程中使用

  //一等公民函数
   def main(args: Array[String]): Unit = {
     //启动项中设置的参数
    val width = args(0).toInt
    for (arg <- args.drop(1))
      processData(arg, width)
      var increase = (x: Int) => x + 1
      println(increase(10))
      increase = (x: Int) => x + 9999
      val someNumbers = List(-11, -10, -5, 0, 5, 10)
      //遍历数组
      someNumbers.foreach((x: Int) => print (x))
      println
      //过滤大于0
      someNumbers.filter((x: Int) => x > 0).foreach((x: Int) => print (x))
       println
       //过滤大于0
      someNumbers.filter((x) => x > 0).foreach((x: Int) => print (x))
       println
       //过滤大于0
      someNumbers.filter(x => x > 0).foreach((x: Int) => print (x))
       println
       //过滤大于0
      someNumbers.filter(_ > 0).foreach((x: Int) => print (x))
       println
       //定义两个数字相加
      val f = (_: Int) + (_: Int)
      println(f(5, 10))

   }

Scala中偏函数讲解

偏函数实现：偏函数能够让表达式更加简洁，没有必要写多余的参数

偏函数解析：偏函数实现的时候会生成对于的apply函数来进行相应的操作

    val data = List(1, 2, 3, 4, 5, 6)
    //使用偏函数来遍历list 使用空格+_
    data.foreach(println _)
    data.foreach(x => println(x))
    def sum(a: Int, b: Int, c: Int) = a + b + c
    println(sum(1, 2, 3))
    val fp_a = sum _
    //直接调用定义sum函数 ，调用它相应的apply函数
    println(fp_a(1, 2, 3))
    println(fp_a.apply(1, 2, 3))
    val fp_b = sum(1, _: Int, 3)
    println(fp_b(2))
    println(fp_b(10))
    data.foreach(println _)
    data.foreach(println)

Scala中关于闭包讲解

Scala闭包解析：让函数体用简单的表达式来实现冗余的事情

Scala闭包实现

    def main(args: Array[String]) {
        
    val data = List(1, 2, 3, 4, 5, 6)
    var sum = 0
    data.foreach(sum += _)
    def add(more: Int) = (x: Int) => x + more
    val a = add(1)
    val b = add(9999)
    println(a(10))
    
    println(b(10)

 Scala的函数式编程真的是博大精深啊，很多东西都被他的底层所实现了，这让我们在使用过程中能更加简洁了。今天就到这儿

欢迎大家观看 王家林老师的大数据相关视频....

王家林微信号：18610086859

最新视频72讲：http://pan.baidu.com/s/1qWsq6Jy

该博客的视频19-22讲：http://pan.baidu.com/s/1o63QbPo