Spark学习之scala编程

Scala语言基础

1、Scala语言简介

Scala是一种多范式的编程语言,其设计的初衷是要集成面向对象编程和函数式编程的各种特性。Scala运行于Java平台(Java虚拟机),并兼容现有的Java程序。

学习Scala编程语言,为后续学习Spark奠定基础。

2、为什么要学Scala

l 优雅:这是框架设计师第一个要考虑的问题,框架的用户是应用开发程序员,API是否优雅直接影响用户体验。

l 速度快:Scala语言表达能力强,一行代码抵得上Java多行,开发速度快;Scala是静态编译的,所以和JRuby,Groovy比起来速度会快很多。

l  能融合到Hadoop生态圈:Hadoop现在是大数据事实标准,Spark并不是要取代Hadoop,而是要完善Hadoop生态。JVM语言大部分可能会想到Java,但Java做出来的API太丑,或者想实现一个优雅的API太费劲。

l 德国的一位资深Java专家Adam Bien在参加JavaOne 2008大会(他在会上有一个技术讲座)期间,亲耳听到,有人问Java之父James Gosling“除了Java之外,你现在最希望在JVM上使用什么语言?”的时候,他出人意料的回答:“Scala!”几乎是脱口而出。

3、安装JDK

因为Scala是运行在JVM平台上的,所以安装Scala之前要安装JDK,安装JDK1.8版本

4、下载和安装Scala

① Windows安装Scala编译器

访问Scala官网http://www.scala-lang.org/下载Scala编译器安装包,目前最新版本是2.12.x,但是目前大多数的框架都是用2.11.x编写开发的,Spark2.x使用的就是2.11.x,所以这里推荐2.11.x版本,下载scala-2.11.12.msi后点击下一步就可以了

1) 安装JDK

2) 下载Scala:http://www.scala-lang.org/download/

3) 安装Scala:

设置环境变量:SCALA_HOME和PATH路径

4) 验证Scala

② Linux安装Scala编译器

下载Scala地址http://downloads.typesafe.com/scala/2.11.12/scala-2.11.12.tgz然后解压Scala到指定目录

tar -zxvf scala-2.11.12.tgz -C /usr/java

配置环境变量,将scala加入到PATH中

vi /etc/profile

export JAVA_HOME=/usr/java/jdk1.8.0_111

export PATH=$PATH:$JAVA_HOME/bin:/usr/java/scala-2.11.12/bin

5、Scala的运行环境

l REPL(Read Evaluate Print Loop):命令行

l IDE:图形开发工具

n The Scala IDE (Based on Eclipse):http://scala-ide.org/

n IntelliJ IDEA with Scala plugin:http://www.jetbrains.com/idea/download/

n Netbeans IDE with the Scala plugin

6、Scala开发工具安装(IDEA)

由于IDEA的Scala插件更优秀,大多数Scala程序员都选择IDEA,可以到http://www.jetbrains.com/idea/download/下载社区免费版,点击下一步安装即可,安装时如果有网络可以选择在线安装Scala插件。这里我们使用离线安装Scala插件:

l 安装IDEA,点击下一步即可。由于我们离线安装插件,所以点击Skip All and Set Defaul

l 下载IEDA的scala插件,地址http://plugins.jetbrains.com/plugin/1347-scala

1.安装Scala插件:Configure -> Plugins -> Install plugin from disk -> 选择Scala插件 -> OK -> 重启IDEA

7、Scala的常用数据类型

注意:在Scala中,任何数据都是对象。例如:

③ 数值类型:Byte,Short,Int,Long,Float,Double

l Byte:  8位有符号数字,从-128 到 127

l Short: 16位有符号数据,从-32768 到 32767

l Int:  32位有符号数据

l Long: 64位有符号数据

例如:

val a:Byte = 10

a+10

得到:res9: Int = 20

这里的res9是新生成变量的名字

val b:Short = 20

a+b

注意:在Scala中,定义变量可以不指定类型,因为Scala会进行类型的自动推导。

④ 字符类型和字符串类型:Char和String

对于字符串,在Scala中可以进行插值操作。

注意:前面有个s;相当于执行:"My Name is " + s1

