当前位置:   article > 正文

小六六学大数据之 Spark(Scala)

spark scala expr

前言

文本已收录至我的GitHub仓库,欢迎Star:https://github.com/bin392328206/six-finger
种一棵树最好的时间是十年前,其次是现在

叨絮

计算引擎我们学完了一个mr,接下来看看我们的Spark

Scala 简介

Scala 是 Scalable Language 的简写,是一门多范式的编程语言 联邦理工学院洛桑(EPFL)的Martin Odersky于2001年基于Funnel的工作开始设计Scala。Funnel是把函数式编程思想和Petri网相结合的一种编程语言。Odersky先前的工作是Generic Java和javac(Sun Java编译器)。Java平台的Scala于2003年底/2004年初发布。.NET平台的Scala发布于2004年6月。该语言第二个版本,v2.0,发布于2006年3月。截至2009年9月,最新版本是版本2.7.6 。Scala 2.8预计的特性包括重写的Scala类库(Scala collections library)、方法的命名参数和默认参数、包对象(package object),以及Continuation。2009年4月,Twitter宣布他们已经把大部分后端程序从Ruby迁移到Scala,其余部分也打算要迁移。此外, Wattzon已经公开宣称,其整个平台都已经是基于Scala基础设施编写的。

Scala 特性

面向对象特性

Scala是一种纯面向对象的语言,每个值都是对象。对象的数据类型以及行为由类和特质描述。类抽象机制的扩展有两种途径:一种途径是子类继承,另一种途径是灵活的混入机制。这两种途径能避免多重继承的种种问题。

函数式编程

Scala也是一种函数式语言,其函数也能当成值来使用。Scala提供了轻量级的语法用以定义匿名函数,支持高阶函数,允许嵌套多层函数,并支持柯里化。Scala的case class及其内置的模式匹配相当于函数式编程语言中常用的代数类型。更进一步,程序员可以利用Scala的模式匹配,编写类似正则表达式的代码处理XML数据。

并发性

Scala使用Actor作为其并发模型,Actor是类似线程的实体,通过邮箱发收消息。Actor可以复用线程,因此可以在程序中可以使用数百万个Actor,而线程只能创建数千个。在2.10之后的版本中,使用Akka作为其默认Actor实现。

扩展性

Scala的设计秉承一项事实,即在实践中,某个领域特定的应用程序开发往往需要特定于该领域的语言扩展。Scala提供了许多独特的语言机制,可以以库的形式轻易无缝添加新的语言结构:

  • 任何方法可用作前缀或后缀操作符

  • 可以根据预期类型自动构造闭包。

Scala 数据类型

Scala 与 Java有着相同的数据类型,下表列出了 Scala 支持的数据类型:

Scala 变量

变量是一种使用方便的占位符,用于引用计算机内存地址,变量创建后会占用一定的内存空间。基于变量的数据类型,操作系统会进行内存分配并且决定什么将被储存在保留内存中。因此,通过给变量分配不同的数据类型,你可以在这些变量中存储整数,小数或者字母

在 Scala 中,使用关键词 "var" 声明变量,使用关键词 "val" 声明常量。其实对比Java 就是加不加final

Scala 访问修饰符

Scala 访问修饰符基本和Java的一样,分别有:private,protected,public。如果没有指定访问修饰符,默认情况下,Scala 对象的访问级别都是 public。Scala 中的 private 限定符,比 Java 更严格,在嵌套类情况下,外层类甚至不能访问被嵌套类的私有成员。

Scala 运算符

一个运算符是一个符号,用于告诉编译器来执行指定的数学运算和逻辑运算。

Scala 含有丰富的内置运算符,包括以下几种类型:

  • 算术运算符

  • 关系运算符

  • 逻辑运算符

  • 位运算符

  • 赋值运算符

基本上和Java是一致的,这边我就不一一举例了

IF 和循环

  1. object Test {
  2.    def main(args: Array[String]) {
  3.       var x = 10;
  4.       if( x < 20 ){
  5.          println("x < 20");
  6.       }
  7.    }
  8. }
  1. object Test {
  2.    def main(args: Array[String]) {
  3.       var a = 10;
  4.       // 无限循环
  5.       while( true ){
  6.          println"a 的值为 : " + a );
  7.       }
  8.    }
  9. }

也是一样的 和Java 没啥区别

Scala 方法与函数(和Java区别挺大)

