scala的语法规则 (一)

一 scala解释器

scala解释器像Linux命令一样,执行一条代码,马上就可以让我们看到执行结果,用来测试比较方便。

要启动scala解释器,只需要以下几步:


按住windows键 + r
输入scala即可

Welcome to Scala 2.11.12 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_221).
Type in expressions for evaluation. Or try :help.

scala>

退出解释器

在scala命令提示窗口中执行:quit,即可退出解释器

二 变量

语法格式

java变量:

int a = 0;

在scala中,可以使用val或者var来定义变量,语法格式如下:

val/var 变量标识:变量类型 = 初始值

其中
val定义的是不可重新赋值的变量
var定义的是可重新赋值的变量

scala中定义变量类型写在变量名后面
scala的语句最后不需要添加分号

在解释器中定义一个变量

示例:定义一个变量保存一个人的名字"tom"

scala> val name:String = "tom"
name: String = tom

val和var变量

示例

给名字变量进行重新赋值为Jim,观察其运行结果

scala> name = "Jim"
<console>:12: error: reassignment to val
       name = "Jim"

示例

使用var重新定义变量来保存名字"tom",并尝试重新赋值为Jim,观察其运行结果

scala> var name:String = "tom"
name: String = tom

scala> name = "Jim"
name: String = Jim

优先使用val定义变量,如果变量需要被重新赋值,才使用var

使用类型推断来定义变量

scala的语法要比Java简洁,我们可以使用一种更简洁的方式来定义变量。

scala> val name = "tom"
name: String = tom

scala可以自动根据变量的值来自动推断变量的类型,这样编写代码更加简洁。

惰性赋值

在企业的大数据开发中,有时候会编写非常复杂的SQL语句,这些SQL语句可能有几百行甚至上千行。这些SQL语句,如果直接加载到JVM中,会有很大的内存开销。如何解决?

当有一些变量保存的数据较大时,但是不需要马上加载到JVM内存。可以使用惰性赋值来提高效率。

lazy val/var 变量名 = 表达式

示例

在程序中需要执行一条以下复杂的SQL语句,我们希望只有用到这个SQL语句才加载它。

"""insert overwrite table adm.itcast_adm_personas
    select
    a.user_id,
    a.user_name,
    a.user_sex,
    a.user_birthday,
    a.user_age,
    a.constellation,
    a.province,
    a.city,
    a.city_level,
    a.hex_mail,
    a.op_mail,
    a.hex_phone,
    a.fore_phone,
    a.figure_model,
    a.stature_model,
    b.first_order_time,
    b.last_order_time,
      ...
    d.month1_hour025_cnt,
    d.month1_hour627_cnt,
    d.month1_hour829_cnt,
    d.month1_hour10212_cnt,
    d.month1_hour13214_cnt,
    d.month1_hour15217_cnt,
    d.month1_hour18219_cnt,
    d.month1_hour20221_cnt,
    d.month1_hour22223_cnt
    from gdm.itcast_gdm_user_basic a
      left join gdm.itcast_gdm_user_consume_order b on a.user_id=b.user_id
    left join gdm.itcast_gdm_user_buy_category c on a.user_id=c.user_id
    left join gdm.itcast_gdm_user_visit d on a.user_id=d.user_id;"""

参考代码:

scala> lazy val sql = """insert overwrite table adm.itcast_adm_personas
     |     select
     |     a.user_id,
    ....
     |     left join gdm.itcast_gdm_user_buy_category c on a.user_id=c.user_id
     |     left join gdm.itcast_gdm_user_visit d on a.user_id=d.user_id;"""
sql: String = <lazy>

三 字符串

scala提供多种定义字符串的方式,将来我们可以根据需要来选择最方便的定义方式。

  • 使用双引号
  • 使用插值表达式
  • 使用三引号

使用双引号

示例

有一个人的名字叫"hadoop",请打印他的名字以及名字的长度。

scala> println(name + name.length)
hadoop6
scala> var name = "hadoop"
name: String = hadoop

scala> println(name + name.length)
hadoop6

使用插值表达式

scala中,可以使用插值表达式来定义字符串,有效避免大量字符串的拼接。

val/var 变量名 = s"${变量/表达式}字符串"

在定义字符串之前添加s
在字符串中,可以使用${}来引用变量或者编写表达式

示例

请定义若干个变量,分别保存:“zhangsan”、30、“male”,定义一个字符串,保存这些信息。

打印输出:name=zhangsan, age=30, sex=male

scala> val name = "zhangsan"
name: String = zhangsan

scala> val age = 30
age: Int = 30

scala> val sex = "male"
sex: String = male

scala> val info = s"name=${name}, age=${age}, sex=${sex}"
info: String = name=zhangsan, age=30, sex=male

scala> println(info)
name=zhangsan, age=30, sex=male

