王家林老师Spark学习第一课



2016年1月1日，是一个值得纪念的日子，当身边的亲朋好友还沉浸在欢度新年到来的时候，我却满怀激动的坐在电脑前等待期待已久的王家林老师的spark学习。在这个虚拟的世界感受着志同道合的战友你追我赶的学习氛围，我很庆幸自己是其中的一份子。被王老师的坚持感动的同时，也激励着自己永不停歇的步伐。

Hadoop和Spark都是基于JVM的，这样的好处就是屏蔽了系统之间的差异

Java和Scala的关系：

1、 Scala是基于JVM的，Scala可以调用Java的一切功能

2、 Scala是纯面向对象的可以便于组织工程，也是函数式编程用于实现功能

 Scala中的变量分为两种类型

1、val（不可变的变量，建议使用）：不能被重新赋值

val result = 10

 2、var ： var的数据类型可以根据值推断

类型也可以手动指定­——val age :Int = 18

一行可以声明多个变量并赋值——val age1,age2,age3 = 18

1.  +(2)——1是对象，+是方法，2是参数

 apply方法的调用：

Array(1,2,3,4)

Array.apply(1,2,3,4)

 表达式可以赋值给变量：

if ( age > 18) "adult" else "child"

val result = if ( age > 18) "adult" else "child"

 代码块的值为最后一行代码的值：

val buffer1 = 10

val result1 = if (age > 18) {

"adult"

buffer1

} 

 换行：

println("Spark")

println("\nSpark")

 readLine：输入，没有参数时可以省略后面的（）

readLine   readInt  readLine(“please enter your password:”)

 <-：提取range中每一个元素

for (i <- 0 to element) println(i)

 元素的过滤条件：

for (i <- 0 to element if i % 2 ==0) println(i)

 函数的定义（p2有默认值）：

def fi(p1: String,p2:Int = 30) = p1 + p2

 p2使用默认值30：

f1(“Spark”)

 p2赋新值20：

f1(“Spark”, 20)

 与实参的赋值顺序无关：

f(p2 = 20,p1 = “Spark”)

 变长参数（*表示参数的个数可以是多个）：

Def sum(number: Int* ) = {var result = 0; for(element <- number) result += element; result}

Sum(1,2,3,4,5)

 计算1+2+3+...+100的和（表示提取1到100的每一个元素）：

Sum(1 to 100: _*)

 过程没有返回值类型：

def morning1(content:String) = "Good " + content

morning1("morning")

def morning2(content:String) {println( "Good " + content)}

morning2("morning")

def morning3(content:String):Unit = "Good " + content

morning3("morning")

 Lazy

由于文件不存在，会报异常：

val content = fromFile("f:/abc.txt")

Lazy后会延迟执行:

lazy val content = fromFile("f:/abc.txt")

 捕获异常：

try{

val content = fromFile(""f:/abc.txt")

}catch{

case _: java.io.FileNotFoundExeception => println("file not found")

}finally{

print("bye!")

 数组声明：

Int——元素类型，(5)——元素个数

val arr1 = new Array [Int] (5)

数组的访问，下标从0开始：

arr1(4)

 数组的赋值：

arr1(3) = 5

 定长数组：

Val arr2 = Array("Spark", "Scala")

 变长数组：

import scala.collection.mutable.ArrayBuffer

val arr3 = ArrayBuffer [Int] ()

 添加元素：

arr3 += 10

 添加多个元素：

arr3 += (12,10,3) 

添加数组：

arr3 ++= Array(5,7,8)

 arr3(2)插入20：

arr3.insert(2,20)

 移除arr3(3)的元素（下标从0开始）：

arr3.remove(3)

 转换为定长数组：

arr3.toArray

 遍历所有元素：

for (elem <- arr3) println(elem)

 下标从0开始，每间隔一个元素输出：

for (i <- 0 until (arr3.length,2)) println(arr3(i))

 逆序遍历元组：

for (i <- (0 until arr3.length).reverse) println(arr3(i))

 定长数组排序：

val a = Array (3,2,7,1)

scala.util.Sorting.quicksort(a)

 数组算法：

arr3.sum  arr3.max  arr3.mkString  arr3.mkString(“ “ )

 每一个元素组拼成新的元素：

val a1 = for (i <- a ) yield i * i

过滤条件:

val a2 = for (i <- a if i %3 == 0) yield i *

a.filter(_ % 3 == 0).map(i => i * i

 Map(键，值)：

val person1 = Map("Spark" -> 6, "Hadoop" -> 11)

访问：

person1("Hadoop")

 可变Map：

val p = scala.collection.mutable.Map("Tom" -> 5,"Jack" -> 10)

 添加映射：

p += ("Jerry" -> 20)

 移除映射：

p -= "Jerry"

 修改键值：

p("Tom") = 18

 是否包含值：

Val p1 = if （p.contains(“tom”) ) p("tom") else 0

快捷写法：val p2 = p.getOrElse(“tom”，0)

 遍历映射：

for（(key,value) <- p） println(key + value)

 只遍历key：

for（(key,_) <- p） println(key)

for（(key,_) <- p.keySet） println(key)

 遍历value：

for((_,value) <- p) println(value)

for(value ,<- p.values) println(value)