Scala 有方法与函数,二者在语义上的区别很小。Scala 方法是类的一部分,而函数是一个对象可以赋值给一个变量。换句话来说在类中定义的函数即是方法。

  • Scala 中的方法跟 Java 的类似,方法是组成类的一部分。

  • Scala 中的函数则是一个完整的对象,Scala 中的函数其实就是继承了 Trait 的类的对象。

  • Scala 中使用 val 语句可以定义函数,def 语句定义方法。

  1. class Test{
  2.   def m(x: Int) = x + 3
  3.   val f = (x: Int) => x + 3
  4. }

方法声明

def functionName ([参数列表]) : [return type]

方法定义

方法定义由一个 def 关键字开始,紧接着是可选的参数列表,一个冒号 : 和方法的返回类型,一个等于号 = ,最后是方法的主体。Scala 方法定义格式如下:

  1. def functionName ([参数列表]) : [return type] = {
  2.    function body
  3.    return [expr]
  4. }

以上代码中 return type 可以是任意合法的 Scala 数据类型。参数列表中的参数可以使用逗号分隔。

  1. object add{
  2.    def addInt( a:Int, b:Int ) : Int = {
  3.       var sum:Int = 0
  4.       sum = a + b
  5.       return sum
  6.    }
  7. }

方法调用

Scala 提供了多种不同的方法调用方式:以下是调用方法的标准格式:

functionName( 参数列表 )

如果方法使用了实例的对象来调用,我们可以使用类似java的格式 (使用 . 号):

[instance.]functionName( 参数列表 )

  1. object Test {
  2.    def main(args: Array[String]) {
  3.         println"Returned Value : " + addInt(5,7) );
  4.    }
  5.    def addInt( a:Int, b:Int ) : Int = {
  6.       var sum:Int = 0
  7.       sum = a + b
  8.       return sum
  9.    }
  10. }

Scala 闭包

闭包是一个函数,返回值依赖于声明在函数外部的一个或多个变量。闭包通常来讲可以简单的认为是可以访问一个函数里面局部变量的另外一个函数。如下面这段匿名的函数:

val multiplier = (i:Int) => i * 10  

函数体内有一个变量 i,它作为函数的一个参数。如下面的另一段代码:

val multiplier = (i:Int) => i * factor

在 multiplier 中有两个变量:i 和 factor。其中的一个 i 是函数的形式参数,在 multiplier 函数被调用时,i 被赋予一个新的值。然而,factor不是形式参数,而是自由变量,考虑下面代码:

  1. var factor = 3  
  2. val multiplier = (i:Int) => i * factor  

这里我们引入一个自由变量 factor,这个变量定义在函数外面。

这样定义的函数变量 multiplier 成为一个"闭包",因为它引用到函数外面定义的变量,定义这个函数的过程是将这个自由变量捕获而构成一个封闭的函数。

  1. object Test {  
  2.    def main(args: Array[String]) {  
  3.       println"muliplier(1) value = " +  multiplier(1) )  
  4.       println"muliplier(2) value = " +  multiplier(2) )  
  5.    }  
  6.    var factor = 3  
  7.    val multiplier = (i:Int) => i * factor  
  8. }

Scala 字符串

以下实例将字符串赋值给一个常量:

  1. object Test {
  2.    val greeting: String = "Hello,World!"
  3.    def main(args: Array[String]) {
  4.       println( greeting )
  5.    }
  6. }

以上实例定义了变量 greeting,为字符串常量,它的类型为 String (java.lang.String)。在 Scala 中,字符串的类型实际上是 Java String,它本身没有 String 类。在 Scala 中,String 是一个不可变的对象,所以该对象不可被修改。这就意味着你如果修改字符串就会产生一个新的字符串对象。但其他对象,如数组就是可变的对象。接下来我们会为大家介绍常用的 java.lang.String 方法。

我们前面提到过 String 对象是不可变的,如果你需要创建一个可以修改的字符串,可以使用 String Builder 类,如下实例:

  1. object Test {
  2.    def main(args: Array[String]) {
  3.       val buf = new StringBuilder;
  4.       buf += 'a'
  5.       buf ++= "bcdef"
  6.       println"buf is : " + buf.toString );
  7.    }
  8. }

具体的String的方法,大家自己去看看,这边不一一列举了

Scala 数组

Scala 语言中提供的数组是用来存储固定大小的同类型元素,数组对于每一门编辑应语言来说都是重要的数据结构之一。声明数组变量并不是声明 number0、number1、...、number99 一个个单独的变量,而是声明一个就像 numbers 这样的变量,然后使用 numbers[0]、numbers[1]、...、numbers[99] 来表示一个个单独的变量。数组中某个指定的元素是通过索引来访问的。数组的第一个元素索引为0,最后一个元素的索引为元素总数减1。

