spark编程 Spark编程基础(Scala版)A卷

spark-scala语言编程基础

• 一.变量

• 1.不同类型变量

• 二、输入输出

• 1.向控制台输入信息
• 2.向控制台输出信息
• 3.写入文件
• 4.读取文件

• 三、控制结构

• 1.if
• 2.while
• 3.for
• 4.异常处理
• 5.对循环的控制

• 四、数据结构

• 1.数组
• 2.元组
• 3.容器
• 4.seq set map索引方式不同
• 5.seq
• 6.列表
• 7.向量（vector）
• 8.range
• 9.集合（set）
• 10.映射

• 五、类

• 1.定义
• 2.类成员的可见性
• 3. 构造器

一.变量

1.不同类型变量

二、输入输出

1.向控制台输入信息

scala.io.StdIn //此处为大写i

• 使用前，必须导入

import io.StdIn._   //._类似于java里面的.*表示导入所有类
var i = readInt()   //从控制台读入一个整形
var f = readFloat
var b = readBoolean

var str = readLine("please input your name:")

• 直接使用全称进行调用

2.向控制台输出信息

• print()和println()

val i = 345
print("i=");print(i)
//两条语句位于同一行，不能省略中间的分号
println("hello");println("world")
//println把里面内容打印出来后换行

• 支持c语言风格格式化字符串

val i = 22
val f = 60.5
printf("I am %d years old and weight %1f Kg.",i,f)
//printf支持格式化字符串，小数点后加1表示小数点后保留一位

• 字符串插值机制
  s’’…$变量名.." f"...$变量名%格式化字符…"

val i = 10
val f = 3.5
val s = "hello"
printIn(s"$s:i=$i,f=$f")
printIn(f"$s:i=$i%-4d,f=$f%.1f")

3.写入文件

• java.io.PrintWriter

import java.io.PrintWriter
val outputFile = new PrintWriter("test.txt")
outputFile.println("hello world")
outputFile.print("Spark is good")
outputFile.close()

4.读取文件

import scala.io.Source
val inputFile = Source.fromFile("output.txt")
val lines = inputFile.getLines
for (line < -lines)println(line)

三、控制结构

1.if

if(表达式){
	语句块1
}
else{
	语句块2
}

• scala中If语句的值还可以赋给其他值

val x = 6
 val a = if (x>0) 1 else -1	//if语句的值为1

2.while

while（表达式）{
	循环体
}
do{
	循环体
}while(表达式)

3.for

• 基本

for(变量<-表达式){语句块}

for(i <- 1 to 5)println(i) //默认步长为1
for(i <- 1 to 5 by 2)println(i) //默认步长为2

• 守卫

for(变量<-表达式 if 条件表达式)语句块

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

• 支持多个生成器，用分号隔开

for (i <- 1 to 5;j<-1 to 3)println(i*j)

• for 推导式

for(变量<-表达式)yield{语句块}

val r=for (i<-Array(1,2,3,4,5)if i%2==0)yield{println(i);i} //打印，把值返回给r

4.异常处理

• scala中把所有异常当作不受检异常（运行时抛出）

import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException
try{
      val f = new FileReader("input.txt")  //文件操作
}catch{
  case ex:FileNotFoundException=>
//文件不存在时的操作
  case ex:IOException=>
//发生I/O错误时的操作
}finally{
file.close()//确保关闭文件
}

5.对循环的控制

• scala中没有break和continue
• breaks类

breakable{
...
if(...)break
...
}

import util.control.Breaks._//导入breaks类的所有方法
val array = Array(1,3,10,5,4)
breakable{
for(i<-array){
	if(i>5)break//跳出Breakable，终止for循环，相当于java中的Break
	println(i)
}
}//输出1，3

for(i<array){
	breakable{
	if(i>5)break//跳出breakable，终止当此循环，相当于java的continue
	println(i)
	}
}//输出1，3，5，4

四、数据结构

1.数组

• 具有相同类型的集合
• 声明一个整型数组

val int(ValueArr=new Array[Int](3))//声明一个长度为3的整形数组，每个数组元素初始化为0
intValueArr(0)=12//给第一个数组元素赋值为12
intValueArr(1)=45//给第二个数组元素赋值为45
intValueArr(2)=33//给第三个数组元素赋值为33

• 声明一个字符串数组

val myStrArr = new Array[String](3)//声明一个长度为3的字符串数组，每个数组元素初始化为null
myStrArr(0)="hello"
myStrArr(1)="world"
for(i<-0 to 1)println(myStrArr(i))

• 自动推断数组的类型

val intValueArr=Array(12,45,33)
val myStrArr=Array("hello","world")

• 多维数组的创建

val myMatrix=Array.ofDim[Int](3,4)//类型实际就是Array[Array[Int]]
val myCube = Array.ofDim[String](3,2,4)//类型是Array[Array[Array[Int]]]
myMAtrix(0)(1)//第一行，第二列的元素

2.元组

• 对多个不同类型的对象的简单分装

val tuple = ("BigData",2015,45,0)
println(tuple._1)//Bigdata
println(tuple._2)//2015
println(tuple._3)//45.0

3.容器

• 特质
• scala中没有接口的概念，只有特质Trait

4.seq set map索引方式不同

• seq 按0，1，2索引
• map 按键索引
• set 无索引结构

5.seq

6.列表

• 具体容器类
• 共享相同类型的不可变的对象序列
• 列表的初始化

var strList=List("BigData","Hadoop","spark")
println(strList.head)//输出列表头部，即Bigdata
println(strList.tail)//输出列表尾部，即spark

• 构造列表的常用方法：向已有列表前端增加元素

val otherList="Apache"::strList

val intList=List(1,2,3)

val intList=1:2:3:Nil //右结合，从右往左执行，先得到 （3，Nil）

