spark-scala语言编程基础

spark-scala语言编程基础

一.变量

1.不同类型变量 二、输入输出

1.向控制台输入信息2.向控制台输出信息3.写入文件4.读取文件 三、控制结构

1.if2.while3.for4.异常处理5.对循环的控制 四、数据结构

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

一.变量 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 " . . . 变量名.." f"... 变量名.."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和continuebreaks类

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(i5)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")