⑤ Unit类型:相当于Java中的void类型

⑥ Nothing类型:一般表示在执行过程中,产生了Exception

例如,我们定义一个函数如下:

8、Scala变量的申明和使用

l 使用val和var申明变量

例如:scala> val answer = 8 * 3 + 2

可以在后续表达式中使用这些名称

l val:value 简写,表示的意思为值,不可变

要申明其值可变的变量:val

l var:variable 简写,表示的变量,可以改变值

要申明其值不可变的变量:var

l 例子



object VariableTest {
  def main(args: Array[String]) {
    //使用val定义的变量值是不可变的,相当于java里用final修饰的变量
    val i = 1
    //使用var定义的变量是可变得,在Scala中鼓励使用val
    var s = "hello"
    //Scala编译器会自动推断变量的类型,必要的时候可以指定类型

    //变量名在前,类型在后
    val str: String = "world"
  }
}

注意:可以不用显式指定变量的类型,Scala会进行自动的类型推到

9、Scala的条件表达式

Scala的if/else语法结构和Java或C++一样。

不过,在Scala中,if/else是表达式,有值,这个值就是跟在if或else之后的表达式的值。

  • Scala的的条件表达式比较简洁,例如:


object ConditionTest {
  def main(args: Array[String]) {
    val x = 1
    //判断x的值,将结果赋给y
    val y = if (x > 0) 1 else -1
    //打印y的值
    println(y)

//支持混合类型表达式
    val z = if (x > 1) 1 else "error"
    //打印z的值
    println(z)

//如果缺失else,相当于if (x > 2) 1 else ()
    val m = if (x > 2) 1
    println(m)

//在scala中每个表达式都有值,scala中有个Unit类,写做(),相当于Java中的void
    val n = if (x > 2) 1 else ()
    println(n)

//if和else if
    val k = if (x < 0) 0
    else if (x >= 1) 1 else -1
    println(k)
  }
}

10、块表达式



object BlockExpressionTest {
  def main(args: Array[String]) {
    val x = 0
    //在scala中{}中课包含一系列表达式,块中最后一个表达式的值就是块的值
    //下面就是一个块表达式
    val result = {
      if (x < 0){
        -1
      } else if(x >= 1) {
        1
      } else {
        "error"
      }
    }
    //result的值就是块表达式的结果
    println(result)
  }
}

11、Scala的循环

Scala拥有与Java和C++相同的while和do循环

Scala中,可以使用for和foreach进行迭代

  • 使用for循环案例:

注意:

(*) <-  表示Scala中的generator,即:提取符

(*)第三种写法是第二种写法的简写

  • 在for循环中,还可以使用yield关键字来产生一个新的集合

在上面的案例中,我们将list集合中的每个元素转换成了大写,并且使用yield关键字生成了一个新的集合。

  • 使用while循环:注意使用小括号,不是中括号

  • 使用do ... while循环

  • 使用foreach进行迭代

注意:在上面的例子中,foreach接收了另一个函数(println)作为值

12、Scala的Lazy值(懒值)

当val被申明为lazy时,它的初始化将被推迟,直到我们首次对它取值。

一个更为复杂一点的例子:读取文件:

13、异常的处理

Scala异常的工作机制和Java或者C++一样。直接使用throw关键字抛出异常。

使用try...catch...finally来捕获和处理异常:

14、Scala中的数组

Scala数组的类型:

l 定长数组:使用关键字Array

l 变长数组:使用关键字ArrayBuffer

l 遍历数组

l Scala数组的常用操作

l Scala的多维数组

l 和Java一样,多维数组是通过数组的数组来实现的。

l 也可以创建不规则的数组,每一行的长度各不相同。

二、数组、映射、元组

1、 数组

① 定长数组和变长数组


import scala.collection.mutable.ArrayBuffer