声明数组

以下是 Scala 数组声明的语法格式:

  1. var z:Array[String] = new Array[String](3)
  2. var z = new Array[String](3)

和Java差不多

Scala Collection

Scala提供了一套很好的集合实现,提供了一些集合类型的抽象。Scala 集合分为可变的和不可变的集合。可变集合可以在适当的地方被更新或扩展。这意味着你可以修改,添加,移除一个集合的元素。而不可变集合类,相比之下,永远不会改变。不过,你仍然可以模拟添加,移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合,同时使原来的集合不发生改变。接下来我们将为大家介绍几种常用集合类型的应用:

Scala 类和对象

类是对象的抽象,而对象是类的具体实例。类是抽象的,不占用内存,而对象是具体的,占用存储空间。类是用于创建对象的蓝图,它是一个定义包括在特定类型的对象中的方法和变量的软件模板。

我们可以使用 new 关键字来创建类的对象,实例如下:

  1. class Point(xc: Int, yc: Int) {
  2.    var x: Int = xc
  3.    var y: Int = yc
  4.    def move(dx: Int, dy: Int) {
  5.       x = x + dx
  6.       y = y + dy
  7.       println ("x 的坐标点: " + x);
  8.       println ("y 的坐标点: " + y);
  9.    }
  10. }

Scala中的类不声明为public,一个Scala源文件中可以有多个类。以上实例的类定义了两个变量 x 和 y ,一个方法:move,方法没有返回值。Scala 的类定义可以有参数,称为类参数,如上面的 xc, yc,类参数在整个类中都可以访问。接着我们可以使用 new 来实例化类,并访问类中的方法和变量:

  1. import java.io._
  2. class Point(xc: Int, yc: Int) {
  3.    var x: Int = xc
  4.    var y: Int = yc
  5.    def move(dx: Int, dy: Int) {
  6.       x = x + dx
  7.       y = y + dy
  8.       println ("x 的坐标点: " + x);
  9.       println ("y 的坐标点: " + y);
  10.    }
  11. }
  12. object Test {
  13.    def main(args: Array[String]) {
  14.       val pt = new Point(1020);
  15.       // 移到一个新的位置
  16.       pt.move(1010);
  17.    }
  18. }

Scala Trait(特征)

Scala Trait(特征) 相当于 Java 的接口,实际上它比接口还功能强大。与接口不同的是,它还可以定义属性和方法的实现。一般情况下Scala的类只能够继承单一父类,但是如果是 Trait(特征) 的话就可以继承多个,从结果来看就是实现了多重继承。Trait(特征) 定义的方式与类类似,但它使用的关键字是 trait,如下所示:

  1. trait Equal {
  2.   def isEqual(x: Any): Boolean
  3.   def isNotEqual(x: Any): Boolean = !isEqual(x)
  4. }

以上Trait(特征)由两个方法组成:isEqual 和 isNotEqual。isEqual 方法没有定义方法的实现,isNotEqual定义了方法的实现。子类继承特征可以实现未被实现的方法。所以其实 Scala Trait(特征)更像 Java 的抽象类。

以下演示了特征的完整实例:

  1. /* 文件名:Test.scala
  2.  * 
  3.  * 
  4.  */
  5. trait Equal {
  6.   def isEqual(x: Any): Boolean
  7.   def isNotEqual(x: Any): Boolean = !isEqual(x)
  8. }
  9. class Point(xc: Int, yc: Int) extends Equal {
  10.   var x: Int = xc
  11.   var y: Int = yc
  12.   def isEqual(obj: Any) =
  13.     obj.isInstanceOf[Point] &&
  14.     obj.asInstanceOf[Point].x == x
  15. }
  16. object Test {
  17.    def main(args: Array[String]) {
  18.       val p1 = new Point(23)
  19.       val p2 = new Point(24)
  20.       val p3 = new Point(33)
  21.       println(p1.isNotEqual(p2))
  22.       println(p1.isNotEqual(p3))
  23.       println(p1.isNotEqual(2))
  24.    }
  25. }

Scala 模式匹配

Scala 提供了强大的模式匹配机制,应用也非常广泛。一个模式匹配包含了一系列备选项,每个都开始于关键字 case。每个备选项都包含了一个模式及一到多个表达式。箭头符号 => 隔开了模式和表达式。

以下是一个简单的整型值模式匹配实例:

  1. object Test {
  2.    def main(args: Array[String]) {
  3.       println(matchTest(3))
  4.    }
  5.    def matchTest(x: Int): String = x match {
  6.       case 1 => "one"
  7.       case 2 => "two"
  8.       case _ => "many"
  9.    }
  10. }
  1.  scalac Test.scala 
  2. $ scala Test
  3. many

