大数据系列第一课：scala基础

内容：
1 Scala的重大价值

2 Scala基础语法入门实战

3 Scala函数入门实战

4 Scala中Array、Map、Tuple实战

5 综合案例及Spark源码解析

一、scala价值

Scala可伸缩的语言的英语翻译是：Scalable Language。它是一门多范式的编程语言，一种类似java的编程语言，集成面向对象编程和函数式编程的各种特性并完美结合，熟练掌握scala对于学习spark来说至关重要。

二、Scala函数定义：

（scala函数定义时候默认会导入包）

有参数的函数定义

def 函数名（参数列表，...)：返回结果类型={...}

①　有时函数必须制定返回结果类型，如函数时递归，就必须明确制定返回结果类型；

②　如果函数仅一个语句，连花括号都可以不写。如是max函数就成了这样,作用功能仍然没有变化；

③　Scala语言在进行函数调用时可不加（）；

④　Scala语言在编写的时候亦可以不用加“；”

⑤　Scala中，i++或者++i都不能其作用，只能使用i=i+1

⑥　foreach与函数字面量

函数字面量格式：参数列表 => 函数体

(x: Int, y:Int) => x + y

三、字段定义

（1）val:类似java中final类型的变量（常量）

1，基本格式：val 变量名：变量类型 = 值

2，其中有时变量类型可以省略，可以自动识别

3，常量不能赋值，修改

（2）var:等同于java中的非final型变量

四、scala中的Array、Map、Tuple以及代码实战

(1)

//函数返回 Any(任何类型)
def main(args: Array[String]): Unit = {
val n =7
def fun :Any = {
for(i <- 1 to 10){
if(i == n) return i
print(i + " ")
}
}
//调用
fun
}

(2)

//a、变长参数；b、最后一行作为返回值；c、遍历输入变长参数方法
def main(args: Array[String]): Unit = {
defsum(numbers : Int*) = {
var result = 0
for(elem <- numbers) result += elem
result //最后一行作为返回值
}
//函数调用
println(sum(1,2,3,4,5,6,7,8,9,10))
println(sum(1 to 100 : _*))//遍历输入变长参数方法
}

(3)

//a、lazy关键字的使用；b、异常判断；c、远程调用和数据库最后要进行关闭
import scala.io.Source._
import scala.io._
import java.io.FileNotFoundException
def main(args: Array[String]): Unit = {
try{
lazy val context = fromFile("d:/3.txt").mkString //lazy关键字的使用
}catch{
case _: FileNotFoundException => println("file not found")//异常判断
}finally{
println("Byebye world!!")//远程调用和数据库最后要进行关闭
}
}

(4)

//a、对象的地址不能改变，内容可以改变；b、默认调用apply方法
def main(args: Array[String]): Unit = {
val arr =new Array[Int](5)
arr(3) = 8//对象的地址不能改变，内容可以改变
println(arr(3))

val arr2 =Array(1,3,5,7,9)
val arr3 =Array.apply(1,3,5,7,9)//arr2默认调用apply方法
}

(5)

//排序
def main(args: Array[String]): Unit = {
val arr =Array(1,13,9,23,5,27,7)
scala.util.Sorting.quickSort(arr)//排序
println(arr.mkString)//mkString默认实现
println(arr.mkString(" "))
}

(6)

//过滤数据并生成新的数组
def main(args: Array[String]): Unit = {
val arr =Array(1,13,9,23,5,27,7)

val arr2 =for(i <- arr if i % 3 == 0) yield i * i
val arr3 =arr.filter(_ % 3 == 0).map(i => i * i) //spark中使用这个

println(arr2.mkString(" "))
println(arr3.mkString(" "))
}

(7)

//数组操作
def main(args: Array[String]): Unit = {
val arr =Array(1,4,9,2,5,8,7)

for(elem<- arr) print(elem + " ")//原样输出
println()

for(i <-1 until(arr.length, 1)) print(arr(i) + "")//从下标为1的元素开始，步长为1进行输出
println()

for(i <-1 until(arr.length, 2)) print(arr(i) + "")//从下标为2的元素开始，步长为2进行输出
println()

for(i <-0 until(arr.length, 2)) print(arr(i) + "")//从下标为0的元素开始，步长为2进行输出
println()

for(i <-(0 until arr.length).reverse) print(arr(i) + " ")//反向输出
}

(8)

