您的位置：首页 > 其它

Spark之scala

2015-08-25 16:16 375 查看

一、什么是scala

scala是基于JVMde编程语言。JAVA是运行在jvm上的编程语言，java源代码通过jvm被编译成class文件，然后在os上运行class文件。scala是运行在jvm上的编程语言，scala源代码通过jvm被编译成class文件，然后在os上运行class文件。

二语法：

1.声明值和变量

vara=12//定义变量vary

valb=23//定义常量：value

2.有趣的语法特性

在scala的变量声明时，可以不指定类型，由解释器自己判断。
“superman”*3//表示字符串“superman”反复输出3次
“superman”*3//实际上是字符串“superman”调用方法*，传入的参数是3

3.函数：

函数在声明后，无论是否有“=”，都有返回值。当没有“=”的时候，表示返回值是Unit类型，Unit类型的值是()。当有“=”的时候，返回值是函数体中的最后一行的值。如果返回值类型强制指定为Unit类型，那么返回值必定是()。

4.判断：

/**
*判断if
*/
objectTest21extendsApp{
defjudge(a:Int):Int={
if(a>0){
1//return相当于函数版的break语句
}elseif(a<0){
-1
}else{
0
}
}

varc=judge(-3)
println(c)
}

/** *while和for循环 */ objectTest22extendsApp{ /*while循环*/ //while(true){ //println("hello") //} /*for循环scala中的for基本形态*/ //for(inti=0;i<5;i++)//java的for循环 //for(i:List)//增强for //println(1to10)//Range(1,2,3,4,5,6,7,8,9,10) //for(i<-1to10){//闭区间 //println(i) //} //for(i<-1until10){//开区间 //println(i) //} //for(i<-1until10reverse){//倒序不能使用10to1 //println(i) //} /*高级for循环*/ //守卫 //for(i<-1to10reverse;ifi%3==0){ //println(i) //} //for(i<-1to(10,3)){//改变步长 //println(i) //} //for(i<-1to10;j<-1to5){//双重for循环 //println(i+"-"+j) //} ////for的推导式 //varc=for(i<-1to10)yield(i*2) //println(c)

/** *数组 */ objectTest31extendsApp{ /*定长数组*/ //使用new定义数组 //vararr1=newArray[Int](5) //arr1(1)=2 ////println(arr1) //for(i<-arr1){ //println(i) //} //使用Array类进行定义 vararr2=Array(1,2,3,4,"hehe") //for(i<-arr2){ //println(i) //} //println(arr2.min) //println(arr2.max) //println(arr2.sum) //println(arr2.mkString("[",",","]"))//Arrays.toString(arr)[1,2,3] /*变长数组*/ //vararrbuf1=ArrayBuffer(1,2,3,4) //arrbuf1+=5 //arrbuf1-=3 //arrbuf1++=Array(3,4,5) //arrbuf1--=Array(3,4,5) //arrbuf1.toArray //println(arrbuf1.mkString(",")) //vararrB=arr2.toBuffer //arrB+=9 //println(arrB.mkString(",")) //filter和map用法 vararr4=Array(1,2,3,4,5) vararr5=arr4.filter(_%2==0).map(_*2) println(arr5.mkString(",")) }

**
*映射
*/
objectTest32extendsApp{
/*不可变的映射*/
//(zhangsan,18)键值对称作对偶用()表示
varmap1=Map[String,Int](("zhangsan",18),("lisi",19))
map1+=("wangwu"->80)
//map1("zhangsan")=12
map1+=("zhangsan"->20)
//println(map1("zhangsan"))
//for(i<-map1){
//println(i)
//}

//if(map1.contains("zhaoliu"))
//println(map1("zhaoliu"))

/*可变的映射*/
//varmapB=scala.collection.mutable.Map[String,Int]("zhangsan"->20,"lisi"->12)
//mapB("zhangsan")=30
//for(i<-mapB){
//println(i)
//}

/*与java的互操作*/
//varlist=newArrayList[Int]
//list.add(1)
//list.add(2)
//
//for(i<-0tolist.size()-1){
//println(list.get(i))
//}

/*map其他遍历方式*/

//for((k,v)<-map1){//方式一
//println(k+"->"+v)
//}

//方式二
varset1=map1.keys
varset2=map1.keySet
for(i<-set1){
println(map1(i))
}
//println(set2)

/**
*元组
*/
objectTest33extendsApp{

//元组定义
//对偶(使用“()”表示)只是元组最简单的形式使用（）表示
vart=(1,2,3,4)
//for(i<-t){//元组不能使用for遍历
//println(i)
//}

//println(t_3)//元组的下标从1开始
//println(t_1)//元组的下标从1开始

var(first,second,third,forth)=t
//var(first,second,third,_)=t
//println(second)

vars="HelloWorld!"
//println(s.partition(_.isUpper))

//拉链操作
vararr1=Array(1,2,3,4,5,6)
vararr2=Array("a","b","c","d","e")
vararr3=arr1.zip(arr2)//
//for(i<-arr3){
//println(i)
//}
println(arr3.mkString(","))
varmap=arr3.toMap//map
for(i<-map){
println(i)
}

/**
*类的基本内容
*/

classTestClass41{
//@BeanPropertyvarmonary=100
varmonary=100

//defshow{
//println("hello")
//}
}

objectTest41extendsApp{

vara=newTestClass41()//实例化一个类
a.monary=200
println(a.monary)
//println(a.show)

//scala使用var定义字段默认生成对应的setter和getter方法对应的名称monary_=和monary

//asetMonary300
//println(agetMonary)

//使用val定义字段的时候scala不在提供setter方法

//@BeanProperty和private不能同时共用

}

/**
*类的基本内容2
*/
classTestClass42{
privatevarmonary=0

defsetMonary(a:Int){//自定义setter方法
if(a>0)
this.monary=a
}

defgetMonary={//自定义getter方法
this.monary
}

}

objectTest42extendsApp{
varc=newTestClass42
csetMonary-1000
println(cgetMonary)

}

/**
*类的构造器
*/
//classTestClass43(varname:String="xxx",varage:Int=0){//主构造器带参数称为默认值
//
////varname:String//需要初始化
////varage:Int
////publicTestClass43{}//java的构造器写法
//println("name="+name)
//println("age="+age)
//
//}

classTestClass43{//辅助构造器
varname:String="lisi"//需要初始化
varage:Int=0

defthis(name:String){
this()//辅助构造器第一行要调用主构造器
this.name=name
println("第一个辅助构造器")
}

defthis(name:String,age:Int){
this(name)//还可以调用其他辅助构造器
this.name=name
this.age=age
println("第二个辅助构造器")
}

println("name="+name+"age="+age)

defshow={
"name!="+name+"age!="+age
}
}

objectTest43extendsApp{
varc=newTestClass43("wangwu",90)
//println("name="+c.name)
//println("age="+c.age)

println(c.show)

}

/**
*伴生对象
*/

classTestObject51{
privatevarvalue=10
defdisplay{
println(TestObject51.value)
}

defshow(a:TestObject51){//自定义getter方法
this.value=TestObject51.value
}
}

/*伴生对象*/
objectTestObject51{//对象使用object定义
//该对象作为同名类的伴生对象
//private[this]varvalue=10
privatevarvalue=10

privatedefshow{
println("超人")
}
}

objectTest51extendsApp{

//println(TestObject51.value)//不能访问对象中的私有字段
//println(TestObject51.show)

}

/**
*高阶函数
*/

objectTest61extendsApp{
//函数定义
defadd(a:Int,b:Int)={
a+b
}
//varc=add(1,2)
//println(c)

varfunc1=add_//把一个函数的实现传递给另外一个函数
//println(func1(1,2))

//varfunc2=(x:Int)=>x+3//传递一个匿名函数给给一个变量
//varfunc3=(x:Int)=>{x+3}//传递一个匿名函数给给一个变量
//varfunc4=(x:Int)=>(x+3)//传递一个匿名函数给给一个变量

//for(i<-arr)
//Map[String,Int]("zhangsan"->12)
//println(func2(3))

//deffunc5(a:Int,f:(Int)=>(Int))={
//f(a)+1
//}
//println(func5(4,(x:Int)=>{x+2}))//传递一个匿名函数给该函数

//调用函数封装举例
//defCPU(a:Int)={
//a*8
//}
//defGPU(a:Int)={
//a+9
//}
//defcompute(men:Int,CPU:(Int)=>(Int),GPU:(Int)=>(Int))={
//men+CPU(2)+GPU(2)
//}
//println(compute(4,CPU,GPU))

deffunc6(f:(Int)=>(Int))={
f(1)
}
//println(func6(_+2))//简写条件：1.只有一行代码2.只有一个形参3.把匿名函数作为形参
//println(func6(_+_))

//总结“_”:
//1.代表数组每一个元素
//2.指的是传递是确切的一个函数而不是忘记给该函数传递参数
//3.元组的元素取值

//思考题
//deffunc7(x:Int,y:Int)={
//(y:Int)=>{
//x+y
//}+2
//}
//println(func7(3,4)(2))

//一些有用的函数mapforeachreduceLeft
//(1to9).map("*"*_).foreach(println_)

varc=(1to3).reduceLeft(_+_)//1+2+3
println(c)

}

.csharpcode,.csharpcodepre
{
font-size:small;
color:black;
font-family:consolas,"CourierNew",courier,monospace;
background-color:#ffffff;
/*white-space:pre;*/
}
.csharpcodepre{margin:0em;}
.csharpcode.rem{color:#008000;}
.csharpcode.kwrd{color:#0000ff;}
.csharpcode.str{color:#006080;}
.csharpcode.op{color:#0000c0;}
.csharpcode.preproc{color:#cc6633;}
.csharpcode.asp{background-color:#ffff00;}
.csharpcode.html{color:#800000;}
.csharpcode.attr{color:#ff0000;}
.csharpcode.alt
{
background-color:#f4f4f4;
width:100%;
margin:0em;
}
.csharpcode.lnum{color:#606060;}

/**
*继承--抽象类
*/

abstractclassPerson{
//抽象类不一定有抽象字段或者抽象方法
//有抽象字段或者抽象方法的类一定是抽象类
varname:String
valage:Int
defstory:String
}

//方式一
//classStudentextendsPerson{//覆盖字段时实质上是覆盖了字段setter、getter方法
//varname:String="Jeckson"//var定义的字段只能使用var覆盖，并且var覆盖只能是为实现的字段
//valage:Int=20//使用val定义的字段只能使用val覆盖
////defstory="dance"//
//defstory="dance"//使用def定义的抽象方法可以使用def覆盖也可以使用val，当def为无参时函数可以使用val
//}

//方式二
//classStudent(varname:String="Jeckson",valage:Int=20,valstory:String="dance")extendsPerson

objectTest71extendsApp{
//varc=newStudent
//println(c.name)
//println(c.age)
//println(c.story)

varc=newPerson{//方式三匿名子类
varname:String="Jeckson"//var定义的字段只能使用var覆盖，并且var覆盖只能是为实现的字段
valage:Int=20//使用val定义的字段只能使用val覆盖
defstory="dance"//
}
}

/**
*构造顺序
*/
classPerson1{
valage:Int=10
vararr:Array[Int]=newArray[Int](age)//调age字段的getter方法
}

//classstudent1extendsPerson1{
//overridelazyvalage:Int=18//如果覆盖的父类不是抽象类必须要写override
//}

classstudent1extends{//解决办法③
overridevalage:Int=18//如果覆盖的父类不是抽象类必须要写override
}withPerson1

//特质
/*traitstudent2{
vara:Int=10
varb:Int
}
traitstudent3{
defshow="123"
}
classstudent4extendsstudent2withstudent3{
varb:Int=1
}*/

objectTest72extendsApp{
varc=newstudent1
println(c.age)
println(c.arr.length)
//输出180解决办法：1.字段前面添加final2.字段前面添加lazy3.解决办法③
//原因:
//a.主构造器和class类交织在一起
//b.子类中使用了override覆盖超类中的字段，构造子类时超类的字段值会被覆盖
//c.student1类作为student1的主构造器，调用了超类的Person1的主构造器
//d.首先，构造器将age值设置为10
//e.接着代码往下走，为了初始化arr数组，调用了age的getter方法
//f.而age字段被重写了，也就是说getter方法被重写了
//g.被重写的getter方法还没有被初始化，确切说就是字段age还是对象在被分配空间时所有整型字段的初始值
//h.arr数组长度被设置为0
//i.子类Student1类构造器执行，age被赋值为18
}

objectTest73extendsApp{
//vart=(1,2,3)
//var(first,second,third)=t//模式匹配
//println(first)

vars="++"

varresult=smatch{
case"a"=>println("超人")
case"*"=>1
case"牛人"=>"superman"
case_ifs.contains("=")=>(x:Int)=>{x+1}
case_=>0
}

println(result)
}