变量

声明变量

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

其中

• Val表示的是不可改变的变量
• Var表示的是可以重新赋值的变量

Notice:

变量写在变量名后面，且不用写分号

语法格式

val name: String = "hello world"
var age:Int = 18

使用Scala中的类型推导

Scala比Java语言更加简洁，类似于Js，类型可以被变量自动根据等号后面的值来推导

语法格式

val name = "leon"
//可以自动推导出name的类型为String，不用再手动添加 

惰性赋值

类似于懒加载，变量不会一次性全部加载到JVM的内存中，可以提高运行效率

语法格式

lazy val/var 变量名 = 表达式

lazy val sql = 

"""insert overwrite table adm.itcast_adm_personas 19
| 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>

字符串

使用字符串

语法格式

val/var 变量名 = “字符串”

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

val name = "liming"
println(name + name.length)

//打印"liming6"

使用插值表达式

语法格式

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

Tips:

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

请定义若干个变量，分别保存："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

使用三引号

语法

val/var 变量名 = """字符串1

字符串2"""

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

select
    * 
from
    t_user 
where
    name = "zhangsan"

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

println(sql)

数据类型与操作符

基本数据类型

Tips:

1. scala中所有的类型都使用大写字母开头
2. 整形使用 Int 而不是Integer
3. scala中定义变量可以不写类型，让scala编译器自动推断

操作符

Tips

1. scala中没有，++、--运算符

2. 与Java不一样，在scala中，可以直接使用 == 、 != 进行比较，它们与 equals 方法表示一

   致。而比较两个对象的引用值，使用 eq

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

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

val str1 = "abc" 
val str2 = str1 + ""
str1 == str2  //true
str1.eq(str2) //false

scala类型层次结构

条件表达式

Tips:

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

定义一个变量sex，再定义一个result变量，如果等于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表达式一样，块表达式也是有值的

• 值就是最后一个表达式的值

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

循环

for

​ 语法

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

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

//先定义一个nums
scala> val nums = 1.to(10)
nums: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

//然后再打印for循环
scala> for(i <- nums) println(i)

2. 中缀法

// 中缀调用法 
scala> for(i <- 1 to 10) println(i)

嵌套循环

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

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

步骤

1. 是否for表达式打印3行，5列星星

2. 每打印5个星星，换行

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

scala中可以把嵌套写成在一个括号中执行。然后后面接条件表达式

守卫

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

洁。

语法

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

​ // 表达式

}

使用for表达式打印能够整除3的数字

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

for推导式

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

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

  导式

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

// for推导式：for表达式中以yield开始，该for表达式会构建出一个集合

val v = for(i <- 1 to 10) yield i * 10

while循环

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

打印1-10的数字

scala> var i = 1 i: 
Int = 1 

scala> while(i <= 10) {
    | println(i)
    | i = i+1 
    | }

方法

基本定义

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

样的，而且scala支持多种调用方式。

语法设置

def methodName (参数名:参数类型, 参数名:参数类型) : [return type] = {

​ // 方法体：一系列的代码

}

Tips：

1. 参数列表的参数类型不能省略
2. 返回值类型可以省略
3. 返回值可以不写return，默认就是{}块表达式的值

示例

1. 定义一个方法，实现两个整形数值相加，返回相加后的结果

2. 调用该方法

scala> def add(x:Int, y:Int):Int = x * y 
m1: (x: Int, y: Int)Int 

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

方法参数

​ scala中的方法参数，使用比较灵活。它支持以下几种类型的参数：

• 默认参数
• 带名参数
• 变长参数

默认参数

​ 在定义方法时可以给参数定义一个默认值。

示例

1. 定义一个计算两个值相加的方法，这两个值默认为0

2. 调用该方法，不传任何参数

// x，y带有默认值为0 
def add(x:Int = 0, y:Int = 0) = x + y 
add()

带名参数

​ 在调用方法时，可以指定参数的名称来进行调用。

示例

1. 定义一个计算两个值相加的方法，这两个值默认为0

2. 调用该方法，只设置第一个参数的值

def add(x:Int = 0, y:Int = 0) = x + y 
add(x=1)

变长参数

​ 如果方法的参数是不固定的，可以定义一个方法的参数是变长参数。

语法格式:

def 方法名(参数名:参数类型*):返回值类型 = {

​ 方法体

}

Tips:

• 在参数类型后面加一个 * 号，表示参数可以是0个或者多个

示例

1. 定义一个计算若干个值相加的方法

2. 调用方法，传入以下数据：1,2,3,4,5

scala> def add(num:Int*) = num.sum 
add: (num: Int*)Int 

scala> add(1,2,3,4,5) 
res1: Int = 15

方法返回值类型推断

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

示例

使用类型推断重新定义上面的add方法

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

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

方法调用方式

后缀调用法

语法

对象名.方法名(参数)

示例

使用后缀法 Math.abs 求绝对值

scala> Math.abs(-1) 
res3: Int = 1

中缀调用法

语法

对象名 方法名 参数

例如 ： 1 to 10

示例

使用中缀法 Math.abs 求绝对值

scala> Math abs -1 
res4: Int = 1

花括号调用法

语法

Math.abs{

​ // 表达式1

​ // 表达式2

}

示例

使用花括号调用法 Math.abs 求绝对值

scala> Math.abs{-10} 
res13: Int = 10

无括号调用法

如果方法没有参数，可以省略方法名后面的括号

示例

• 定义一个无参数的方法，打印"hello"
• 使用无括号调用法调用该方法

def m3()=println("hello") 
m3()

函数

scala支持函数式编程，将来编写Spark/Flink程序中，会大量经常使用到函数

定义函数

语法

val 函数变量名 = (参数名:参数类型, 参数名:参数类型....) => 函数体

Tips:

1. 函数是一个对象（变量）
2. 类似于方法，函数也有输入参数和返回值
3. 函数定义不需要使用 def 定义
4. 无需指定返回值类型

示例

1. 定义一个两个数值相加的函数

2. 调用该函数

scala> val add = (x:Int, y:Int) => x + y 
add: (Int, Int) => Int = <function2> 

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

方法和函数的区别

• 方法是隶属于类或者对象的，在运行时，它是加载到JVM的方法区中

• 可以将函数对象赋值给一个变量，在运行时，它是加载到JVM的堆内存中

• 函数是一个对象，继承自FunctionN，函数对象有apply，curried，toString，tupled这些方

  法。方法则没有

示例

方法无法赋值给变量

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

scala> val a = add 
<console>:12: error: missing argument list for method add Unapplied methods are only converted to functions when a function type is expected. You can make this conversion explicit by writing `add _` or `add(_,_)` instead of `add`. 

val a = add

方法转换为函数

• 有时候需要将方法转换为函数，作为变量传递，就需要将方法转换为函数
• 使用 _ 即可将方法转换为函数

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

val a = add _ 
a: (Int, Int) => Int = <function2>