第1讲：大数据最火爆语言Scala光速入门

最新推荐文章于 2022-04-26 12:25:14 发布

一叶扁舟yis

最新推荐文章于 2022-04-26 12:25:14 发布

阅读量1.1k

点赞数 1

分类专栏： Spark学习文章标签： spark scala

本文链接：https://blog.csdn.net/Diamonds_ys/article/details/52329284

版权

Spark学习专栏收录该内容

9 篇文章 0 订阅

订阅专栏

第一阶段：Spark streaming、spark sql、kafka、spark内核原理（必须有一个大型项目经验）；

第二阶段：spark运行的各种环境，各种故障的解决，性能优化（精通spark内核、运行原理）；

第三阶段：流处理、机器学习为鳌头，需要首先掌握前两个阶段的内容；

第一部分：学习笔记

内容：
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，i+=1

⑥　foreach与函数字面量

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

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

⑦　for循环中是val类型，因此在for表达式中不能重新对其赋值,<-可以理解为其中的意思for(arg<-args)函数调用。
这里写图片描述

//可以使用sum( 1 to 100 _*)求和  
 val arr= Array(10,11,2,4,123,2)  
 val hello = for(i<- 0 until(arr.length,2))println(arr(i))   
//10  2  123  间隔1个取值
//注：Scala 三元符表达示例：  
 var file=if（!args.isEmpty）args(0) else scala.xml

使用scala解释器REPL中的黏贴模式，将代码块黏贴进去方便执行分析。

这里写图片描述

//Scala输入输出形式较丰富  
print("\n I'm a Student!")  
printf("%s the future of BigDate computation framework:\n","Spark")

三、字段定义

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

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

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

3，常量不能赋值，修改

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

四、scala中的Array、Map、Tuple实战

（1）map

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

/* 
 * Map:映射，把值和集合中的元素联系起来，使用任意类型的键 
 */  
val scores = Map("Alice" -> 10, "Bob" -> 33)
 //构造一个不可变的Map[String,Int]  
val scores2 = scala.collection.mutable.Map("Alice" -> 10, "Bob" -> 33)
 //构造一个可变的映射  
val scores3 = new mutable.HashMap[String, Int] 
//构造一个空的映射，选定一个映射实现并给出类型参数  
val scores4 = Map(("Alice", 10), ("Bob", 33)) 
//另外一种定义映射的方式  
val bobScore = scores4("Bob") 
//类似于Java中的scores4.get("Bob");  
val bobScore2 = scores4.getOrElse("Bob", 0) 
//如果映射包含键"Bob"，返回对应的值；否则，返回0 
//映射.get(key)这样的调用返回一个Option对象，要么是some（键对应的值），要么是None  
//更新映射中的值  
scores("Bob") = 90 
//更新键"Bob"对应的值  
scores("Fred") = 88
    scores + ("Fred" -> 88)
 //增加新的键/值对偶到scores  
scores +=("Bob" -> 20, "Fred" -> 30)
 //批量添加多个关系  
scores -= "Alice" 
//移除Alice键对应的值  
//如果对于不可变的映射，需要更改其值，那么可以使用如下方式  
var newScores = scores +("Bob" -> 1, "Fred" -> 7) 
//返回更新过的新映射  
newScores = scores - "Alice" 
//返回去掉Alice之后的新映射 
scores.contains("scala")     //检查是否包含  
scores.keySet                //返回key集合

（2）List

List列表（不可变）

1，类型都是相同的

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

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

 /* 
  * 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的头部添加3
    li.toList  //将ListBuffer转换为List=（1,2）
    println(li(2))  //报错，没有指标2的输出

（3）Array数组
数组要点：
若长度固定则使用Array，若长度可能有变化则使用ArrayBuffer；提供初始值时不要使用new；用()来访问元素；用for(elem<-arr)来遍历元素；用for(elem<-arr if…)…yield…来将原数组转型为新数组；Scala数组和Java数组可以互操作，用ArrayBuffer，使用scala.collection.JavaConversions中的转换函数。

（1）定长数组声明：
val arr = Array[Int](1,2)
print(arr(0))//输出1，下标从0开始
val arrbuff = arr.toBuffer //将Array转换为数组缓冲
(2)变长数组
import collection.mutable.ArrayBuffer
val arrbuff = ArrayBuffer[Int]()
arrbuff += 23    //用+=在尾端添加元素
arrbuff += (2,3,4,32) //同时在尾端添加多个元素
arrbuff ++= Array(2,43,88,66)//可以用++=操作符追加任何集合
arrbuff.trimEnd(2) //移除最后的2个元素
arrbuff.remove(2)  //移除arr(2+1)个元素
arrbuff.remove(2,4) //从第三个元素开始移除4个元素
val arr = arrbuff.toArray //将数组缓冲转换为Array

（4）Tuple元组（不可变）
映射是键/值对偶的集合。对偶是元组（tuple）的最简单形态—元组是不同类型的值的聚集。如果你有元组，val t = (1,3.14,”fred”)，那么可以使用val second = t._2来访问第二个元素，也就是3.14，注意元组的各元组从1开始，而不是0。（这是scala恶心的地方之一，处处充满了变数，不够规整，不够统一，无为的为开发者增加了诸多记忆的负担，很担心scala并不会像Java那样流行，或许以后会出现比scala更优秀的JVM函数式语言）元组可以用于函数需要返回不止一个值的情况。

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

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

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

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

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

第二部分：作业完成

1、移除一个数组中第一个负数后的所有负数；（效率）

val a = ArrayBuffer(1, -2, 3, 5, -4, -5)  
var first = true  
//首先收集需要保留的下标，返回的结果是一个vector集合  
val indexs = for (i <- 0 until a.length if first || a(i) >= 0) yield {  
  if (a(i) < 0) first = false; i  
}  
print(indexs) //output：Vector(0, 1, 2, 3)  
//然后将元素移动到该去的位置，并截断尾端  
for (j <- 0 until indexs.length) {  
  a(j) = a(indexs(j))  
}    
a.trimEnd(a.length - indexs.length)  
print(a)