Scala 正则表达式

Scala 通过 scala.util.matching 包中的 Regex 类来支持正则表达式。以下实例演示了使用正则表达式查找单词 Scala :

  1. import scala.util.matching.Regex
  2. object Test {
  3.    def main(args: Array[String]) {
  4.       val pattern = "Scala".r
  5.       val str = "Scala is Scalable and cool"
  6.      
  7.       println(pattern findFirstIn str)
  8.    }
  9. }

Scala 异常处理

Scala 的异常处理和其它语言比如 Java 类似。Scala 的方法可以通过抛出异常的方法的方式来终止相关代码的运行,不必通过返回值。

抛出异常 Scala 抛出异常的方法和 Java一样,使用 throw 方法,例如,抛出一个新的参数异常:

throw new IllegalArgumentException

捕获异常 异常捕捉的机制与其他语言中一样,如果有异常发生,catch 字句是按次序捕捉的。因此,在 catch 字句中,越具体的异常越要靠前,越普遍的异常越靠后。如果抛出的异常不在 catch 字句中,该异常则无法处理,会被升级到调用者处。

捕捉异常的 catch 子句,语法与其他语言中不太一样。在 Scala 里,借用了模式匹配的思想来做异常的匹配,因此,在 catch 的代码里,是一系列 case 字句,如下例所示

  1. import java.io.FileReader
  2. import java.io.FileNotFoundException
  3. import java.io.IOException
  4. object Test {
  5.    def main(args: Array[String]) {
  6.       try {
  7.          val f = new FileReader("input.txt")
  8.       } catch {
  9.          case ex: FileNotFoundException =>{
  10.             println("Missing file exception")
  11.          }
  12.          case ex: IOException => {
  13.             println("IO Exception")
  14.          }
  15.       }
  16.    }
  17. }

catch字句里的内容跟match里的case是完全一样的。由于异常捕捉是按次序,如果最普遍的异常,Throwable,写在最前面,则在它后面的case都捕捉不到,因此需要将它写在最后面。

finally 语句 finally 语句用于执行不管是正常处理还是有异常发生时都需要执行的步骤,实例如下:

  1. import java.io.FileReader
  2. import java.io.FileNotFoundException
  3. import java.io.IOException
  4. object Test {
  5.    def main(args: Array[String]) {
  6.       try {
  7.          val f = new FileReader("input.txt")
  8.       } catch {
  9.          case ex: FileNotFoundException => {
  10.             println("Missing file exception")
  11.          }
  12.          case ex: IOException => {
  13.             println("IO Exception")
  14.          }
  15.       } finally {
  16.          println("Exiting finally...")
  17.       }
  18.    }
  19. }

Scala 提取器(Extractor)

提取器是从传递给它的对象中提取出构造该对象的参数。Scala 标准库包含了一些预定义的提取器,我们会大致的了解一下它们。Scala 提取器是一个带有unapply方法的对象。unapply方法算是apply方法的反向操作:unapply接受一个对象,然后从对象中提取值,提取的值通常是用来构造该对象的值。

以下实例演示了邮件地址的提取器对象:

  1. object Test {
  2.    def main(args: Array[String]) {
  3.      
  4.       println ("Apply 方法 : " + apply("Zara""gmail.com"));
  5.       println ("Unapply 方法 : " + unapply("Zara@gmail.com"));
  6.       println ("Unapply 方法 : " + unapply("Zara Ali"));
  7.    }
  8.    // 注入方法 (可选)
  9.    def apply(user: String, domain: String) = {
  10.       user +"@"+ domain
  11.    }
  12.    // 提取方法(必选)
  13.    def unapply(str: String): Option[(String, String)] = {
  14.       val parts = str split "@"
  15.       if (parts.length == 2){
  16.          Some(parts(0), parts(1))
  17.       }else{
  18.          None
  19.       }
  20.    }
  21. }

结尾

Scala入门,最近写的都没几个人看了,但是还是得按照自己的学习过程去写吧,加油吧!骚年!!!

日常求赞

好了各位,以上就是这篇文章的全部内容了,能看到这里的人呀,都是真粉。

创作不易,各位的支持和认可,就是我创作的最大动力,我们下篇文章见

微信 搜 "六脉神剑的程序人生" 回复888 有我找的许多的资料送给大家

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/盐析白兔/article/detail/864511
推荐阅读
相关标签
  

闽ICP备14008679号