Scala进阶之路-Scala的基本语法
作者：尹正杰
版权声明：原创作品，谢绝转载！否则将追究法律责任。
一.函数式编程初体验Spark-Shell之WordCount
var arr=Array("hello","yinzhengjie","hello","world","yinzhengjie","big","data") //声明一个数组
arr.map((_,)).groupBy(_._1).mapValues(_.length).toList.sortBy(-_._2) //使用Spark进行单词个数统计并进行降序
使用CMD窗口操作如下：
二.变量定义以及条件表达式
1>.数据类型介绍
答：Scala 和Java 相似，有7 种数值类型Byte、Char、Short、Int、Long、Float 和Double（无包装类型）和Boolean、Unit 类型.注意:Unit 表示无值，和其他语言中void 等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。下图展示了Scala中的整体类层级图，其中Any位于最顶端，Nothing位于最底端。
2>.变量定义
/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.basicGrammar object DefiningVariable {
def main(args: Array[String]): Unit = {
/**
* 变量的定义可以用关键字var和val修饰
* var修饰的变量值可以更改
* val修饰的变量值不可用改变，相当于Java中final修饰的变量
* 定义变量格式如下 :
* 方式一 : var | val 变量名称 : 类型 = 值
* 方式二 : var | val 变量名称 = 值
*
*/
val name:String = "尹正杰"
var age:Int = 26
val blog = "http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/"
// 输出我们上面定义的变量
println ("姓名 :" + name , "年龄 :" + age , "博客地址 :" + blog ) /**
* Unit数据类型相当于Java中void关键字，但是在scala它的表示形式是一对括号，即"()"。
* 由于我println返回值为空，因此我定义了一个变量res它拿到的返回值必然为空。
*/
val res:Unit=println("yinzhengjie")
println(res)
/**
* 文字'f'插值器允许创建一个格式化的字符串，类似于C语言中的printf。注意，如果你没有写文字'f'插值器的话，格式化字符串会原样输出哟
* 在使用'f'插值器时，所有变量引用都应该是printf 样式格式说明符，如％d，％i，％f 等。
*/
println (f"姓名 :$name%s 年龄 :$age, 博客地址 :$blog ") // 该行输出有换行
/**
* 's'允许在处理字符串时直接使用变量。
* 在println 语句中将String 变量($name)附加到普通字符串中。
*/
println (s"Name=$name , Age=$age , Url=$blog ")
/**
* 字符串插入器还可以处理任意表达式。
* 使用's'字符串插入器处理具有任意表达式"${10 * 10}"的字符串"10 x 10"的以下代码片段。任何表达式都可以嵌入到${}中。
*/
println (s"10 x 10 = ${10 * 10}") /**
* 扩展小知识一:
* 多个变量声明模式
*/
val (x,y,z) = (100,200,300)
println(s"x = ${x},y = ${y},z = ${z}") /**
* 扩展小知识二
* 抽取前两个元素依次赋值,目的只是关心a,b两个值，这样我们就可以直接输出a和b的值
*/
val Array(a,b,_*) = Array("A","B","C","D")
println(s"a = ${a},b = ${b}") }
} /*
以上代码输出结果如下 :
(姓名 :尹正杰,年龄 :26,博客地址 :http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/)
yinzhengjie
()
姓名 :尹正杰 年龄 :26, 博客地址 :http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
Name=尹正杰 , Age=26 , Url=http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
10 x 10 = 100
x = 100,y = 200,z = 300
a = A,b = B
*/
3>.条件表达式
/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.variable object ConditionalExpression {
def main(args: Array[String]): Unit = {
/**
* if 语句的使用
*/
val Name = "尹正杰"
if (Name == "尹正杰"){
println("欢迎使用Scala！")
}
/**
* if...else 语句的使用
*/
val sex = "boy"
val res = if (sex == "boy") "小哥哥" else "小姐姐" //这个和Python中的三元表达式很像哟！
println(res) /**
* if...else if ...else多分支语句
*/
val age:Int = 18
var Title = if (age > 38){ //注意:我们在定义Title变量是并没有指定数据类型，编译器会自动推测出返回值类型，如果上面都没有返回默认就是Unit哟！
"大叔"
}else if (age > 20){
"小哥哥"
}else{
"小鲜肉"
}
println(s"${Title}")
}
} /*
以上代码输出结果如下 :
欢迎使用Scala！
小哥哥
小鲜肉
*/
三.循环语句for及yield关键字
1>.遍历数组的几种方式
/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.variable object CircularStatement {
def main(args: Array[String]): Unit = {
//定义一个数组
val arr = Array(1,2,3,4,5)
//遍历数组的中的所有元素
for (item <- arr){
print(item + " ")
}
println("\n=======我是分割线==========")
//定义一个数组，用面的每一个元素代表arr数组中的角标，从而达到访问arr每一个元素的目的
val index = Array[Int](0,1,2,3,4)
for (item <- index){
print(arr(item) + "|")
}
println("\n=======我是分割线==========")
//以角标的方式会访问，注意“0 to 4”,会生成一个“(0,1,2,3,4)”的数组
for (item <- 0 to 4){
print(arr(item) + " ")
}
println("\n=======我是分割线==========")
//以角标的方式会访问，注意“0 until arr.length”,也会生成一个“(0,1,2,3,4)”的数组,因为arr.length的值为5
for (item <- 0 until arr.length){
print(arr(item) + "|")
}
println("\n=======我是分割线==========")
//取出数组中的偶数元素
for (item <- arr){
if (item % 2 == 0){
print(item + " ")
}
}
println("\n=======我是分割线==========")
//当然，上面的循环表达式也可以简写，如下：
for (item <- arr if item % 2 == 0){
print(item + " ")
}
}
} /*
以上代码执行结果如下 :
1 2 3 4 5
=======我是分割线==========
1|2|3|4|5|
=======我是分割线==========
1 2 3 4 5
=======我是分割线==========
1|2|3|4|5|
=======我是分割线==========
2 4
=======我是分割线==========
2 4
*/
2>.循环的嵌套方式
/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.variable object CircularStatement {
def main(args: Array[String]): Unit = {
for (i <-1 to 3){
for (j <- 1 to 3){
if (i != j){
print(10 * i + j + " ")
}
}
}
println("\n=======我是分割线==========")
//上面的for循环嵌套是很繁琐的，我们可以用一行搞定！
for(i <- 1 to 3;j <-1 to 3 if i != j){
print(10 * i + j + " ")
}
}
} /*
以上代码执行结果如下 :
12 13 21 23 31 32
=======我是分割线==========
12 13 21 23 31 32
*/
3>.yield关键字
/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.variable object CircularStatement {
def main(args: Array[String]): Unit = { val arr = Array(1,2,3,4,5) //yield关键字和Python很类似，它可以多次返回值，比如我们判断arr数组中存在的偶数值
var res = for(item <- arr if item % 2 == 0) yield item //遍历我们得到的数组
for(item <- 0 until res.length){
print(res(item) + " ")
} }
} /*
以上代码执行结果如下 :
2 4
*/
4>.小试牛刀-打印九九乘法表
/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.basicGrammar object MultiplicationTable {
def main(args: Array[String]): Unit = {
for_while_99(9)
println("=======我是分割线==========")
while_while_99(10)
println("=======我是分割线==========")
for_for_99(9)
println("=======我是分割线==========")
senior_for(9)
} /**
* 使用高级for循环打印99乘法表，当然是在传递的参数为9的情况下
*/
def senior_for(arg:Int):Unit={
for(i<-1 to arg;j<-1 to i ){
print(s"${i} x ${j} = ${i * j}\t")
if (j == i) {
println()
}
}
} /**
* 使用for循环嵌套打印99乘法表,我们需要传入一个参数，可以实现任意乘法表
*/
def for_for_99(arg:Int):Unit={
for(i <- 1 to arg){
for (j <- 1 to i){
print(s"${i} x ${j} = ${i * j}\t")
if (j == i) {
println()
}
}
}
}
/**
* 使用while循环嵌套打印99乘法表，我们需要传入一个参数，可以实现任意乘法表
*/
def while_while_99(arg:Int): Unit ={
var i = 1
while (i < arg){
var j = 1
while (j <= i){
printf("%d x %d = %d\t",j,i,(j*i))
if (j == i){
println()
}
j+=1
}
i+=1
}
}
/**
* 使用while和for循环打印99乘法表，我们需要传入一个参数，可以实现任意乘法表
*/
def for_while_99(arg:Int):Unit = {
var i: Int = 1
for (i <- 1 to arg) {
var j = 1
while (j <= i) {
print(s"${i} x ${j} = ${i * j}\t")
if (j == i) {
println()
}
j += 1
}
}
}
} /*
以上代码执行结果如下 :
1 x 1 = 1
2 x 1 = 2 2 x 2 = 4
3 x 1 = 3 3 x 2 = 6 3 x 3 = 9
4 x 1 = 4 4 x 2 = 8 4 x 3 = 12 4 x 4 = 16
5 x 1 = 5 5 x 2 = 10 5 x 3 = 15 5 x 4 = 20 5 x 5 = 25
6 x 1 = 6 6 x 2 = 12 6 x 3 = 18 6 x 4 = 24 6 x 5 = 30 6 x 6 = 36
7 x 1 = 7 7 x 2 = 14 7 x 3 = 21 7 x 4 = 28 7 x 5 = 35 7 x 6 = 42 7 x 7 = 49
8 x 1 = 8 8 x 2 = 16 8 x 3 = 24 8 x 4 = 32 8 x 5 = 40 8 x 6 = 48 8 x 7 = 56 8 x 8 = 64
9 x 1 = 9 9 x 2 = 18 9 x 3 = 27 9 x 4 = 36 9 x 5 = 45 9 x 6 = 54 9 x 7 = 63 9 x 8 = 72 9 x 9 = 81
=======我是分割线==========
1 x 1 = 1
1 x 2 = 2 2 x 2 = 4
1 x 3 = 3 2 x 3 = 6 3 x 3 = 9
1 x 4 = 4 2 x 4 = 8 3 x 4 = 12 4 x 4 = 16
1 x 5 = 5 2 x 5 = 10 3 x 5 = 15 4 x 5 = 20 5 x 5 = 25
1 x 6 = 6 2 x 6 = 12 3 x 6 = 18 4 x 6 = 24 5 x 6 = 30 6 x 6 = 36
1 x 7 = 7 2 x 7 = 14 3 x 7 = 21 4 x 7 = 28 5 x 7 = 35 6 x 7 = 42 7 x 7 = 49
1 x 8 = 8 2 x 8 = 16 3 x 8 = 24 4 x 8 = 32 5 x 8 = 40 6 x 8 = 48 7 x 8 = 56 8 x 8 = 64
1 x 9 = 9 2 x 9 = 18 3 x 9 = 27 4 x 9 = 36 5 x 9 = 45 6 x 9 = 54 7 x 9 = 63 8 x 9 = 72 9 x 9 = 81
=======我是分割线==========
1 x 1 = 1
2 x 1 = 2 2 x 2 = 4
3 x 1 = 3 3 x 2 = 6 3 x 3 = 9
4 x 1 = 4 4 x 2 = 8 4 x 3 = 12 4 x 4 = 16
5 x 1 = 5 5 x 2 = 10 5 x 3 = 15 5 x 4 = 20 5 x 5 = 25
6 x 1 = 6 6 x 2 = 12 6 x 3 = 18 6 x 4 = 24 6 x 5 = 30 6 x 6 = 36
7 x 1 = 7 7 x 2 = 14 7 x 3 = 21 7 x 4 = 28 7 x 5 = 35 7 x 6 = 42 7 x 7 = 49
8 x 1 = 8 8 x 2 = 16 8 x 3 = 24 8 x 4 = 32 8 x 5 = 40 8 x 6 = 48 8 x 7 = 56 8 x 8 = 64
9 x 1 = 9 9 x 2 = 18 9 x 3 = 27 9 x 4 = 36 9 x 5 = 45 9 x 6 = 54 9 x 7 = 63 9 x 8 = 72 9 x 9 = 81
=======我是分割线==========
1 x 1 = 1
2 x 1 = 2 2 x 2 = 4
3 x 1 = 3 3 x 2 = 6 3 x 3 = 9
4 x 1 = 4 4 x 2 = 8 4 x 3 = 12 4 x 4 = 16
5 x 1 = 5 5 x 2 = 10 5 x 3 = 15 5 x 4 = 20 5 x 5 = 25
6 x 1 = 6 6 x 2 = 12 6 x 3 = 18 6 x 4 = 24 6 x 5 = 30 6 x 6 = 36
7 x 1 = 7 7 x 2 = 14 7 x 3 = 21 7 x 4 = 28 7 x 5 = 35 7 x 6 = 42 7 x 7 = 49
8 x 1 = 8 8 x 2 = 16 8 x 3 = 24 8 x 4 = 32 8 x 5 = 40 8 x 6 = 48 8 x 7 = 56 8 x 8 = 64
9 x 1 = 9 9 x 2 = 18 9 x 3 = 27 9 x 4 = 36 9 x 5 = 45 9 x 6 = 54 9 x 7 = 63 9 x 8 = 72 9 x 9 = 81
*/
四.运算符重载成方法
/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.variable object OperatorReloadingMethod {
def main(args: Array[String]): Unit = {
var res1 = 1 + 2
println(res1)
//上面的运算符“+”其实是运算符重载成方法，即".+"
var res2 = 1.+(2)
println(res2) val res3 = 1 to 10
println(res3)
//上面的运算符“to”其实也是运算符重载成方法，即".to"
val res4 = 1.to(10)
println(res4) }
} /*
以上代码输出结果如下 :
3
3
Range 1 to 10
Range 1 to 10
*/
五.Scala中定义方法和函数简介
1>.有参函数和无参函数以及方法转换成函数案例
/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.function object Method { /**
* 定义有参函数 :
* 定义个 sum 方法(用关键字def来标识方法), 该方法有 3 个参数(即a,b和c), 参数类型为整型, 方法的返回值为整型，
*/
def sum(a:Int, b: Int,c:Int): Int = {
//方法体是将形参列表的三个参数进行相加操作，相加的结果就是返回值的整形
a + b + c
} /**
* 定义无参函数 :
* 改方法没有任何参数, 也没有返回值。注意：如果方法没有括号"()" 调用时不能加"()"
*/
def sayHello() ={
println("I'm Yinzhengjie！")
} def main(args: Array[String]): Unit = {
//调用有参函数
var res = sum(100,200,300)
println(res) //调用无参函数,调用时可以省略括号"()", 也可以不省略。如果方法没有括号"()"，调用时不能加"()"
sayHello() //方法可转换为函数，格式很简单，只需要在方法名后面加个空格和下划线即可。
var f1 = sum _
//调用我们将方法转换过来的函数
var res1 = f1(1,2,3)
println(res1)
}
} /**
* 以上代码执行结果如下 :
* 600
* I'm Yinzhengjie！
* 6
*/
2>.匿名函数的两种定义和调用方式
/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.function object Method { /**
* 函数定义方式一:
* f1 :
* 其中f1是对匿名函数签名的一个引用，我们可以通过f1去调用这个函数，
* (x : Int) :
* 其中x是变量的名称，而Int是变量的类型
* => :
* 表示的是函数标志
* x * 2 ：
* 表示的具体的函数体，即也是最终的返回值哟
*/
val f1 = (x:Int) => x * 2 /**
* 函数定义方式而:
* f2 :
* 其中f2是对匿名函数签名的一个引用，我们可以通过f2去调用这个函数，
* (Int) :
* Int定义的是函数的参数类型，我这个定义了一个Int类型的参数，如果有多个用逗号分隔即可
* => :
* 表示的是函数标志
* Int ：
* 表示的是返回值类型为Int
* (x) :
* 注意，这里的x实际上是形参，这个参数的类型就是前面我们定义的Int类型
* x * 2 ：
* 表示的具体的函数体，即也是最终的返回值哟
*/
val f2 :(Int) => Int =(x) => x * 2 /**
* 下面为没有任何参数的匿名函数, 函数的返回值为String类型.
*
*/
val f3:() => String = () => "尹正杰" def main(args: Array[String]): Unit = {
//调用匿名函数f1
var res1 = f1(10)
println(res1) //调用匿名函数f2
var res2 = f1(20)
println(res2) //调用参数为空的匿名函数f3
val Name = f3();
println(Name) }
} /**
* 以上代码执行结果如下 :
* 20
* 40
* 尹正杰
*/
想要了解更多关于函数知识点笔记请参考：https://www.cnblogs.com/yinzhengjie/p/9352798.html。