object ArrayTest {

def main(args: Array[String]) {

//初始化一个长度为8的定长数组,其所有元素均为0
    val arr1 = new Array[Int](8)
    //直接打印定长数组,内容为数组的hashcode值
    println(arr1)
    //将数组转换成数组缓冲,就可以看到原数组中的内容了
    //toBuffer会将数组转换长数组缓冲
    println(arr1.toBuffer)

//注意:如果new,相当于调用了数组的apply方法,直接为数组赋值
    //初始化一个长度为1的定长数组
    val arr2 = Array[Int](10)
    println(arr2.toBuffer)

//定义一个长度为3的定长数组
    val arr3 = Array("hadoop", "storm", "spark")
    //使用()来访问元素
    println(arr3(2))

//////////////////////////////////////////////////
    //变长数组(数组缓冲)
    //如果想使用数组缓冲,需要导入import scala.collection.mutable.ArrayBuffer包
    val ab = ArrayBuffer[Int]()
    //向数组缓冲的尾部追加一个元素
    //+=尾部追加元素
    ab += 1
    //追加多个元素
    ab += (2, 3, 4, 5)
    //追加一个数组++=
    ab ++= Array(6, 7)
    //追加一个数组缓冲
    ab ++= ArrayBuffer(8,9)
    //打印数组缓冲ab

    //在数组某个位置插入元素用insert
    ab.insert(0, -1, 0)
    //删除数组某个位置的元素用remove
    ab.remove(8, 2)
    println(ab)

}
}

② 遍历数组

  • 增强for循环
  • 好用的until会生成脚标,0 until 10 包含0不包含10

 


object ForArrayTest {

def main(args: Array[String]) {
    //初始化一个数组
    val arr = Array(1,2,3,4,5,6,7,8)
    //增强for循环
    for(i <- arr)
      println(i)

//好用的until会生成一个Range
    //reverse是将前面生成的Range反转
    for(i <- (0 until arr.length).reverse)
      println(arr(i))
  }
}

 

③ 数组转换

yield关键字将原始的数组进行转换会产生一个新的数组,原始的数组不变



object ArrayYieldTest {
  def main(args: Array[String]) {
    //定义一个数组
    val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
    //将偶数取出乘以10后再生成一个新的数组
    val res = for (e <- arr if e % 2 == 0) yield e * 10
    println(res.toBuffer)

//更高级的写法,用着更爽
    //filter是过滤,接收一个返回值为boolean的函数
    //map相当于将数组中的每一个元素取出来,应用传进去的函数
    val r = arr.filter(_ % 2 == 0).map(_ * 10)
    println(r.toBuffer)

}
}

④ 数组常用算法

在Scala中,数组上的某些方法对数组进行相应的操作非常方便!

2、 映射

在Scala中,把哈希表这种数据结构叫做映射

① 构建映射

② 获取和修改映射中的值

好用的getOrElse

注意:在Scala中,有两种Map,一个是immutable包下的Map,该Map中的内容不可变;另一个是mutable包下的Map,该Map中的内容可变

例子:

注意:通常我们在创建一个集合是会用val这个关键字修饰一个变量(相当于java中的final),那么就意味着该变量的引用不可变,该引用中的内容是不是可变,取决于这个引用指向的集合的类型

例子:如下这段超简单的循环即可遍历映射中所有的键/值对偶

3、 元组

映射是K/V对偶的集合,对偶是元组的最简单形式,元组可以装着多个不同类型的值。

① 创建元组

② 获取元组中的值

③ 将对偶的集合转换成映射

④ 拉链操作

zip命令可以将多个值绑定在一起

注意:如果两个数组的元素个数不一致,拉链操作后生成的数组的长度为较小的那个数组的元素个数

三、Scala语言的函数式编程

4、 调用方法和函数

Scala中的+ - * / %等操作符的作用与Java一样,位操作符 & | ^ >> <<也一样。只是有

一点特别的:这些操作符实际上是方法。例如:

a + b

是如下方法调用的简写:

a.+(b)

a 方法 b可以写成 a.方法(b)

5、 定义方法和函数

① 定义方法

方法的返回值类型可以不写,编译器可以自动推断出来,但是对于递归方法,必须指定返回类型

② 定义函数

③ 方法和函数的区别

在函数式编程语言中,函数是“头等公民”,它可以像任何其他数据类型一样被传递和操作

案例:首先定义一个方法,再定义一个函数,然后将函数传递到方法里面



