大数据技术Spark基础实验指导书

实验一Scala部署及基本语法4

1.安装Scala6

1.1进入安装目录6

2.Scala基础7

2.1基础语法7

2.2控制结构12

实验二Scala数据结构13

3.Scala数据结构15

3.1列表15

3.2集合15

3.3映射（Map）16

3.4迭代器18

实验三Scala类和又蝮21

4.类23

4.1简单的类23

5.对象27

5.1单例对象27

5.2伴生对象28

5.3应用程序对象30

实验四Scala函级编程WordCount31

6.实验操作32

6.1创建需要统计的目录32

实验五spark安装部署34

1、检查环境hadoop集群环境35

2、Spark部署36

3、启动spark集群48

实验六SparkRDD编程50

l.RDD编程51

实验七Spark单词统计实验53

2、检查hadoop集群环境54

2、创建项目55

2.1创建javamaven项目56

2.2更改JDK版本60

2.3配置pom.xml文件63

2.4创建SparkWordCount类70

4、打包项目75

5、运行打包好的jar程序81

5.1运行程序81

实验八SparkHbase读写实验82

1、检查hadoop集群环境84

2、Hbase创建studen表85

2.1进入hbase环境85

2.2查看表是否存在86

2.3创建student表86

2.4往表里插入数据87

2.5使用scan命令查看表结构88

3、创建项目88

3.1创建javamaven项目89

3.2更改JDK版本93

3.3配置pom.xml文件96

4、创建Scalajar包104

5、Spark运行打包好的jar文件107

6、java代码和配置文件（附）110

实验九Sparkstream实验116

1.实验准备117

2.创建Scalajar包118

2.1创建Scala项目118

2.2把scala项目Maven管理118

3.Spark运行打包好的jar文件121

4.java代码和配置文件（附）123

4.1Stream类123

实验十SparkSQL实验126

1.实验准备128

5.创建Scalajar包129

5.1创建Scala项目129

5.2把scala项目Maven管理129

6.Spark运行打包好的jar文件132

7.java代码和配置文件（附）134

7.1SQL类134

实验一Scala部署及基本语法

【实验名称】

Scala基本语法

【实险目的】

1.熟悉Scala的安装和基础语法学习

2.掌握Scala基本数据类型和操作

3.熟悉使用Scala控制语句

【实险要求】

要求实验结束后，每位学生都能够自行安装Scala,并且能熟悉应用Scala的基础语法

和基本数据类型，能在Scala成功编写程序。

【实验环境】

1、1台Centos6.8虚拟机

2、实验所需安装包

【实验步骤】

1.安装Scala

1.1进入安装目录

[rootlocalhost〜]#cd/opt/hadoop-package/

1.2通过cp命令将scala安装包（5。3匕・2・10.4&92）解压到/（^1目录下

[rootlocalhosthadoop-package]#tar-zxvfscala-2.10.4.tgz-C/opt/

1.3scala重命名

[rootlocalhost]#cd/opt

[rootlocalhostopt]#mvscala-2.10.4/scala

1.4设置环境变量，并是环境变量生效

[rootlocalhost]#vi/etc/profile

在文件最后加上下面环境配置

exportPATH="$PATH:/opt/scaIa/bin"

使环境生效

[rootlocalhost]#source/etc/profile

修改好的配置截图：

exportHAUOOP_HUWLEA1H

172,16.15.123

*31#5ETZOOKEEPER

exportZOOKEEPER_HOME-/opt/zookeeper-3.4.10

a32exportPATH-JPATH:$ZOOKE£PER_HOME./bin

电33

exportHBASE_HOME=/opt/hbase

9exportPATH-SPATH:SHBASE_HOME/bin

918.2.3243exportPATH=5PATH：/usr/loca]/mysaUhin_______________________

«9

ExportPATH-"JPATH:/opt/scala/bin"

.2

*0—INSERT—

ault曰

issh2:AES-256-CTR18.120Rows,80ColsXtermCAPNUM

1.5scala成功测试

直接输入scala命令

[rootlocalhost]#scala

安装成功如下图：

[root@hadooplopt]#scala

welcometoscalaversion2.10.4(JavaHotspot(1M)64-Bitservervw,Java1

31).

Typeinexpressionstohavethemevaluated.