使用三引号

如果有大段的文本需要保存,就可以使用三引号来定义字符串。例如:保存一大段的SQL语句。三个引号中间的所有字符串都将作为字符串的值。

示例

定义一个字符串,保存以下SQL语句

select
    *
from
    t_user
where
    name = "zhangsan"

打印该SQL语句:

val sql = """select
     | *
     | from
     |     t_user
     | where
     |     name = "zhangsan""""

println(sql)
scala> val sql = """select
     | *
     | from
     |  t_user
     | where
     |  name = "zhangsan""""
sql: String =
select
*
from
 t_user
where
 name = "zhangsan"

scala> println(sql)
select
*
from
 t_user
where
 name = "zhangsan"

四 数据类型与操作符

scala中的类型以及操作符绝大多数和Java一样

基础类型 类型说明
Byte 8位带符号整数
Short 16位带符号整数
Int 32位带符号整数
Long 64位带符号整数
Char 16位无符号Unicode字符
String Char类型的序列(字符串)
Float 32位单精度浮点数
Double 64位双精度浮点数
Boolean true或false
  • scala中所有的类型都使用大写字母开头
  • 整形使用Int而不是Integer
  • scala中定义变量可以不写类型,让scala编译器自动推断

运算符

类别 操作符
算术运算符 +、-、*、/
关系运算符 >、<、==、!=、>=、<=
逻辑运算符 &&、||、!
位运算符 &、||、^、<<、>>

  • scala中没有,++、–运算符

  • 与Java不一样,在scala中,可以直接使用==!=进行比较,它们与equals方法表示一致。而比较两个对象的引用值,使用eq


示例

有一个字符串"abc",再创建第二个字符串,值为:在第一个字符串后拼接一个空字符串。

然后使用比较这两个字符串是否相等、再查看它们的引用值是否相等。


参考代码

val str1 = "abc"
val str2 = str1 + ""
str1 == str2
str1.eq(str2)
scala> val str1 = "abc"
str1: String = abc

scala> val str2 = str1 + ""
str2: String = abc

scala> str1 == str2
res3: Boolean = true

scala> str1.eq(str2)
res4: Boolean = false


scala类型层次结构


scala的语法规则 (一)_第1张图片


类型 说明
Any 所有类型的父类,,它有两个子类AnyRef与AnyVal
AnyVal 所有数值类型的父类
AnyRef 所有对象类型(引用类型)的父类
Unit 表示空,Unit是AnyVal的子类,它只有一个的实例{% em %}() {% endem %}
它类似于Java中的void,但scala要比Java更加面向对象
Null Null是AnyRef的子类,也就是说它是所有引用类型的子类。它的实例是{% em %}null{% endem %}
可以将null赋值给任何对象类型
Nothing 所有类型的子类
不能直接创建该类型实例,某个方法抛出异常时,返回的就是Nothing类型,因为Nothing是所有类的子类,那么它可以赋值为任何类型

nothing

def main(args: Array[String]): Unit = {
    val c = m3(1,0)
}

def m3(x:Int, y:Int):Int = {
    if(y == 0) throw new Exception("这是一个异常")
    x / y
}

问题

以下代码是否有问题?

val b:Int = null
scala> val b:Int = null
<console>:11: error: an expression of type Null is ineligible for implicit conversion
       val b:Int = null

scala会解释报错:

Null类型并不能转换为Int类型,说明Null类型并不是Int类型的子类



五 条件表达式

条件表达式就是if表达式,if表达式可以根据给定的条件是否满足,根据条件的结果(真或假)决定执行对应的操作。scala条件表达式的语法和Java一样。


有返回值的if

与Java不一样的是,

[!NOTE]

  • 在scala中,条件表达式也是有返回值的
  • 在scala中,没有三元表达式,可以使用if表达式替代三元表达式

示例

定义一个变量sex,再定义一个result变量,如果sex等于"male",result等于1,否则result等于0


参考代码

scala> val sex = "male"
sex: String = male

scala> val result = if(sex == "male") 1 else 0
result: Int = 1


块表达式

  • scala中,使用{}表示一个块表达式
  • 和if表达式一样,块表达式也是有值的
  • 值就是最后一个表达式的值

问题

请问以下代码,变量a的值是什么?

scala> val a = {
     | println("1 + 1")
     | 1 + 1
     | }

scala> val a = {
     
     | println("1 + 1")
     | 1 + 1
     | }
1 + 1
a: Int = 2

六 循环

在scala中,可以使用for和while,但一般推荐使用for表达式,因为for表达式语法更简洁


for表达式

语法

for(i <- 表达式/数组/集合) {
    // 表达式
}

简单循环

使用for表达式打印1-10的数字


步骤

  1. 生成1-10的数字(提示:使用to方法)
  2. 使用for表达式遍历,打印每个数字