object MethodAndFunctionTest {
  //定义一个方法
  //方法m2参数要求是一个函数,函数的参数必须是两个Int类型

  //返回值类型也是Int类型
  def m1(f: (Int, Int) => Int) : Int = {
    f(2, 6)
  }

//定义一个函数f1,参数是两个Int类型,返回值是一个Int类型
  val f1 = (x: Int, y: Int) => x + y
  //再定义一个函数f2
  val f2 = (m: Int, n: Int) => m * n

//main方法
  def main(args: Array[String]) {

//调用m1方法,并传入f1函数
    val r1 = m1(f1)
    println(r1)

//调用m1方法,并传入f2函数
    val r2 = m1(f2)
    println(r2)
  }
}

④ 将方法转换成函数(神奇的下划线)

6、 Scala的函数和方法的使用

l 可以使用Scala的预定义函数

例如:求两个值的最大值

l 也可以使用def关键字自定义函数

语法:

示例:

7、 Scala函数的求值策略

  • Scala中,有两种函数参数的求值策略

l Call By Value:对函数实参求值,且仅求一次

l Call By Name:函数实参每次在函数体内被用到时都会求值

我们来分析一下,上面两个调用执行的过程:

一份复杂一点的例子:

  • Scala中的函数参数

l 默认参数

l 代名参数

l 可变参数

8、 Scala中的函数

在Scala中,函数是“头等公民”,就和数字一样。可以在变量中存放函数,即:将函数作为变量的值(值函数)

9、 匿名函数

10、 带函数参数的函数,即:高阶函数

示例1:

(*)首先,定义一个最普通的函数

(*)再定义一个高阶函数

(*)分析这个高阶函数调用的过程 

示例2:

在这个例子中,首先定义了一个普通的函数mytest,然后定义了一个高阶函数myFunction;myFunction接收三个参数:第一个f是一个函数参数,第二个是x,第三个是y。而f是一个函数参数,本身接收两个Int的参数,返回一个Int的值。

11、 闭包

就是函数的嵌套,即:在一个函数定义中,包含另外一个函数的定义;并且在内函数中可以访问外函数中的变量

测试上面的函数:

12、 柯里化:Currying

柯里化函数(Curried Function)是把具有多个参数的函数转换为一条函数链,每个节点上是单一参数。

一个简单的例子:

13、 高阶函数示例

示例1:

示例2 

示例3 

示例4 

示例5 

在这个例子中,可以被2整除的被分到一个分区;不能被2整除的被分到另一个分区。

示例6 

示例7  

示例8 

在这个例子中,分为两步:

(1)将(1,2,3)和(4,5,6)这两个集合合并成一个集合

(2)再对每个元素乘以2

三、Scala语言的面向对象

1、 面向对象的基本概念

把数据及对数据的操作方法放在一起,作为一个相互依存的整体——对象

面向对象的三大特征:

  封装

  继承

  多态

2、 类的定义

简单类和无参方法:

案例:注意没有class前面没有public关键字修饰。

如果要开发main方法,需要将main方法定义在该类的伴生对象中,即:object对象中,(后续做详细的讨论)。

3、 属性的getter和setter方法

l 当定义属性是private时候,scala会自动为其生成对应的get和set方法

private var stuName:String = "Tom"

  • get方法: stuName    ----> s2.stuName() 由于stuName是方法的名字,所以可以加上一个括号
  • set方法: stuName_=  ----> stuName_= 是方法的名字

l 定义属性:private var money:Int = 1000 希望money只有get方法,没有set方法??

  • 办法:将其定义为常量private val money:Int = 1000

l  private[this]的用法:该属性只属于该对象私有,就不会生成对应的set和get方法。如果这样,就不能直接调用,例如:s1.stuName ---> 错误

4、 内部类(嵌套类)

我们可以在一个类的内部在定义一个类,如下:我们在Student类中,再定义了一个Course类用于保存学生选修的课程。

开发一个测试程序进行测试:

5、 类的构造器

类的构造器分为:主构造器、辅助构造器

l 主构造器:和类的声明结合在一起,只能有一个主构造器

Student4(val stuName:String,val stuAge:Int)

(1) 定义类的主构造器:两个参数

