天津店小二

浏览: 73913 次
性别:
来自: 天津

最近访客更多访客>>

佛挡杀佛萨达

cxykyw-2

zhyly101

roqingyou

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

scala

博客分类：

大数据

Scala

Scala介绍

1. Spark中使用的是Sacla2.10。scala跟java语言一样需要在jvm中编译后才能运行，也就是说都需要安装jdk环境。只是后缀是.scala

2.Scala官网6个特征。

1).Java和scala可以混编（可以互相调用类，例如调用java中的unti类）

2).类型推测(自动推测类型)

3).并发和分布式（Actor）

4).特质，特征(类似java中interfaces 和 abstract结合)（支持多继承多实现）

5).模式匹配match（类似java switch）

6).高阶函数（scala不仅面向对象，还面向函数）。Scala中函数其实就是方法，将方法当做一个参数传给函数。

Scala安装使用

1. windows安装,配置环境变量

Ø 官网下载scala2.10：http://www.scala-lang.org/download/2.10.4.html

Ø 下载好后安装。双击msi包安装,记住安装的路径。

Ø 配置环境变量（和配置jdk一样）

l 新建SCALA_HOME

l 上个步骤完成后，编辑Path变量，在后面追加如下：

;%SCALA_HOME%\bin;%SCALA_HOME%\jre\bin

Ø 打开cmd,输入：scala - version 看是否显示版本号，确定是否安装成功

2. eclipse 配置scala插件

Ø 下载插件（一定要对应eclipse版本下载）

http://scala-ide.org/download/prev-stable.html

Ø 下载好zip包后，解压如下：

Ø 将features和plugins两个文件夹拷贝到eclipse安装目录中的” dropins/scala”目录下。进入dropins，新建scala文件夹，将两个文件夹拷贝到“dropins/scala”下

3. scala ide

下载网址：http://scala-ide.org/download/sdk.html

4. idea 中配置scala插件

Ø 打开idea,close项目后，点击Configure->Plugins

Ø 搜索scala，点击Install安装

Ø 设置jdk，打开Project Structure,点击new 选择安装好的jdk路径

Ø 创建scala项目，配置scala sdk(Software Development Kit)

点击第三步，弹出选择SDK,点击Browse选择本地安装的Scala目录。选择system.

Scala基础

1. 数据类型

2. 变量和常量的声明

Ø 定义变量或者常量的时候，也可以写上返回的类型，一般省略，如：val a:Int = 10

Ø 常量不可再赋值

