关于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 + "\t" + blog)
case _ => println("Oops...")
}
Scala中本地函数与一等公民函数
本地函数实现：就是函数中包括函数，这样使函数更加安全。
//本地函数 就是函数中包含函数 这样就可以使里面的函数使用外面函数的参数
def processData(filename: String, width: 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