参考代码1

scala> val nums = 1.to(10)                                                              
nums: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) 
                                                                                        
scala> for(i <- nums) println(i)                                                                                                                                          

简写方式


参考代码2

// 中缀调用法
scala> for(i <- 1 to 10) println(i)
scala> for(i <- 1 to 10) println(i)
1
2
3
4
5
6
7
8
9
10

嵌套循环

使用for表达式,打印以下字符

*****
*****
*****

步骤

  1. 使用for表达式打印3行,5列星星
  2. 每打印5个星星,换行

参考代码

for(i <- 1 to 3; j <- 1 to 5) {print("*");if(j == 5) println("")}
scala> for(i <- 1 to 3; j <- 1 to 5) {
     print("*");if(j == 5) println("")}
*****
*****
*****

守卫

for表达式中,可以添加if判断语句,这个if判断就称之为守卫。我们可以使用守卫让for表达式更简洁。


语法

for(i <- 表达式/数组/集合 if 表达式) {
    // 表达式
}

示例

使用for表达式打印1-10之间能够整除3的数字


参考代码

// 添加守卫,打印能够整除3的数字
for(i <- 1 to 10 if i % 3 == 0) println(i)
scala> for(i <- 1 to 10 if i % 3 ==0) println(i)
3
6
9

for推导式

  • 将来可以使用for推导式生成一个新的集合(一组数据)

  • 在for循环体中,可以使用yield表达式构建出一个集合,我们把使用yield的for表达式称之为推导式


示例

生成一个10、20、30…100的集合


参考代码

// for推导式:for表达式中以yield开始,该for表达式会构建出一个集合
val v = for(i <- 1 to 10) yield i * 10
scala> var v = for(i <- 1 to 10) yield i * 10
v: scala.collection.immutable.IndexedSeq[Int] = Vector(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)


while循环

scala中while循环和Java中是一致的


示例

打印1-10的数字


参考代码

scala> var i = 1
i: Int = 1

scala> while(i <= 10) {
     | println(i)
     | i = i+1
     | }
scala> while(i <= 10) {
     
     | println(i)
     | i = i+1
     | }
1
2
3
4
5
6
7
8
9
10

七 break和continue

  • 在scala中,类似Java和C++的break/continue关键字被移除了
  • 如果一定要使用break/continue,就需要使用scala.util.control包的Break类的breablebreak方法。



实现break

用法

  • 导入Breaks包import scala.util.control.Breaks._
  • 使用breakable将for表达式包起来
  • for表达式中需要退出循环的地方,添加break()方法调用

示例

使用for表达式打印1-100的数字,如果数字到达50,退出for表达式

参考代码

// 导入scala.util.control包下的Break
import scala.util.control.Breaks._

breakable{
    for(i <- 1 to 100) {
        if(i >= 50) break()
        else println(i)
    }
}


实现continue

用法

continue的实现与break类似,但有一点不同:

[!NOTE]

实现break是用breakable{}将整个for表达式包起来,而实现continue是用breakable{}将for表达式的循环体包含起来就可以了



示例

打印1-100的数字,使用for表达式来遍历,如果数字能整除10,不打印

// 导入scala.util.control包下的Break    
import scala.util.control.Breaks._

for(i <- 1 to 100 ) {
    breakable{
        if(i % 10 == 0) break()
        else println(i)
    }
}

八 方法

一个类可以有自己的方法,scala中的方法和Java方法类似。但scala与Java定义方法的语法是不一样的。


定义方法

语法

def methodName (参数名:参数类型, 参数名:参数类型) : [return type] = {
    // 方法体:一系列的代码
}

[!NOTE]

  • 参数列表的参数类型不能省略
  • 返回值类型可以省略,由scala编译器自动推断
  • 返回值可以不写return,默认就是{}块表达式的值

示例

  1. 定义一个方法,实现两个整形数值相加,返回相加后的结果
  2. 调用该方法

参考代码

scala> def add(a:Int, b:Int) = a + b
m1: (x: Int, y: Int)Int

scala> add(1,2)
res10: Int = 3

返回值类型推断

scala定义方法可以省略返回值,由scala自动推断返回值类型。这样方法定义后更加简洁。


[!DANGER]

定义递归方法,不能省略返回值类型


示例

定义递归方法(求阶乘)

10 * 9 * 8 * 7 * 6 * … * 1


参考代码

scala> def m2(x:Int) = {
     | if(x<=1) 1
     | else m2(x-1) * x
     | }
:13: error: recursive method m2 needs result type
       else m2(x-1) * x
scala> def m2(x:Int):Int = {
     
     | if(x<=1) 1
     | else m2(x-1) * x
     | }
m2: (x: Int)Int

scala> m2(3)
res13: Int = 6

你可能感兴趣的:(Spark,scala,scala的语法规则)