7.向量（vector）

val vecl=Vector(1,2)
val vec2=3+:4+:vecl
val vec3=vec2:+5//注意：+和+：不同
val vec3(3)

8.range

• 特俗的带索引的不可变数字等差序列
• 创建一个从1到5的数值序列，区间终点5，步长为1

val r =new Range(1,5,1)
1 to 5
1.to(5)

• 创建一个从1到5的数值序列，不包含区间终点5，步长为1

1 until 5

• 创建一个从1到10的数字序列包含区间终点10，步长为2

1 to 10 by 2

• 创造一个Float类型的数值序列从0.5到5.9，步长为0.3

0.5f to 5.9 by 0.3f

9.集合（set）

• 元素不允许重复
• 无顺序
• 用哈希方法查找
• 三个包

scala.collection//封装了可变容器和不可变容器的超类
scala.collection.mutable
scala.collection.immutable

• 创建不可变类型的变量

var mySet = Set("Hadoop","Spark")  //创建不可变集合的对象，var表示变量可变
// 把不可变集合的对象赋值给可变变量
mySet +="Scala"//修改可变变量的值

• 创建一个可变集合对象

import scala.collection.mutable.Set
val myMutableSet=Set("Database","BigData")//创建可变集合的对象，val表示变量不可变
myMutableSet+="Cloud Compting"//去改变可变集合里面的元素，并没有改变集合本身

10.映射

• 一系列键值对的容器，键唯一，值可能有多个
• 不可变scala.collection.immutable包（默认不可变）

val university=Map("HBUT"->"Hubei University of Technology","address"->"Wuhan")
val HBUT= if (university.contains("HBUT"))university("HBUT")else 0
println(HBUT)

• 可变 scala.collection.mutable包（想要可变必须导入）

import scala.collection.mutable.Map
val university2=Map("HBUT"->"Hubei of Technology")
university2("HBUT")="Hubei University of Technology"//更新已有元素值
university2("adress")="Wuhan"//添加新元素
university2+=("SDU"->"Shandong University")//利用加等添加
university2+=("TJU"->"Tianjin University","WHU"->"Wuhan University")

五、类

1.定义

• 类的定义

class Counter{
//这里定义类的字段和方法，类名首字母大写
}

• 方法的定义

def 方法名（参数列表）：返回结果类型={方法体}//什么都不返回时，返回的类型叫Unit,参数不能加val和var来修饰，可以用圆括号也可以用大括号

def value=privateValue//没有参数的方法在定义的时候是可以圆括号省略的,后面调用时，也不能加括号

def current:Int=value//方法体只有一条语句可以省略括号

class Counter{
var value =0
def increment(step:Int):Unit={value+=step}
def current:Int=value
def getValue():Int:value
val c=new Counter
c increment 5//中缀调用法
c.getValue()//getValue中有括号，可以带括号调用
c.getvalue//getValue中有括号，也可不带括号调用
c.current//crrent定义中没有括号，只能不带括号调用

class Counter{
var value=0
def increment(step:Int){value+=step}//赋值表达式的值为Unit类型，把冒号unit全省略
def current()=value//根据value的类型自动推断出返回类型为Int型

• 实例

class Counter{
var value =0
def increment(step:Int):Unit={value += step}
def current():Int={value}
}

//实例化
val myCounter=new Counter
myCounter.value=5//访问字段
myCounter.increment(3)//调用方法
println(myCounter.current)//调用无参数方法时，可以省略方法名后的括号

2.类成员的可见性

• 在scala中如果没有任何修饰关键字，默认public,任何作用域内都可以访问公有成员
• private本类型可见，嵌套类型可见
• protected本类型可见，其他继承类型可见
• value方法，读取
• value_=方法，修改

class Counter{
private var privateValue=0
def value =privateValue
def value_=(newValue:Int){
	if (newValue>0)privateValue=newValue
	}
	def increment(step:Int):Unit={value+=step}
	def current():Int={value}
	}

val myCounter=new Conter
myCounter.value_=(3)//为privateValue设置新的值,当value,value_=成对出现时，myCounter.value=3等效于myCounter.value_=(3)
println(myCounter.value)//访问privateValue当前值

3. 构造器

• 类的定义主体就是一个构造器，称为主构造器
• 类名称（参数列表）
• 可以用val 或var关键字去修饰，加了之后，整个scala会自动地给这个相关类去创建一个内部成员，即放在主构造器参数列表里面的参数会自动变成它的类内部的成员字段
• 不加val或var就仅仅只起到内部传参的作用，不会帮你创建内部成员

class Counter(var name:String)//定义一个带字符串参数的简单类
var mycounter = new Counter("Runner")//调用读方法
println(mycounter.name)
mycounter.name_=("Timer")//调用写方法
mycounter.name="Timer"//更直观的调用写方法，和上句等效

• 类名称（参数）（参数）（参数）来定义不同的构造器和辅助构造器
• 使用This(参数列表）的形式
• 每个辅助构造器的第一个表达式必须是调用此前已经定义的辅助构造器或者主构造器

class Counter{
 private var value = 0
 private var name = ""
 private var step =1 //计算器的默认递进步长
 println("the main constructor")
 def this(name:String){  //第一个辅助构造器
 this()//调用主构造器
 this.name = name
 printf("the first auxiliart constructor:%s\n",name)
 }
 def this(name:String,step:Int){  //第二个辅助构造器
 this(name)//调用前一个辅助构造器
 this.step=step
 println("the second auxiliary constructor,name:%s,step:%d\n",name,step)
}
def increment(step:Int):Unit = {value + = step}
def current():Int ={value}
}

val c1 =new Counter//调用主构造器
val c2 = new Counter("the 2nd Counter")
val c3 =new Counter("the 3nd Counter",2)