(2) 声明了两个属性:stuName和stuAge 和对应的get和set方法

l 辅助构造器:可以有多个辅助构造器,通过关键字this来实现

6、 Scala中的Object对象

Scala没有静态的修饰符,但Object对象下的成员都是静态的 ,若有同名的class,这其作为它的伴生类。在Object中一般可以为伴生类做一些初始化等操作。

下面是Java中的静态块的例子。在这个例子中,我们对JDBC进行了初始化。

而Scala中的Object就相当于Java中静态块。

Object对象的应用

  单例对象

  使用应用程序对象:可以省略main方法;需要从父类App继承。

7、 Scala中的apply方法

遇到如下形式的表达式时,apply方法就会被调用:

Object(参数1,参数2,......,参数N)

通常,这样一个apply方法返回的是伴生类的对象;其作用是为了省略new 关键字

Object的apply方法举例:

8、 Scala中的继承

Scala和Java一样,使用extends关键字扩展类。

l 案例一:Employee类继承Person类

l 案例二:在子类中重写父类的方法

l 案例三:使用匿名子类

l 案例四:使用抽象类。抽象类中包含抽象方法,抽象类只能用来继承。

l 案例五:使用抽象字段。抽象字段就是一个没有初始值的字段

9、 Scala中的trait(特质)

trait就是抽象类。trait跟抽象类最大的区别:trait支持多重继承

10、 包的使用

Scala的包和Java中的包或者C++中的命名空间的目的是相同的:管理大型程序中的名称。

Scala中包的定义和使用:

  包的定义

  包的引入:Scala中依然使用import作为引用包的关键字,例如

  而且Scala中的import可以写在任意地方

11、 包对象

包可以包含类、对象和特质,但不能包含函数或者变量的定义。很不幸,这是Java虚拟机的局限。

把工具函数或者常量添加到包而不是某个Utils对象,这是更加合理的做法。Scala中,包对象的出现正是为了解决这个局限。

Scala中的包对象:常量,变量,方法,类,对象,trait(特质)

12、 Scala中的文件访问

l  读取行

l  读取字符

其实这里的source就指向了这个文件中的每个字符。

从URL或其他源读取:注意指定字符集UTF-8

读取二进制文件:Scala中并不支持直接读取二进制,但可以通过调用Java的InputStream来进行读入。

写入文本文件

四、Scala中的集合

Scala的集合有三大类:序列Seq、集Set、映射Map,所有的集合都扩展自Iterable特质

在Scala中集合有可变(mutable)和不可变(immutable)两种类型,immutable类型的集合初始化后就不能改变了(注意与val修饰的变量进行区别)

1、 可变集合和不可变集合

l 可变集合

l 不可变集合:

  集合从不改变,因此可以安全地共享其引用。

  甚至是在一个多线程的应用程序当中也没问题。

集合的操作:

2、 列表

l 不可变列表(List)

不可变列表的相关操作:

l 可变列表(LinkedList):scala.collection.mutable

3、 序列

常用的序列有:Vector和Range

  Vector是ArrayBuffer的不可变版本,是一个带下标的序列

  Range表示一个整数序列

4、 集(Set)和集的操作

l 集Set是不重复元素的集合

l 和列表不同,集并不保留元素插入的顺序。默认以Hash集实现

示例1:创建集

示例2 :集的操作

5、 模式匹配

Scala有一个强大的模式匹配机制,可以应用在很多场合:

  switch语句

  类型检查

Scala还提供了样本类(case class),对模式匹配进行了优化

模式匹配示例:

l 更好的switch

l Scala的守卫

l 模式匹配中的变量

l 类型模式

l 匹配数组和列表

6、 样本类(CaseClass)

简单的来说,Scala的case class就是在普通的类定义前加case这个关键字,然后你可以对这些类来模式匹配。

case class带来的最大的好处是它们支持模式识别。

首先,回顾一下前面的模式匹配:

其次,如果我们想判断一个对象是否是某个类的对象,跟Java一样可以使用isInstanceOf

最后,在Scala中有一种更简单的方式来判断,就是case class

注意:需要在class前面使用case关键字。

 

 