Type:helpformoreinformation.

seala>[root@hadooplopt]#vi/etc/profile

[root@hadooplopt]#scala

welcometoscalaversion2.10.4(JavaHotspot(TNI)64-Bitserverwi,Java1

31).

Typeinexpressionstohavethemevaluated.

Type:helpformoreinformation.

scala>

2.Scala基础

2.1基础语法

2.1.1声明值和变量

Scala有两种类型的变量：

val:是不可变的，在声明时就必须被初始化，而且初始化以后就不能再赋值；

var:是可变的，声明的时候需要进行初始化，初始化以后还可以再次对其赋值。

例如：声明不可变的字符串

scala>valmyStr="HelloWorld"

scala>valmyStr2:String="HelloWorld"

scala>valmyStr3Java.lang.String="HelloWorld"

scala>valmystr="Helloworld"

mystr:string=Helloworld

scala>valmystr2:string="Helloworld"

mystr2:String=Helloworld

scala>valmystr3:java.lang.string="Helloworld"

mystr3:string=Helloworld

scala>

例如：声明可变的复数

scala>varmyPrice:Double=9.9

scala>myPrice=9.9

scala>varmyPrice:Double=9.9

myPrice:Double=9.9

9

scala>myPrice=9.9

myPrice:Double=9.

scala>|

2.1.2基本的数据类型和操作

Scala的数据类型包括：Byte、Char、Short、Int、Long、Float、Double和Boolean

和Java不同的是,在Scala中，这些类型都是"类",并且都是包scala的成员，比如，Int

的全名是scala.Int。对于字符串,Scala用java.Iang.String类来表示字符串

值类型范围

Byte8位有符号补码整数(-27-27-l)

Short16位有符号补码整数(-2】s〜215-1)

Int32位有符号补码整数(-231〜231-1)

Long64位有符号补码整数(-263〜263-1)

Char16位无符号Unicode字符(0~216-1)

String字符序列

Float32位IEEE754单精度浮点数

Double64位IEEE754单精度浮点数

Booleantrue或false

操作符：在Scala中，可以使用加(+)、减(-)、乘(*)、除(/)、余数(％)等操作符，而且，

这些操作符就是方法。例如，5+3和(5).+(3)是等价的，也就是说：

a方法b等价于a方法b

scala>varsuml=5+3

等价于

scala>varsuml=(5).+(3)

scala>varsuml=5+3

suml:Int=8

scala>varsuml=(5).+⑶

suml:int=8

scala>|

2.1.3Range

在执行for循环时，我们经常会用到数值序列，比如，i的值从1循环到5,这时就可以采

用Range来实现

Range可以支持创建不同数据类型的数值序列，包括Int、Long、Float、Double.Char.

Biglnt和BigDecimal等

(1)创建一个从1到5的数值序列，包含区间终点5,步长为1命令如下

scala>1to5

(2)创建一个从1到5的数值序列，不包含区间终点5,步长为1命令如下

scala>1until5

(3)创建一个从1到10的数值序列，包含区间终点10,步长为2命令如下

scala>1to10by2

(4)创建TFloat类型的数值序列，从0.5f至！］5.9f,步长为0.3f命令如下

scala>0.5fto5.9fby0.3f

scala>1to5

res3:seala.collection.immutable.Range.inclusive=Range(1,2,3,4,5)

scala>1until5

res4:seala.collection.immutable.Range=Range(1,2,3,4)

scala>1to10by2

res5:seala.col1ection.immutable.Range=Range(1,3,5,7,9)

scala>0.5fto5.9fby0.3f

res7:seala.collection.immutable.NumericRange[Float]=NumericRangefO.5,0.8,

1,1.4000001,1.7,2.0,2.3,2.6,2.8999999,3.1999998,3.4999998,3.7999997,

1,4.4,4.7000003,5.OOOOOO5,5.3000007,5.600001,5.900001)

scala>|

2.1.4控制台输入输出语句

为了从控制台读写数据，可以使用以read为前缀的方法，包括：readlnt、readDouble、

readByte.readShort.readFloat.readLong.readCharreadBoolean及readLine,分

别对应9种基本数据类型,其中前8种方法没有参数，readLine可以不提供参数，也可以

带一个字符串参数的提示

