scala
开发spark可以使用哪些语言：
Python开发45%
scala 35%
java 20%
一、scala的概述
java基础上代码的简化版、功能的加强版
隐式转换
高阶函数
一个函数的参数是另一个函数 ，或者是返回值是一个函数
1、scala继承了面向对象编程和面向函数式编程的各种特征，在2003年发布了基础java的第一个版本
Object-Oriented Meets Functional
scala 优雅 简洁 强大
基于spark的开发使用scala语言实现wordcount
sc.textFile("/user/beifeng/input/wc.txt") //RDD[String]
.flatMap(x=>x.split(" ")) // Array[(String)]
.map(x=>(x,1)) //Array[(String,Int)]
.reduceByKey((x,y)=>(x+y)) //Array[(String,Int)]
.saveAs("/user/beifeng/output1")
hadoop hive hive spark
oozie flume
Array(hadoop hive hive spark oozie flume )
Array[(hadoop,1), (hive,1), hive spark oozie flume ]
2、scala和java可以互操作
java和scala共用jvm平台
scala使用scalac编译器将源码编译成java的class文件
可以在scala代码中直接调用所有的java类库
也可以在java的代码中插入一段scala代码
3、函数式链式编程一些以函数和对象两方面为主
函数在scala中是一等公民
函数可以被当做参数进行传递
函数可以做为一个函数的返回值返回
可以在函数中定义另一函数
重点：
模式匹配
高阶函数
匿名函数
隐式转换
将一种数据类型偷偷转换成另一种数据类型
trait类
接口
二、scala安装部署
下载路径：http://www.scala-lang.org/download/2.10.4.html
window下：
java需求提前配置好
scala配置：
scala-2.10.4.zip 解压到某个路径下
配置环境变量：
JAVA_HOME XXX
SCALA_HOME XXX
PATH %JAVA_HOME%/bin;%SCALA_HOME%/bin
linux：
三、scala基本使用
交互式命令行 -》 REPl l->loop
scala是一种强类型语言
但是scala可以自动推断数据类型
scala> val b = 3
b: Int = 3
scala> b+5
res0: Int = 8 //res0是系统提供的临时变量
scala> res0+1
res1: Int = 9
scala> println("hello world")
hello world
scala写第一个程序
object HelloWorld {
def main(args:Array[String]) {
println("Hello,world!!!")
}
}
$ scalac HelloWorld.scala
$ scala HelloWorld
四、安装部署IDEA工具
window/linux 版本
window：
安装前一定要配置好scala和java的环境变量
启动-》选择主题-》都是下一步（不要选择任何插件）-》start
集成scala插件：
configure-》plugins-》install form disk -》选择scala插件-》重启
Setting：
appreance-》设置系统字体及主题
keymap -》 设置快捷键风格-》eclipse
editor->font->save as -> 设置代码字体风格
create new project
scala -》设置项目名称及工程目录 -》选择本地安装的jdk的sdk
五、scala中变量的定义、数据类型、函数的定义及函数的参数类型
1、变量的定义
使用val声明一个不可变变量
scala> val a:Int=3
a: Int = 3
scala> a=4 //val声明的变量不能重新赋值
<console>:8: error: reassignment to val
a=4
^
使用var声明一个可变变量
scala> var c = 6
c: Int = 6
scala> c = 7
c: Int = 7
在scala中声明变量的语法
val/var a:Int=3
语法：
关键字（val/var）+ 变量名:数据类型（首写字母大写） = 值
2、scala中如何先定义一个为空值的变量
scala> var name:String //报错，需要给变量一个初始化值
解决：
scala> var name:String = ""
scala> var name1:String = _
3、scala中的数据类型
在scala中没有基本数据量和包装类之分，所有的数据类型都是类
首写字母需要大写
4、scala中的lazy 懒执行
当val修饰的变量被lazy修饰时，它的初始化将被推迟，直到第一次去调用
scala> lazy val price = 15.8
price: Double = <lazy> //此时没有将15.8赋值给price
scala> price //当第一次去调用 price时系统才会进行赋值操作
res3: Double = 15.8
scala> lazy var price1 = 15.8
<console>:1: error: lazy not allowed here. Only vals can be lazy
lazy var price1 = 15.8
^
5、scala中函数的定义
def 函数名称（参数名称：参数类型）：返回类型 = {
函数体内容
}
因为scala可以自动推断数据类型，所以函数的返回值类型一般可以直接省略
def min(x:Int,y:Int):Int = {
if (x>y)
y
else
x
}
6、文件编辑软件sublime介绍
查看-》语法-》scala
7、当定义的函数为空参时，调用该函数时可以省略函数的括号
def hello()={println("hello!!!")}
def hello() = println("hello!!!") //当函数体只有一句时可以省略大括号
hello()
hello
def hello():Unit = println("hello!!!")
Unit在scala中表示无返回值类型，相当于java的void
8、函数中定义另一个函数
函数的嵌套或闭包
内函数可以调用外函数的变量
def fun1(a: Int) = {
def fun2(b: Int) = {
println("a+b=" + (a + b))
}
fun2(200)
}
fun1(20)
scala> :paste //进入到粘贴模式
(ctrl-D to finish)
scala> fun1(100)
a+b=300
9、匿名函数
定义： (x:Int)=>{x+1}
语法：（变量名：数据类型，...）=> { 函数体内容 }
匿名函数的特点：
1、匿名函数可以赋值给一个函数
def add=(x:Int,y:Int)=>{x+y}
add(3,8)
2、匿名函数可以赋值给一个变量
val add=(x:Int,y:Int)=>{x+y}
add(3,6)
考虑如何将一个非匿名函数赋值给一个变量 ？
def add(x: Int, y: Int) = x + y
val add1=add _ //函数名+空格+占位符
add1(3,8)
10、在scala的函数中可以指定参数的默认值（缺省值）
def path(p: String="Desttop") = {
println("the path is " + p)
}
path() //当传入参数时，会使用参数的默认值
def loadConf(conf:String="spark-defalut.xml")={
println("conf is "+conf )
}
11、scala中可以使用*代表传入的参数为重复参数（变长参数）
def printName(name:String*)={
println("the name is "+name)
}
printName("zhangsan","lili","wangwu")
val arr=Array("lili","tom","mary")
printName(arr:_*)//通过声明arr为_*，表示告诉编译器我们传入的是一个个String类型的元素，而不是一个Array[String]
六、scala中的流程控制语句及循环表达式
while
do while
for
breaks
1、
val list=List("tom","mary","lio","lili") //定义一个List集合不用使用new，使用的是List类的伴生对象里面的apply方法，通过apply方法帮我们new的List对象
val list = List("tom", "mary", "lio", "lili")
var x = 0
while (x < list.length) {
println(list(x))
x += 1
}
for (x <- list) {
println(x)
}
“<-”是一个提取符，可以从集合中遍历提取出所有的元素
break() 方法演示
object LoopTest {
def main(args: Array[String]) {
val list = List("tom", "mary", "lio", "lili")
val loop = new Breaks
loop.breakable {
for (x <- list) {
println(x)
if (x == "mary")
loop.break()
}
}
println("over........")
}
}
-----------------------------------
2、scala中的循环表达式
1 to 10 //包头包尾
1.to(10)
1 until 10 //包头不包尾
1.until(10)
Range(1,10) //包头不包尾
Range(1,-10,-3) //可以给出step步长
Range(1,-10,0) //java.lang.IllegalArgumentException: step cannot be 0.
结合for循环使用循环表达式
for (x<- 1.to(10)){
println(x)
}
求1到10范围内的偶数
for (x<- 1.to(10) if x%2==0 ){
println(x)
}
七、元组 tuple
元组的定义 使用 括号 ()
val tuple = (1, 3, "tom", 3.3, "lili")
tuple._1 //元组元素的获取
tuple._3
总结 ：
元组类型是scala和Python里特有
在scala中，元组是n个不同数据类型对象的一个聚集
n的最大的值是22
Map的元素实际上是n=2的元组 ，即2元组 ，也是最简单的元组
元组必须使用()来表示
元组元素的遍历
val tuple = (1, 3, "tom", 3.3, "lili")
for (x<- 0 to tuple.productArity ) { //使用to为什么会报错
println(tuple.productElement(x))
}
for (x<- 0 until tuple.productArity ) { // until不报错
println(tuple.productElement(x))
}
八、scala中的数组
1、scala中数组的特点
数组是相同数据类型固定大小的元素的连续集合
数组的元素的角标从0开始
数组的定义
val arr=Array(33,11,66,88)
2、数组分为定长数组和变长数组
定长数组
val arr=Array(33,11,66,88) //默认是定长数组
数组的取值
arr(0)
arr(2)
定长数组不支持更改数组元素长度或值的方法
变长数组
val arr1=scala.collection.mutable.ArrayBuffer(11,22,44)
import scala.collection.mutable.ArrayBuffer
val arr2=ArrayBuffer(55,99)
添加元素
val arr1 = scala.collection.mutable.ArrayBuffer(11, 22, 44)
val arr = Array(111, 222)
arr1 += 55
arr1
arr1 +=(66, 77)
arr1 ++= arr
减去元素
-=/--=
变长数组可以使用的更改元素内容的方法
arr1.insert(0,77,88)
arr1
arr1.remove(3)
arr1
arr1.trimEnd(2)
arr1
arr1.toArray //变长数组转定长数组
3、数组的遍历
for (x <- 0 until arr1.length) {
println(arr1(x))
}
for (x <-arr1){
println(x)
}
4、其他常用方法
排序：
val arr1 = scala.collection.mutable.ArrayBuffer(55,11, 22, 44)
val arr2=arr1.toArray
scala.util.Sorting.quickSort(arr2) //原来的数组变了
arr2
arr1.sorted //默认是升序排序，返回一个新的排好序的数组 ，原来的不变
转换为字符串
arr1.mkString("，")
arr1.mkString("【",",","】") //res1: String = 【55,11,22,44】
九、scala中的集合
scala中所有的集合类都在 scala.collection 包下
scala.collection.mutable 包下是可变集合
可变集合可以进行修改、添加、删除等操作，且是在原集合基础上进行的更新操作
scala.collection.immutable 包下是不变集合
不可变集合也可以模拟修改、添加、删除等操作，但是每次操作不是在原来集合基础上的更新操作，每次都会生产一个新的集合
1、定长List集合
定长list集合的定义：
val list = List(33,55,77,11)
list.head //返回第一个元素的值
list.tail //返回除第一个元素外的其他元素的集合
Nil //代表一个空的List集合
总结List集合是由head头和tail尾组成的
向定长list集合添加元素
val list1=88::list //添加元素后生产了一个新的list集合，原list集合元素没有变化
val list2 =99::111::222::list
val list3=555::Nil //通过这种方法也能创建一个list集合
删除list集合的元素
list.drop(3) //表示从左数删除3个元素
原list集合元素没有变化
2、变长list集合
定义
val list=scala.collection.mutable.ListBuffer(44,11,88)
添加元素（都是在原集合基础上进行的更新操作）
list += 111
list+=(444,666)
list++= list1
删除元素
-=/--=
变长list集合的转换
list.toList 定长list集合
list.toArray 定长数组
list集合的遍历
for (x<-list){
println(x)
}
list集合其他常用方法
list.exists((x:Int)=> {x>55}) //通过exists方法判断list集合里面有没有大于55的元素
简化：
list.exists((x:Int)=> x>55 )
list.exists((x)=> x>55) //scala可以自动推断数据类型
list.exists(x=> x>55 ) //只有一个参数时可以省略括号
list.exists(_ > 55 ) //当匿名函数的参数在函数体中只调用一次时可以这样写
list.filter(_ > 20) //过滤出大于20的元素
3、Set
PPT 参考list array
4、不可变Map集合
定义：
val map=Map("lili"->18,"tom"->19,"mary"->17)
获取value
map("tom")
map("mary")
//map("wangwu")
//方法一
if (map.contains("wangwu"))
map("wangwu")
else
-1
//方法二
map.getOrElse("lili",-1)
5、可变map集合
定义
val map1=scala.collection.mutable.Map("lili"->18,"tom"->19,"mary"->17)
更新或添加元素
map1("lili")=19
map1("lio")=21
map1 +=("zhaosi"->23)
map集合的遍历
for ((x, y) <- map1) {
println("key is " + x + ",value is " + y)
}
for ((key, _) <- map1) {
println("key is " + key)
}
for ((_, value) <- map1) {
println("value is " + value)
}
for (values <- map1.values){
println("value is " + values)
}
比较安全的遍历方法
for((key,value)<-map1){
println("key is " + key+ ",value is " + map1.getOrElse(key,-1))
}
map集合的排序
map1.toList.sorted.toMap