五、Scala语言的高级特性

1、 什么是泛型类

和Java或者C++一样,类和特质可以带类型参数。在Scala中,使用方括号来定义类型参数

测试程序:

2、 什么是泛型函数

函数和方法也可以带类型参数。和泛型类一样,我们需要把类型参数放在方法名之后。

注意:这里的ClassTag是必须的,表示运行时的一些信息,比如类型。

3、 Upper Bounds 与 Lower Bounds

类型的上界和下界,是用来定义类型变量的范围。它们的含义如下:

  S <: T

这是类型上界的定义。也就是S必须是类型T的子类(或本身,自己也可以认为是自己的子类。

  U >: T

这是类型下界的定义。也就是U必须是类型T的父类(或本身,自己也可以认为是自己的父类)。

l 一个简单的例子:

l 一个复杂一点的例子(上界):

l 再来看一个例子:

4、 视图界定(View bounds)

它比 <: 适用的范围更广,除了所有的子类型,还允许隐式转换过去的类型。用 <% 表示。尽量使用视图界定,来取代泛型的上界,因为适用的范围更加广泛。

示例:

l 上面写过的一个列子。这里由于T的上界是String,当我们传递100和200的时候,就会出现类型不匹配。

l 但是100和200是可以转成字符串的,所以我们可以使用视图界定让addTwoString方法接收更广泛的数据类型,即:字符串及其子类、可以转换成字符串的类型

注意:使用的是 <% 

l 但实际运行的时候,会出现错误:

这是因为:Scala并没有定义如何将Int转换成String的规则,所以要使用视图界定,我们就必须创建转换的规则。

l 创建转换规则

l 运行成功

5、 协变和逆变

l 协变:

Scala的类或特征的范型定义中,如果在类型参数前面加入+符号,就可以使类或特征变为协变了。

  逆变:

在类或特征的定义中,在类型参数之前加上一个-符号,就可定义逆变范型类和特征了。

总结一下:Scala的协变:泛型变量的值可以是本身类型或者其子类的类型

Scala的逆变:泛型变量的值可以是本身类型或者其父类的类型

6、 隐式转换函数

所谓隐式转换函数指的是以implicit关键字申明的带有单个参数的函数。

l 前面讲视图界定时候的一个例子:

l 再举一个例子:我们把Fruit对象转换成了Monkey对象

7、 隐式参数

使用implicit申明的函数参数叫做隐式参数。我们也可以使用隐式参数实现隐式的转换

8、 隐式类

所谓隐式类: 就是对类增加implicit 限定的类,其作用主要是对类的功能加强

原文地址:https://www.cnblogs.com/lq0310/p/9840317.html

时间: 2024-10-29 16:17:09

Spark学习之scala编程的相关文章

大数据Spark学习:Scala基础第一课

计划: 阶段1: 精通Spark内核 阶段2: 精通千万级的项目 阶段3: 机器学习 JAVA本身不是伟大的语言,伟大的是JVM,构件分布式平台什么的,依赖的是JVM,不一定要JAVA语言 可认为Scala是JAVA的升级语言,JAVA是支持面向对象的语言,而非纯面向对象的语言.Scala是一切皆对象, 是纯面向对象语言.面向对象结合函数式编程. 不可变变量声明val result = 10+2  不可再次赋值,分布式数据的时候,传输数据.校验数据等不想改变这个数据 可变变量var name =

2020寒假学习01 Scala 编程初级实践

1. 计算级数请用脚本的方式编程计算并输出下列级数的前 n 项之和 Sn,直到 Sn 刚好大于或等于 q为止,其中 q 为大于 0 的整数,其值通过键盘输入. Sn = 2/1+3/2+4/3+......+n+1/n 例如,若 q 的值为 50.0,则输出应为:Sn=50.416695.请将源文件保存为exercise2-1.scala,在REPL模式下测试运行,测试样例:q=1时,Sn=2:q=30时,Sn=30.891459:q=50 时,Sn=50.416695. object test

初解,Scala语言中基于Actor的并发编程的机制,并展示了在Spark中基于Scala语言的Actor而产生的消息驱动框架Akka的使用,

Scala深入浅出实战中级--进阶经典(第66讲:Scala并发编程实战初体验及其在Spark源码中应用解析)内容介绍和视频链接 2015-07-24 DT大数据梦工厂 从明天起,做一个勤奋的人 看视频.下视频,分享视频 DT大数据梦工厂-Scala深入浅出实战中级--进阶经典:第66讲:Scala并发编程实战初体验及其在Spark源码中的应用解析 本期视频通过代码实战详解了Java语言基于加锁的并发编程模型的弊端以及Scala语言中基于Actor的并发编程的机制,并展示了在Spark中基于Sc

(升级版)Spark从入门到精通(Scala编程、案例实战、高级特性、Spark内核源码剖析、Hadoop高端)

本课程主要讲解目前大数据领域最热门.最火爆.最有前景的技术——Spark.在本课程中,会从浅入深,基于大量案例实战,深度剖析和讲解Spark,并且会包含完全从企业真实复杂业务需求中抽取出的案例实战.课程会涵盖Scala编程详解.Spark核心编程.Spark SQL和Spark Streaming.Spark内核以及源码剖析.性能调优.企业级案例实战等部分.完全从零起步,让学员可以一站式精通Spark企业级大数据开发,提升自己的职场竞争力,实现更好的升职或者跳槽,或者从j2ee等传统软件开发工程

大数据学习:Scala面向对象和Spark一些代码读和问

画外音: Spark对面向对象的支持是非常完美的 主题: 1.简单的类: 2.重写getter.setter方法: 3.利用其它方法来控制外部对值的控制: 4. private[this]: 5.构造器以及构造器相关: 直接代码见真章: ==========最简单的类============ scala> class HiScala{ | private var name = "Spark" | def sayName(){println(name)} | def getName

大数据学习:Scala隐式转换和并发编程(DT大数据梦工厂)

很多Spark代码中使用了隐式转换.隐式参数.隐式类.隐式对象 如果不掌握,基本在读写复杂代码的时候读不懂 并发编程,怎么样进行高效并发,相互之间怎么通信,Spark这种分布式并发肯定非常重要 (Actor.Akka) ==========隐式转换函数============ 可以手动指定将某种类型的对象转换成其它类型的对象或者类 转换原因:假设制定好接口 比如File,我们想要File.dtSpark的方法,在JAVA中不行 如果在Scala里面我们可以进行升级,将File编程其它类型,就用之

Spark入门到精通--(第二节)Scala编程详解基础语法

Scala是什么? Scala是以实现scaleable language为初衷设计出来的一门语言.官方中,称它是object-oriented language和functional language的混合式语言. Scala可以和java程序无缝拼接,因为scala文件编译后也是成为.class文件,并且在JVM上运行. Spark是由Scala进行开发的. Scala安装? 这里就讲一下Scala在Centos上进行安装的过程,和安装JDK差不多. 官网下载Scala:http://www

下载20小时玩转Scala编程(Spark必备)

20课下载地址:http://pan.baidu.com/s/1nuV8NnN现200转让了,联系QQ:380539674本课程紧抓重点.言简意赅.深入浅出的讲解Scala编程,旨在学员能快速上手并灵活掌握. 课程以实操为主,提供完整详细的源码,供学员学习或应用到项目中.课程的课件也很详细, 在学员不方便看视频的时候直接看课件并结合源码,同样可以达到很好的学习效果,并能大幅节省学习时间.第一讲.Scala环境和IDE使用,数据类型第二讲.控制语句,if.while.for.foreach使用第三

20小时玩转Scala编程(Spark必备)

网盘地址:https://pan.baidu.com/s/1NdFAD5K3XkoWAzo0uWDqtQ 提取码: 7k7j 本课程紧抓重点.言简意赅.深入浅出的讲解Scala编程,旨在学员能快速上手并灵活掌握. 课程以实操为主,提供完整详细的源码,供学员学习或应用到项目中.课程的课件也很详细,在学员不方便看视频的时候直接看课件并结合源码,同样可以达到很好的学习效果,并能大幅节省学习时间. 课程大纲: 第一讲.Scala环境和IDE使用,数据类型第二讲.控制语句,if.while.for.for