大数据系列第一课：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。
（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开始）的索引访问元素
五、感受 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)
}
}