所有这些函数都属于对象scala.io.Stdln的方法，使用前必须导入，或者直接用全称进行调

用

为了向控制台输出信息，常用的两个函数是print。和println(),可以直接输出字符串或者

其它数据类型

scala>print(,,123")

scala>println("231H)

scala>print(*'123")

123

scala>printlnC'231")

231

scala>|

Scala还带有C语言风格的格式化字符串的printf()函数

scala>printf("Mynameis%s",Iam%dyearsold,"xiaoming*',12)

<console>:8:error:notfound:valueI

printf("Mynameis%s",Iam%dyearsold,"xiaoming”,12)

scala>printf("Mynameis%s,Iam%dyearsold","xiaoming",12)

Mynameisxiaoming,Iam12yearsold

scala>.

2.1.5读写文件

1.写入文件

Scala需要使用java.io.PrintWriter实现把数据写入到文件

scala>importjava.io.PrintWriter

scala>valout二newPrintWriter("output.txt")

scala>for(i<-1to5)out.println(i)

scala>out.closeQ

如果我们想把文件保存到一个指定的目录下，就需要给出文件路径

scala>importjava.io.PrintWriter

scala>valout=newPrintWriter(7root/output.txt")

scala>for(i<-1to5)out.println(i)

scala>out.closeO

-I.UM.wuvpuU.IWUL

[root@hadooplIs

anaconda-ks.cfgb.txtinputoutputwordcountApp.jarwordcount.txt

[root(&hadoopl〜]#cd/opt/

[root@hadooplopt]#Is

hadoop-3.1.0hadoop-p<*ackagehbaseoutput.txtsealazookeeper-3.4.10

[root@hadooplopt]#vioutput.txt

[root@hadooploptJ#.

2.读取文件

可以使用Scala.io.Source的getLines方法实现对文件中所有行的读取

scala>importscala.io.Source

scala>varinputFile二Source.fromFileC'output.txt")

scala>vallines=inputFile.getLines

for(line<-lines)println(line)

scala>importscala.io.source

importscala.io.source

scala>varinputFile=source.formFileC^output.txt")

<console>:9:error:valueformFileisnotamemberofobjectscala.io.*

varinputFile=Source.formFi1e(noutput.txt

A

scala>varinputFile=Source.fromFi1eC*output.txt")

inputFile:seala.io.Bufferedsource=non-emptyiterator

scala>vallines=inputFi1e.getLines

lines:iterator[string]=non-emptyiterator

1for(line<-lines)printIn(line)

2

3

4

2.2控制结构

2.2.1if条件表达式

scala>valx=6

scala>if(x>0)

{println("turen)}else{

println("false")

)

Iiiainuj

A

scala>if(x>0)

{println("ture")}else(

^rintlnCfalse")

ture

scala>

2.2.2while循环

scala>valx=6

scala>while(x>0){

x-=1

printf("xis%d'\x)

)

scala>while(x>0){

Ix-=1

Iprintf(nxis%dn,x)

)

xis5xis4xis3xis2xislxis0

scala>|

2.2.3for循环

Scala中的for循环语句格式如下：

scala>for(i<-1to5)println(i)

xis5xis4xis3xis2xislxis0

1Lscala>for(i<-1to5)println(i)

实验二Scala数据结构

【实验名称】

Scala数据结构

【实验目的】

1.熟悉Scala的数据结构

2.熟悉掌握列表、集合、映射、迭代器、数组、元组等常见的数据类型。

【实验要求】

在实验结束时能熟悉掌握列表、集合、映射、迭代器、数组、元组等常见数据操作

【实验环境】

1、安装好scala环境的Centos6.8虚拟机

【实验步骤】

3.Scala数据结构

3.1列表

列表是一种共享相同类型的不可变的对象序列。既然是一个不可变的集合，Scala的List

定义在scala.collection.immutable包中

不同于Java的java.util.List,scala的List一旦被定义，其值就不能改变，因此声明List时

必须初始化

scala>varstrList=List("BigData","Hadoop'","Spark")

scala>varstrList=List("BigData","Hadoop","spark")

strList:List[string]=List(BigData,Hadoop,spark)

列表有头部和尾部的概念，可以分别使用head和tail方法来获取

head返回的是列表第一个元素的值

tail返回的是除第一个元素外的其它值构成的新列表，这体现出列表具有递归的链表结构

strList.head将返回字符串"BigData",strList.tail返回List("Hadoop","Spark")

3.2集合

集合(set)是不重复元素的容器(collectionX列表中的元素是按照插入的先后顺序来组织

的，但是，"集合"中的元素并不会记录元素的插入顺序，而是以"哈希"方法对元素的值

进行组织，所以，它允许你快速地找到某个元素集合包括可变集和不可变集，分别位于

scala.collection.mutable包和scala.collection.immutable包，缺省情况下创建的是不可

变集

3.2.1不可变集

scala>varmySet=Set("Hadoop"/Spark")

scala>mySet+="Scala"

3.2.2可变集

scala>importscala.collection.mutable.Set

scala>valmyMutableSet=Set("Database"/'BigData")

scala>myMutableSet十="CloudComputing"

iscaia>prinrm^myserj

set(Hadoop,spark,seala)

scala>importseala.col1ection.mutable.set

importscala.collection.mutable.set

scala>valmyMutableSet=set("Database","BigData")

=myMutableSet:scala.collection.mutable.set[string]=set(BigData,Database)

scala>myMutableSet+="cloudcomputing"

res8:myMutableset.type=set(BigData,cloudcomputing,Database)

scala>

3.3映射(M叩)

映射(Map)是一系列键值对的容器。在一个映射中，键是唯一的，但值不一定是唯一的。可

以根据键来对值进行快速的检索

和集合一样，Scala采用了类继承机制提供了可变的和不可变的两种版本的映射，分别定义

在包scala.collection.mutable和scala.collection.immutable里。默认情况下，Scala中

使用不可变的映射。如果想使用可变映射，必须明确地导入scala.collection.mutable.Map

3.3.1不可变Map集

scala>valuniversity=Map("XMU"->"XiamenUniversity","THU"->"Tsinghua

University","PKU"->"PekingUniversity")

如果要获取映射中的值，可以通过键来获取

scala>println(university("XMUn))

对于这种访问方式，如果给定的键不存在则会抛出异常，为此，访问前可以先调用contains

方法确定键是否存在

scala>valxmu=if(university.contains("XMU"))university(nXMU")else0

scala>println(xmu)

ap

-~LucJavaluniversity=MapC'XMU"->"Xiamenuniversity","THU"->"Tsinghuauni

SearchJsity"»"PKU"->"Pekinguniversity")

-university:scala.collection.immutable.Map[String,String]=Map(XMU->XiamenUn

iversity,THU->Tsinghuauniversity,PKU->Pekinguniversity)

scala>println(university("XMU"))

Xiamenuniversity

scala>valxmu=if(university.containsC'XMU"))universityC'XMU")else0

xmu:Any=Xiamenuniversity

scala>print!n(xmu)

xiamenuniversity

不可变映射，是无法更新映射中的元素的，也无法增加新的元素。如果要更新映射的元素，

就需要定义一个可变的映射

33.2可变Map集

scala>importscala.collection.mutable.Map

scala>valuniversity2=Map(nXMU"->"XiamenUniversity","THU"->"Tsinghua

University",nPKU"->"PekingUniversity")

scala>println(university2(MXMU"))

也可以使用十二操作来添加新的元素

scala>university2+=("TJU,,->"TianJingUniversity")

scala>importseala.collection.mutable.Map

importseala.col1action.mutable.Map

scala>valuniversity2=MapC'XMU"->"xiamenuniversity","THU"->**Tsinghuaun

iversity","PKU,'->,,PeKinguniversity")

university2:seala.collection.mutable.Map[string,string]=Map(XMU->xiamenuni

versity,THU->Tsinghuauniversity,PKU->Pekinguniversity)

scala>printlnXMU3)

Xiamenuniversity

scala>university2+=("TJU,,->"TianJinguniversity")

resl:university?.type=Map(XMU->Xiamenuniversity,THU->Tsinghuauniversit

y,TJU->TianJinguniversity,PKU->Pekinguniversity)

seala>println(university2(MTJUM))

TianJinguniversity

scala>.

3.3.3循环遍历映射

scala>for((k,v)<-university2)printf(Codeis:%sandnameis:%s\n,k,v)

scala>for((k,v)<-university2)printf("codeis%sandnameis:%s\n",k,v)

codeis:XMUandnameis:Xiamenuniversity

codeis:THUandnameis:Tsinghuauniversity

codeis:TJUandnameis:TianJinguniversity

codeis:PKUandnameis:Pekinguniversity

r

或者，也可以只遍历映射中的k或者v

scala>for(k<-university2.keys)println(k)

scala>for(v<-university2.values)println(v)

scala>for(k<-university?.keys)println(k)

XMU

THU

TJU

PKU

seala>for(v<-university2.values)println(v)

xiamenuniversity

Tsinghuauniversity

TianJinguniversity

Pekinguniversity

scala>

3.4迭代器

在Scala中，迭代器(Iterator)不是一个集合，但是，提供了访问集合的一种方法

迭代器包含两个基本操作：next和hasNext。next可以返回迭代器的下一个元素，hasNext

用于检测是否还有下一个元素

nn,

scala>valiter=Iterator("Hadoop,"Spark/Scala")

scala>while(iter.hasNext){println(iter.next())}

scala>for(v<-university2.values)print!n(v)

xiamenuniversity

Tsinghuauniversity

Tianjinguniversity

Pekinguniversity

scala>valiter=iterator("Hadoop","spark","seala")

iter:Iterator[String]=non-emptyiterator

while(iter.hasNext){println(iter.next()))

1.5数组（Array）

数组是一种可变的、可索引的、元素具有相同类型的数据集合，它是各种高级语言中最常用

的数据结构。Scala提供了参数化类型的通用数组类Array[T],其中T可以是任意的Scala

类型，可以通过显式指定类型或者通过隐式推断来实例化一个数组。

1.5.1普通数组

scala>varintValueArr=newArray[Int](3)

scala>intValueArr(O)=12

scala>intValueArr(l)=45

scala>intValueArr(2)=33

iriLVlaueArr,:ArrayLIFILJ=Array^u,u,uj

scala>varIntvalueArr=newArray[lnt](3)

intvalueArr:Array[[nt]=Array(O,0,0)

scala>intvalueArr(O)=12

scala>intvalueArr(l)=45

scala>IntvalueArr(2)=33

1.5.2函数ofDim

Array提供了函数。fDim来定义二维和三维数组，用法如下:

类型实际就是

scala>valmyMatrix=Array.ofDim[Int](3z4)Array[Array[Int]]

类型实际是

scala>valmyCube=Array.ofDim[String](3z2z4)Array[Array[Array[Int]]]

iype111icuiiavcLIieiiievdiudieu.

yype:helpformore

scala>valmyMatrix=Array.ofDim[lnt](3,4)

nywatrix:Array[Array[lnt]]=Array(ArrayCO,0,0,0),Array(0,0,0,0),Array(0,0

,0,0))

scala>valmycube=Array.ofDim[String](3,2,4)

nycube:Array[Array[Array[String]]]=Array(Array(Array(null,nul1,nul1,null),Ar

ay(null,null,nulI,null)),Array(Array(null,null,null,null),Array(null,null,

lull,null)),Array(Array(null,null,null,null),Array(null,null,null,null)))

scala>

可以使用多级圆括号来访问多维数组的元素，例如myMatrix(O)Q)返回第一行第二列的元

素

1.5.3定长数组

采用Array类型定义的数组属于定长数组，其数组长度在初始化后就不能改变。如果要定义

变长数组,需要使用ArrayBuffer参数类型，其位于包scala.collection.mutable中。举例

如下：

scala>importscala.collection.mutable.ArrayBuffer

scala>valaMutableArr=ArrayBuffer(10z20z30)

scala>aMutableArr+=40

scala>aMutableArr.insert(2,60,40)

scala>aMutableArr-=40

scala>vartemp=aMutableArr.remove(2)

scala>importseala.collection.mutable.ArrayBuffer

importseala.col1ection.mutable.ArrayBuffer

scala>valaMutableArr=ArrayBuffer(10,20,30)

awutableArr:seala.col1ection.mutable.ArrayBuffer[int]=ArrayBuffer(10,20,30)

scala>aMutableArr+=40

resO:aMutableArr.type=ArrayBuffer(10,20,30,40)

scala>aMutableArr.insert(2,60,40)

seala>aMutableArr-=40

res2:aMutableArr.type=ArrayBuffer(10,20,60,30,40)

scala>vartemp=aMutableArr.remove(2)

temp:Int=60

scala>|

1.6元组(Tuple)

元组是不同类型的值的聚集。元组和列表不同，列表中各个元素必须是相同类型，而元组可

以包含不同类型的元素

scala>valtuple=("hello",2015,44.7)

scala>println(tuple._l)

scala>println(tuple._2)

scala>println(tuple._3)

scala>valtuple=("hello",2015,44.7)

tuple:(String,int,Double)=(hello,2015,44.7)

scala>println(tuple,_l)

<console>:9:error:toomanyargumentsformethodprintln:(x:Any)unit

println(tuple,_l)

scala>println(tuple._l)

hello

scala>println(tuple._2)

2015

scala>println(tuple.-3)

44.7

scala>|

实验三Scala类和对象

【实验名称】

Scala类和对象

【实验目的】

1.熟悉Scala的类和对象

2.熟悉使用Scala文件的编译和执行

3.了解单例对象、伴生对象、应用程序对象的特征和区别。

【实验要求】

实验结束后学生能够熟悉使用Scala文件的编译和执行，能够熟悉使用类的属性和方

法，了解单例对象、伴生对象、应用程序对象的特征和区别

【实验环境】

1、安装好scala环境的Centos6.8虚拟机

【实验步骤】

4.类

4.1简单的类

最简单的类的定义形式是：

classCounter{

〃这呈定义类的字段和方法

)

可以使用new关键字来生成对象

newCounter〃或者newCounter()

1.2给类增加字段和方法

classCounter{

privatevarvalue=0

defincrementO：Unit={value+=1}

defcurrentQ：Int={value}

}

13创建对象

classCounter{

privatevarvalue=0

defincrementO：Unit={value+=1}

defcurrentQ:Int={value}

下面我们新建对象，并调用其中的方法：

valmyCounter=newCounter

myCounter.incrementO

println(myCounter.current)

从上面代码可以看出，Scala在调用无参方法时，是可以省略方法名后面的圆括号的

1.4编译和执行

1.4.1编辑文件内容

[roothadoopl]#viTestCounter.scala

内容如下

classCounter{

privatevarvalue=0

defincrementO：Unit={value+=1}

defcurrentO：Int={value}

)

valmyCounter=newCounter

myCounter.incrementO

println(myCounter.current)

1.4.2在LinuxShell命令下执行seala

[roothadoopl]#scalaTestCounter.scala

1.4.3输出结果

上面命令执行后，会在屏幕输出1

Lroor^naaoopi〜」并vilesrcounrer.scaia

[root@hadoopl〜j#scalaTestcounter.seala

1

1.4.4JVM字节码

如果需要封装成JVM字节码则需要通过scalac进行编译

1.编辑文件内容

[roothadoopl]#viTestCounterJVM.scala

内容如下

classCounter{

privatevarvalue=0

defincrement():Unit={value+=1}

defcurrent():Int={value}

}

objectMyCounter{

defmain(args:Array[String]){

valmyCounter=newCounter

MyCounter.incrementO

println(myCounter.current)

}

)

2.使用scalac命令编译这个代码文件,并用scala命令执行,如下：

[roothadoopl]#scalacTestCounterJVM.scala

[roothadoopl]#scala-classpath.MyCounter

counter,c-zookeeper.out

rroot@had(>1-I#scalacTestCounterJVM.scala

[root@hadoopl

[10,Downloadsjdk-8ul61-linux-x64.tar.gztest」,javawordcountscala-0.0.1-SNAPSHOT,jar

aaHelloworld.class■etastore_dbTestcounterJVW.sealzookeeper.out

anaconda-ks.cfgHelloworlds>..das;MyCounter.classTestcounter.seala

Counter.classinstall.logMyCounter$.class

derby.logrhinssrataTT;k*TTi-isp<irk7<u-

[root@hadoopl-]#scala-cl一Mycounter

[rootehadoopl-]#c

1.5getter和setter方法

给类中的字段设置值以及读取值，在Java中是通过getter和setter方法实现的

在Scala中,也提供了getter和setter方法的实现，但是并没有定义成getXxx和setXxx

继续修改TestCounterJVM.scala文件：

value变成私有字段以后,Scala又没有提供getter和setter方法，怎么可以访问value字

段呢？解决方案是，在Scala中，可以通过定义类似getter和setter的方法，分别叫做

value和value_=，具体如下：

1.5.1编辑文件内容

[roothadoopl]#viTestCounterJVM.scala

内容如下

objectMyCounter{

defmain(args:Array[String]){

valmyCounter=newCounter()

println(myCounter.value)

myCounter.value=3

myCounter.increment(l)

println(myCounter.current)

)

)

classCounter{

privatevarprivateValue=0

defvalue=privateValue

defvalue_=(newValue:Int){

if(newValue>0)privateValue=newValue

)

defincrement(temp:Int):Unit={value+=temp}

defcurrent():Int={value}

)

1.5.2删除之前生成的class

[roothadoopl]#rm-rfMyCounter*

1.5.3使用scalac命令编译这个代码文件

[roothadoopl]#scalacTestCounterJVM.scala

[roothadoopl]#scala-classpath.MyCounter

编译执行这个文件，就可以得到两行执行结果，第一行是0,第二行是4。

[root@hadoopl〜]#rm-rfdemol*

[root@hadoopl〜viTestcounterJVM.scala

[root@hadoopl〜scalacTestcounterJVM.scala

[root@hadoopl〜j#

LIO,install.logTestcounterJVM.scala

aainstal1.log.syslogTestcounter.seala

anaconda-ks.cfgjdk-8ul61-linux-x64.tar.gztest.py

counter.classmetastore-dbtest.scala

derby.logMyCounter.classwordcountseala-0.0.1-SNAPSHOT.jar

DownloadsMyCounter$.classzookeeper.out

Helloworld.classsparkJar

HelloworldS.classtest_l.java

[root@hadoopl〜]#scala-classpath.MyCounter

0

4r

5.对象

5.1单例对象

Scala并没有提供Java那样的静态方法或静态字段，但是，可以采用object关键字实现单

例对象，具备和Java静态方法同样的功能。

下面是单例对象的定义：

objectPerson{

privatevarlastld=0

defnewPersonldO={

lastld+=1

lastld

)

)

println("lpersionidis'\Person.newPersonldO)

println("2persionidis'\Person.newPersonldO)

println("3persionidis'\Person.newPersonldO)

pressLNILKorrypecommanaroconrinue

[root@hadoopl~]#sealatest.scala

(1persionidis,1)

(2persionidis,2)

(3persionidis,3)

▼[root@hadoopl〜]#

5.2伴生对象

在Java中，我们经常需要用到同时包含实例方法和静态方法的类，在Scala中可以通过伴

生对象来实现。

当单例对象与某个类具有相同的名称时，它被称为这个类的“伴生对象"。

类和它的伴生对象必须存在于同一个文件中，而且可以相互访问私有成员（字段和方法I

2.2.1删除并重新创建一个test.scala

在该文件中输入如下代码：

classPerson{

privatevalid=Person.newPersonldO调用了伴生对象中的方法

privatevarname=""

defthis(name:String){

this()

=name

)

definfo(){printf("Theidof%sis%d.\n";name,id)}

)

objectPerson{

privatevarlastld=0一个人的身份编号

privatedefnewPersonldQ={

lastld+=1

lastld

)

defmain(args:Array[String]){

valpersonl=newPerson(nZiyu")

valperson2=newPerson(nMinxing")

O

()

)

)

2.2.2编译执行

[roothadoopl]#scalactest.scala

[roothadoopl]#scalaPersion

：11l-ks.crginstall,logPerson.classtest.py

classinstall.log.syslogPersons.classtest.scala

derby.logjdk-8ul61-1inux-x64.tar.gzsparkjarwordcotintscala-0.0

Down!oads«etastore_dbjavazookeeper.out

[root@hadooplscalaPerson

TheidofZiyuis1.

TheidofMinxingis2.

[root@hadoopl.

5.3应用程序对象

每个Scala应用程序都必须从一个对象的main方法开始，重新创建一个test.scala

5.3.1删除并重新创建一个test.scala

[roothadoopl]#rm-rftest.scala