/**

* 定义变量和常量

* 变量 :用 var定义，可修改

* 常量 :用 val定义，不可修改

varname = "zhangsan"

println(name)

name ="lisi"

println(name)

valgender = "m"

// gender = "m"//错误，不能给常量再赋值

3. 类和对象

Ø 创建类

class Person{

val name = "zhangsan"

valage = 18

defsayName() = {

"my name is "+name

}

Ø 创建对象

objectLesson_Class {

defmain(args: Array[String]): Unit = {

valperson = new Person()

println(person.age);

println(person.sayName())

}

Ø 伴生类和伴生对象

class Person(xname :String , xage :Int){

varname = Person.name

valage = xage

vargender = "m"

defthis(name:String,age:Int,g:String){

this(name,age)

gender = g

}

defsayName() = {

"my name is "+name

}

objectPerson {

valname = "zhangsanfeng"

defmain(args: Array[String]): Unit = {

valperson = new Person("wagnwu",10,"f")

println(person.age);

println(person.sayName())

println(person.gender)

}

注意点：

l 建议类名首字母大写，方法首字母小写，类和方法命名建议符合驼峰命名法。

l scala 中的object是单例对象，相当于java中的工具类，可以看成是定义静态的方法的类。object不可以传参数。另：Trait不可以传参数

l scala中的class类默认可以传参数，默认的传参数就是默认的构造函数。

重写构造函数的时候，必须要调用默认的构造函数。

l class 类属性自带getter ，setter方法。

l 使用object时，不用new,使用class时要new ,并且new的时候，class中除了方法不执行，其他都执行。

l 如果在同一个文件中，object对象和class类的名称相同，则这个对象就是这个类的伴生对象，这个类就是这个对象的伴生类。可以互相访问私有变量。

4. if else

/**

* if else

valage =18

if (age<18 ){

println("no allow")

}elseif (18<=age&&age<=20){

println("allow with other")

}else{

println("allow self")

}

5. for ,while,do…while

1. to和until 的用法（不带步长，带步长区别）

/**

* to和until

* 例：

* 1 to 10 返回1到10的Range数组，包含10

* 1 until 10 返回1到10 Range数组，不包含10

println(1to10 )//打印 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

println(1.to(10))//与上面等价，打印 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

println(1to (10 ,2))//步长为2，从1开始打印，1,3,5,7,9

println(1.to(10, 2))

println(1until10 ) //不包含最后一个数，打印 1,2,3,4,5,6,7,8,9

println(1.until(10))//与上面等价

println(1until (10 ,3 ))//步长为2，从1开始打印，打印1,4,7

2. 创建for循环

/**

* for 循环

for( i <- 1to10 ){

println(i)

}

3. 创建多层for循环

//可以分号隔开，写入多个list赋值的变量，构成多层for循环

//scala中不能写count++ count-- 只能写count+

varcount = 0;

for(i <- 1to10; j <- 1until10){

println("i="+i+", j="+j)

count += 1

}

println(count);

//例子：打印小九九

for(i <- 1until10 ;j <- 1until10){

if(i>=j){

print(i+" * "+j+" = "+i*j+"")

}

if(i==j ){

println()

}

4. for循环中可以加条件判断，分号隔开

//可以在for循环中加入条件判断

for(i<- 1to10 ;if (i%2) ==0 ;if (i==4) ){

println(i)

}

5. scala中不能使用count++，count—只能使用count = count+1 ，count += 1

6. for循环用yield 关键字返回一个集合

7. while循环，while（）{}，do {}while()

//将for中的符合条件的元素通过yield关键字返回成一个集合

vallist = for(i <- 1to10 ; if(i>5 )) yieldi

for( w <- list ){

println(w)

}

/**

* while 循环

varindex = 0

while(index<100 ){

println("第"+index+"次while 循环")

index += 1

}

index = 0

do{

index +=1

println("第"+index+"次do while 循环")

}while(index<100 )

Scala函数

1. Scala函数的定义

Ø 有参函数

Ø 无参函数

deffun (a: Int , b: Int ) : Unit = {

println(a+b)

}

fun(1,1)

deffun1 (a : Int , b : Int)= a+b

println(fun1(1,2))

注意点：

l 函数定义语法用def来定义

l 可以定义传入的参数，要指定传入参数的类型

l 方法可以写返回值的类型也可以不写，会自动推断，有时候不能省略，必须写，比如在递归函数中或者函数的返回值是函数类型的时候。

l scala中函数有返回值时，可以写return，也可以不写return，会把函数中最后一行当做结果返回。当写return时，必须要写函数的返回值。

l 如果返回值可以一行搞定，可以将{}省略不写

l 传递给方法的参数可以在方法中使用，并且scala规定方法的传过来的参数为val的，不是var的。

l 如果去掉方法体前面的等号，那么这个方法返回类型必定是Unit的。这种说法无论方法体里面什么逻辑都成立，scala可以把任意类型转换为Unit.假设，里面的逻辑最后返回了一个string，那么这个返回值会被转换成Unit，并且值会被丢弃。

2. 递归函数

/**

* 递归函数

* 5的阶乘

deffun2(num :Int) :Int= {

if(num==1)

num

else

num*fun2(num-1)

}

print(fun2(5))

3. 包含参数默认值的函数

l 默认值的函数中，如果传入的参数个数与函数定义相同，则传入的数值会覆盖默认值。

l 如果不想覆盖默认值，传入的参数个数小于定义的函数的参数，则需要指定参数名称。

/**

* 包含默认参数值的函数

* 注意：

* 1.默认值的函数中，如果传入的参数个数与函数定义相同，则传入的数值会覆盖默认值

* 2.如果不想覆盖默认值，传入的参数个数小于定义的函数的参数，则需要指定参数名称

deffun3(a :Int = 10,b:Int) = {

println(a+b)

}

fun3(b=2)

4. 可变参数个数的函数

l 多个参数用逗号分开

/**

* 可变参数个数的函数

* 注意：多个参数逗号分开

deffun4(elements :Int*)={

varsum = 0;

for(elem <- elements){

sum += elem

}

sum

}

println(fun4(1,2,3,4))

5. 匿名函数

1. 有参匿名函数

2. 无参匿名函数

3. 有返回值的匿名函数

l 可以将匿名函数返回给val定义的值

l 匿名函数不能显式声明函数的返回类型

/**

* 匿名函数

* 1.有参数匿名函数

* 2.无参数匿名函数

* 3.有返回值的匿名函数

* 注意：

* 可以将匿名函数返回给定义的一个变量

//有参数匿名函数

valvalue1 = (a : Int) => {

println(a)

}

value1(1)

//无参数匿名函数

valvalue2 = ()=>{

println("我爱尚学堂")

}

value2()

//有返回值的匿名函数

valvalue3 = (a:Int,b:Int) =>{

a+b

}

println(value3(4,4))

6. 嵌套函数

/**

* 嵌套函数

* 例如：嵌套函数求5的阶乘

deffun5(num:Int)={

deffun6(a:Int,b:Int):Int={

if(a==1){

}else{

fun6(a-1,a*b)

}

fun6(num,1)

}

println(fun5(5))

7. 偏应用函数

偏应用函数是一种表达式，不需要提供函数需要的所有参数，只需要提供部分，或不提供所需参数。

/**

* 偏应用函数

deflog(date :Date, s :String)= {

println("date is "+date+",log is "+s)

}

valdate = new Date()

log(date ,"log1")

log(date ,"log2")

log(date ,"log3")

//想要调用log，以上变化的是第二个参数，可以用偏应用函数处理

vallogWithDate = log(date,_:String)

logWithDate("log11")

logWithDate("log22")

logWithDate("log33")

8. 高阶函数

函数的参数是函数，或者函数的返回类型是函数，或者函数的参数和函数的返回类型是函数的函数。

l 函数的参数是函数

l 函数的返回是函数

l 函数的参数和函数的返回是函数

/**

* 高阶函数

* 函数的参数是函数或者函数的返回是函数或者函数的参数和返回都是函数

//函数的参数是函数

defhightFun(f : (Int,Int) =>Int, a:Int ) : Int = {

f(a,100)

}

deff(v1 :Int,v2: Int):Int = {

v1+v2

}

println(hightFun(f, 1))

//函数的返回是函数

//1，2,3,4相加

defhightFun2(a : Int,b:Int) : (Int,Int)=>Int = {

deff2 (v1: Int,v2:Int) :Int = {

v1+v2+a+b

}

println(hightFun2(1,2)(3,4))

//函数的参数是函数，函数的返回是函数

defhightFun3(f : (Int ,Int) => Int) : (Int,Int) => Int = {

}

println(hightFun3(f)(100,200))

println(hightFun3((a,b) =>{a+b})(200,200))

//以上这句话还可以写成这样

//如果函数的参数在方法体中只使用了一次那么可以写成_表示

println(hightFun3(_+_)(200,200))

9. 柯里化函数

l 可以理解为高阶函数的简化

/**

* 柯里化函数

deffun7(a :Int,b:Int)(c:Int,d:Int) = {

a+b+c+d

}

println(fun7(1,2)(3,4))

Scala字符串

1. String

2. StringBuilder 可变

3. string操作方法举例

Ø 比较:equals

Ø 比较忽略大小写:equalsIgnoreCase

Ø indexOf：如果字符串中有传入的assci码对应的值，返回下标

/**

* String && StringBuilder

valstr = "abcd"

valstr1 = "ABCD"

println(str.indexOf(97))

println(str.indexOf("b"))

println(str==str1)

/**

* compareToIgnoreCase

* 如果参数字符串等于此字符串，则返回值 0；

* 如果此字符串小于字符串参数，则返回一个小于 0 的值；

* 如果此字符串大于字符串参数，则返回一个大于 0 的值。

println(str.compareToIgnoreCase(str1))

valstrBuilder = newStringBuilder

strBuilder.append("abc")

// strBuilder.+('d')

strBuilder+'d'

// strBuilder.++=("efg")

strBuilder++="efg"

// strBuilder.+=('h')

strBuilder+='h'

strBuilder.append(1.0)

strBuilder.append(18f)

println(strBuilder)

String方法：（见附件）

集合

数组

1. 创建数组

Ø new Array[Int](10)

赋值：arr(0) = xxx

Ø Array[String](“s1”,”s2”,”s3”)

2. 数组遍历

Ø for

Ø foreach

3. 创建一维数组和二维数组

4. 数组中方法举例

Ø Array.concate：合并数组

Ø Array.fill(5)(“bjsxt”)：创建初始值的定长数组

创建两种方式:

/**

* 创建数组两种方式：

* 1.new Array[String](3)

* 2.直接Array

//创建类型为Int 长度为3的数组

valarr1 = new Array[Int](3)

//创建String 类型的数组，直接赋值

valarr2 = Array[String]("s100","s200","s300")

//赋值

arr1(0) = 100

arr1(1) = 200

arr1(2) = 300

遍历两种方式：

/**

* 遍历两种方式

for(i <- arr1){

println(i)

}

arr1.foreach(i => {

println(i)

})

for(s <- arr2){

println(s)

}

arr2.foreach {

x => println(x)

}

创建二维数组

/**

* 创建二维数组和遍历

valarr3 = new Array[Array[String]](3)

arr3(0)=Array("1","2","3")

arr3(1)=Array("4","5","6")

arr3(2)=Array("7","8","9")

for(i <- 0untilarr3.length){

for(j <- 0untilarr3(i).length){

print(arr3(i)(j)+" ")

}

println()

}

varcount = 0

for(arr <- arr3 ;i <- arr){

if(count%3==0){

println()

}

print(i+" ")

count +=1

}

arr3.foreach { arr => {

arr.foreach { println }

}}

valarr4 = Array[Array[Int]](Array(1,2,3),Array(4,5,6))

arr4.foreach { arr => {

arr.foreach(i => {

println(i)

})

}}

println("-------")

for(arr <- arr4;i <- arr){

println(i)

}

数组中的方法:

list

1. 创建list

val list = List(1,2,3,4)

Ø Nil长度为0的list

2. list遍历

foreach ，for

3. list方法举例

Ø filter:过滤元素

Ø count:计算符合条件的元素个数

Ø map：对元素操作

Ø flatmap ：压扁扁平,先map再flat

Ø map与flatmap的区别

val list1 = List("hello bjsxt","hello shsxt","hello gzsxt")

//1.map是一进一出，每次进去list集合中的一个元素，出来一个数组。最终把list中三个元素组成三个数组后组成一个list输出。也就是形成了一个新的list，里面元素是数组

val result = list1.map(s=>{ s.split(" ") })

2. flatmap是一进多出，每次进去list集合中的一个元素，出来两个字符串。flat是扁平的意思。flatMap是把list集合中每个元素切割后的每个字符串放入一个新的list集合中，最终产生一个list。（其实就是在map方法的基础上进行扁平化）。最终形成了一个新的list，里面元素都是string类型的。

val result1 = list1.flatMap(s=>{ s.split(" ") })

//创建

vallist = List(1,2,3,4,5)

//遍历

list.foreach { x => println(x)}

// list.foreach { println}

//filter

vallist1 = list.filter { x => x>3 }

list1.foreach { println}

//count

valvalue = list1.count { x => x>3 }

println(value)

//map

valnameList = List(

"hello bjsxt",

"hello xasxt",

"hello shsxt"

)

valmapResult:List[Array[String]] = nameList.map{ x => x.split(" ") }

mapResult.foreach{println}

//flatmap

valflatMapResult : List[String] = nameList.flatMap{ x => x.split(" ") }

flatMapResult.foreach { println }

4. list方法总结

set

1. 创建set

注意：set集合会自动去重

2. set遍历

foreach，for

3. set方法举例

Ø 交集：intersect ,&

Ø 差集: diff ,&~

Ø 子集:subsetOf

Ø 最大:max

Ø 最小:min

Ø 转成数组，toList

Ø 转成字符串：mkString(“~”)

4. set方法总结

//创建

valset1 = Set(1,2,3,4,4)

valset2 = Set(1,2,5)

//遍历

//注意：set会自动去重

set1.foreach { println}

for(s <- set1){

println(s)

}

println("*******")

/**

* 方法举例

//交集

valset3 = set1.intersect(set2)

set3.foreach{println}

valset4 = set1.&(set2)

set4.foreach{println}

println("*******")

//差集

set1.diff(set2).foreach { println }

set1.&~(set2).foreach { println }

//子集

set1.subsetOf(set2)

//最大值

println(set1.max)

//最小值

println(set1.min)

println("****")

//转成数组，list

set1.toArray.foreach{println}

println("****")

set1.toList.foreach{println}

//mkString

println(set1.mkString)

println(set1.mkString("\t"))

set方法总结

map

1. map创建

Ø Map（1 –>”bjsxt’）

Ø Map((1,”bjsxt”))

注意：创建map时，相同的key被后面的相同的key顶替掉，只保留一个

valmap = Map(

"1"->"bjsxt",

2->"shsxt",

(3,"xasxt")

)

2. 获取map的值

Ø map.get(“1”).get

Ø map.get(100).getOrElse(“no value”)：如果map中没有对应项，赋值为getOrElse传的值。

//获取值

println(map.get("1").get)

valresult = map.get(8).getOrElse("no value")

println(result)

3. 遍历map

Ø for,foreach

//map遍历

for(x <- map){

println("====key:"+x._1+",value:"+x._2)

}

map.foreach(f => {

println("key:"+f._1+" ,value:"+f._2)

})

4. 遍历key

Ø map.keys

//遍历key

valkeyIterable = map.keys

keyIterable.foreach { key => {

println("key:"+key+", value:"+map.get(key).get)

} }

println("---------")

5. 遍历value

Ø map.values

//遍历value

valvalueIterable = map.values

valueIterable.foreach { value => {

println("value: "+value)

} }

6. 合并map

Ø ++ 例：map1.++(map2) --map1中加入map2

Ø ++: 例：map1.++:(map2) –map2中加入map1

注意：合并map会将map中的相同key的value替换

//合并map

valmap1 = Map(

(1,"a"),

(2,"b"),

(3,"c")

)

valmap2 = Map(

(1,"aa"),

(2,"bb"),

(2,90),

(4,22),

(4,"dd")

)

map1.++:(map2).foreach(println)

7. map中的方法举例

Ø filter:过滤，留下符合条件的记录

Ø count:统计符合条件的记录数

Ø contains：map中是否包含某个key

Ø exist：符合条件的记录存在不存在

/**

* map方法

//count

valcountResult = map.count(p => {

p._2.equals("shsxt")

})

println(countResult)

//filter

map.filter(_._2.equals("shsxt")).foreach(println)

//contains

println(map.contains(2))

//exist

println(map.exists(f =>{

f._2.equals("xasxt")

}))

Map方法总结

元组

1. 元组定义

与列表一样，与列表不同的是元组可以包含不同类型的元素。元组的值是通过将单个的值包含在圆括号中构成的。

2. 创建元组与取值

Ø val tuple = new Tuple（1）可以使用new

Ø val tuple2 = Tuple（1,2）可以不使用new，也可以直接写成val tuple3 =（1,2,3）

Ø 取值用”._XX” 可以获取元组中的值

注意：tuple最多支持22个参数

//创建，最多支持22个

valtuple = newTuple1(1)

valtuple2 = Tuple2("zhangsan",2)

valtuple3 = Tuple3(1,2,3)

valtuple4 = (1,2,3,4)

valtuple18 = Tuple18(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18)

valtuple22 = newTuple22(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22)

//使用

println(tuple2._1+"\t"+tuple2._2)

valt = Tuple2((1,2),("zhangsan","lisi"))

println(t._1._2)

3. 元组的遍历

tuple.productIterator得到迭代器，进而遍历

//遍历

valtupleIterator = tuple22.productIterator

while(tupleIterator.hasNext){

println(tupleIterator.next())

}

4. swap,toString方法

注意：swap元素翻转，只针对二元组

/**

* 方法

//翻转，只针对二元组

println(tuple2.swap)

//toString

println(tuple3.toString())

trait 特性

1. 概念理解

Scala Trait(特征) 相当于 Java 的接口，实际上它比接口还功能强大。

与接口不同的是，它还可以定义属性和方法的实现。

一般情况下Scala的类可以继承多个Trait，从结果来看就是实现了多重继承。Trait(特征) 定义的方式与类类似，但它使用的关键字是 trait。

2. 举例：trait中带属性带方法实现

注意：

Ø 继承的多个trait中如果有同名的方法和属性，必须要在类中使用“override”重新定义。

Ø trait中不可以传参数

traitRead {

valreadType = "Read"

valgender = "m"

defread(name:String){

println(name+" is reading")

}

traitListen {

vallistenType = "Listen"

valgender = "m"

deflisten(name:String){

println(name+" is listenning")

}

class Person() extendsReadwithListen{

overridevalgender = "f"

}

objecttest {

defmain(args: Array[String]): Unit = {

valperson = new Person()

person.read("zhangsan")

person.listen("lisi")

println(person.listenType)

println(person.readType)

println(person.gender)

}

3. 举例：trait中带方法不实现

objectLesson_Trait2 {

defmain(args: Array[String]): Unit = {

valp1 = new Point(1,2)

valp2 = new Point(1,3)

println(p1.isEqule(p2))

println(p1.isNotEqule(p2))

}

traitEqule{

defisEqule(x:Any) :Boolean

defisNotEqule(x : Any) = {

!isEqule(x)

}

class Point(x:Int, y:Int) extendsEqule {

valxx = x

valyy = y

defisEqule(p:Any) = {

p.isInstanceOf[Point] &&p.asInstanceOf[Point].xx==xx

}

模式匹配match

1. 概念理解：

Scala 提供了强大的模式匹配机制，应用也非常广泛。

一个模式匹配包含了一系列备选项，每个都开始于关键字 case。

每个备选项都包含了一个模式及一到多个表达式。箭头符号 => 隔开了模式和表达式。

2. 代码及注意点

Ø 模式匹配不仅可以匹配值还可以匹配类型

Ø 从上到下顺序匹配，如果匹配到则不再往下匹配

Ø 都匹配不上时，会匹配到case _ ,相当于default

Ø match 的最外面的”{ }”可以去掉看成一个语句

objectLesson_Match {

defmain(args: Array[String]): Unit = {

valtuple = Tuple6(1,2,3f,4,"abc",55d)

valtupleIterator = tuple.productIterator

while(tupleIterator.hasNext){

matchTest(tupleIterator.next())

}

/**

* 注意点：

* 1.模式匹配不仅可以匹配值，还可以匹配类型

* 2.模式匹配中，如果匹配到对应的类型或值，就不再继续往下匹配

* 3.模式匹配中，都匹配不上时，会匹配到 case _ ，相当于default

defmatchTest(x:Any) ={

xmatch {

casex:Int=> println("type is Int")

case1 => println("result is 1")

case2 => println("result is 2")

case3=> println("result is 3")

case4 => println("result is 4")

casex:String => println("type is String")

// case x :Double => println("type is Double")

case _ => println("no match")

}

样例类(case classes)

1. 概念理解

使用了case关键字的类定义就是样例类(case classes)，样例类是种特殊的类。实现了类构造参数的getter方法（构造参数默认被声明为val），当构造参数是声明为var类型的，它将帮你实现setter和getter方法。

Ø 样例类默认帮你实现了toString,equals，copy和hashCode等方法。

Ø 样例类可以new, 也可以不用new

2. 例子：结合模式匹配的代码

caseclassPerson1(name:String,age:Int)

objectLesson_CaseClass {

defmain(args: Array[String]): Unit = {

valp1 = newPerson1("zhangsan",10)

valp2 = Person1("lisi",20)

valp3 = Person1("wangwu",30)

vallist = List(p1,p2,p3)

list.foreach { x => {

xmatch {

casePerson1("zhangsan",10) => println("zhangsan")

casePerson1("lisi",20) => println("lisi")

case _ => println("no match")

}

} }

}

Actor Model

1. 概念理解

Actor Model是用来编写并行计算或分布式系统的高层次抽象（类似java中的Thread）让程序员不必为多线程模式下共享锁而烦恼,被用在Erlang 语言上, 高可用性99.9999999 % 一年只有31ms 宕机Actors将状态和行为封装在一个轻量的进程/线程中，但是不和其他Actors分享状态，每个Actors有自己的世界观，当需要和其他Actors交互时，通过发送事件和消息，发送是异步的，非堵塞的(fire-andforget)，发送消息后不必等另外Actors回复，也不必暂停，每个Actors有自己的消息队列，进来的消息按先来后到排列，这就有很好的并发策略和可伸缩性，可以建立性能很好的事件驱动系统。

Actor的特征：

Ø ActorModel是消息传递模型,基本特征就是消息传递

Ø 消息发送是异步的，非阻塞的

Ø 消息一旦发送成功，不能修改

Ø Actor之间传递时，自己决定决定去检查消息，而不是一直等待，是异步非阻塞的

什么是Akka

Akka 是一个用 Scala 编写的库，用于简化编写容错的、高可伸缩性的 Java 和Scala 的 Actor 模型应用，底层实现就是Actor,Akka是一个开发库和运行环境，可以用于构建高并发、分布式、可容错、事件驱动的基于JVM的应用。使构建高并发的分布式应用更加容易。

spark1.6版本之前，spark分布式节点之间的消息传递使用的就是Akka，底层也就是actor实现的。1.6之后使用的netty传输。

2. 例：Actor简单例子发送接收消息

import scala.actors.Actor

class myActor extendsActor{

defact(){

while(true){

receive {

casex:String => println("save String ="+x)

casex:Int => println("save Int")

case _ => println("save default")

}

objectLesson_Actor {

defmain(args: Array[String]): Unit = {

//创建actor的消息接收和传递

valactor =new myActor()

//启动

actor.start()

//发送消息写法

actor!"i love you !"

}

3. 例：Actor与Actor之间通信

caseclassMessage(actor:Actor,msg:Any)

class Actor1 extendsActor{

defact(){

while(true){

receive{

case msg :Message => {

println("i sava msg! = "+msg.msg)

msg.actor!"i love you too !"

}

casemsg :String => println(msg)

case _ => println("default msg!")

}

class Actor2(actor :Actor) extendsActor{

actor!Message(this,"i love you !")

defact(){

while(true){

receive{

casemsg :String => {

if(msg.equals("i love you too !")){

println(msg)

actor!"could we have a date !"

}

case _ => println("default msg!")

}

objectLesson_Actor2 {

defmain(args: Array[String]): Unit = {

valactor1 = new Actor1()

actor1.start()

valactor2 = new Actor2(actor1)

actor2.start()

}

WordCount

import org.apache.spark.SparkConf

import org.apache.spark.SparkContext

import org.apache.spark.rdd.RDD

import org.apache.spark.rdd.RDD.rddToPairRDDFunctions

objectWordCount {

defmain(args: Array[String]): Unit = {

valconf = new SparkConf()

conf.setMaster("local").setAppName("WC")

valsc = new SparkContext(conf)

vallines :RDD[String] = sc.textFile("./words.txt")

valword :RDD[String] = lines.flatMap{lines => {

lines.split(" ")

}}

valpairs : RDD[(String,Int)] = word.map{ x => (x,1) }

valresult = pairs.reduceByKey{(a,b)=> {a+b}}

result.sortBy(_._2,false).foreach(println)

//简化写法

lines.flatMap { _.split(" ")}.map { (_,1)}.reduceByKey(_+_).foreach(println)

}

分享到：

scala中的wordcount

2018-04-23 22:44
浏览 430
评论(0)
分类:开源软件
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

scala

Scala

评论

发表评论

相关推荐

最近访客 更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

scala

Scala

评论

发表评论

相关推荐

spark11

oozie

公司hive

大数据项目

scala2

scala中的wordcount

scala中的Akka通讯模型

hadooop

kafka

zookerpeer

jvm调优

jvm调优

jvm调优

java复习

机器学习

hive

大数据集群搭建

hbase

hbase代码

hive

最近访客更多访客>>