//Map操作
def main(args: Array[String]): Unit = {
//构造Map
//不可变：
//val map0 =Map("sa" -> 1, "s" -> 2) map0("sa") = 3 // error
valemptyMap0 = new scala.collection.immutable.HashMap[String,Int]
//可变：
val map1 =scala.collection.mutable.Map("sa" -> 2);map1("sa") = 3
valemptyMap1 = new scala.collection.mutable.HashMap[String, Int]

val persons= Map("Spark" -> 6, "Hadoop" -> 11)
println(persons("Hadoop"))
val map =scala.collection.mutable.Map("Spark" -> 6, "Hadoop" ->11)
map +=("Flink" -> 5)
map -="Hadoop"
println(map)

valsparkValue = if(map.contains("Spark")) map("Spark") else 1000
println(sparkValue)

valsparkValue2 = map.getOrElse("Spark", 1000)
println(sparkValue2)

valsparkValue3 = map.getOrElse("Hadoop", 1000)
println(sparkValue3)

for((key,value) <- map) println(key + " : " + value)

for(key<- map.keySet) println(key)
}

(9)

//元组Tuple操作
def main(args: Array[String]): Unit = {
//不同类型值的集合
val tp = (1,"ss", 2.0)

//拉链操作
val arrkey =Array(1, 3, 5)
val arrValue= Array("a", "b", "c")
val tupleArr= arrkey.zip(arrValue) // tupleArr为Array((1,a), (3,b), (5,c))
val map =tupleArr.toMap
}

（10）map

Map就是键值对的集合。在Scala中，Map是对偶（键值对的另一个说法）的集合。->操作符用来创建对偶，即key和values。

def main(args: Array[String]): Unit = {
/*
* Map:映射，把值和集合中的元素联系起来，使用任意类型的键
*/
val map1 = Map{"hadoop"->1 }
map1 + ("spark"->2)
map1("spark")=3          //更改已有的值
map1.contains("scala")     //检查是否包含
map1.keySet                //返回key集合
//添加多个对偶，使用“+=”操作符：
map1+=("Flink"->3,"Hbase"->5)
//移除某个对偶，使用“-=”操作符：
map1-="hadoop"
import scala.collection.mutable._
val map2 = mutable.Map.empty[String,Int]//创建空map
}

（11）List

List列表（不可变）

1，类型都是相同的

2，不可变的，（Array虽然长度固定，但是元素之使可变的）

3，(：：：)实现叠加List,(::)cons:将新元素组合到列表的最前端

def main(args: Array[String]): Unit = {
/*
* List:支持头部的快速删除和添加,不可变，列表的所有元素都具有相同类型，类似于数组Array
*/
val color =  List("yellow","blue")
val list2 = (1,2,3)
var list3 = 4
def list4:Int = 5
/*
* listBuffer：可以更加高效的通过添加元素的方式构建列表
* 元素的添加使用+=操作符
* 元素的前缀使用+:操作符
*/
import scala.collection.mutable.ListBuffer
val li= new ListBuffer[Int]
li+= 1
li +=2
3+:li
li.toList
println(li(2))
}

（12）Array数组

def main(args: Array[String]): Unit = {
/*
* Array:使用基于0的索引高效访问任意位置的元素
*/
val array1 = Array[Int](1,2,3,4,54,5,5)
val array3 =  new Array[Int](3) //创建长度已知，内容未知
println(array3(2))
array1.clone()
array1.length
var array = array1
/*
* ArrayBuffer：类似于数组，可以在序列的结束和开始的地方添加元素
* 创建ArrayBuffer的时候必须指定它的类型参数，可以不指定数组的长度
* ArrayBuffer也使用+=添加元素
*/
import scala.collection.mutable.ArrayBuffer
val ar= new ArrayBuffer[String]()
ar += "hadoop"
ar += "Spark"
ar +: "scala"
li.length
li(2)
Ar.remove(2,1)
}

（13）Tuple元组（不可变）
在Scala中，元组是n个对象的一个聚集（Map是n=2个对象的聚集），元组可以包含不同类型的元素。

1，元组也是不可变的，但是元组可以是不同类型的数据

2，实例化：var a = （，）

3,可以通过点号，下划线，-N（N从1开始）的索引访问元素

def main(args: Array[String]): Unit = {
/*
* Tuple:元组，把固定数量的条木组合在一起整体传送，可以包含不同       *的类型
*/
val tuple = (1,"spark",true)
tuple._1
tuple._2
tuple.->(1)
}

五、感受
a、听课之前需要提前做功课，信息量较大；

b、课后要强化练习，并消化；

c、本节课老师即兴发挥，讲了很多实用的知识点；

d、很喜欢老师一行一行写代码；

e、讲解很深入，实用，实战性极强

f、喜欢跟着老师看源码

六、作业

//作业之一：移除一个数组中第一个负数后的所有负数
import scala.collection.mutable.ArrayBuffer
object Task {

def main(args: Array[String]): Unit = {
//第一个负数后的所有负数
val arr =ArrayBuffer[Int]()
arr  += (1,2,3,4,-9,9,-4,8,-6)

var n =0
//返回的结果是一个vector集合
val result =for (i <- 0 until arr.length if n == 0 || arr(i) >= 0) yield{
if (arr(i) < 0) n = 1; arr(i)
}
//输出结果
print(result)
}
}