变量的定义语法及测试*
功能:定义一个值可变的变量
语法
var 变量名称:数据类型 = 值
测试
scala> var a:String = "djn"
a: String = djn
scala> println(a)
djn
scala> a = "sky"
a: String = sky
scala> println(a)
sky
scala> var b:Int = 20
b: Int = 20
scala> b = 10
b: Int = 10
scala> println(a+"\t"+b)
sky10
scala> var a = "spark"
a: String = spark
scala> var a = 1
a: Int = 1
scala> var a = 1.9
a: Double = 1.9
scala> var a = false
a: Boolean = false
常量的定义语法及测试
功能:定义一个值不可变的常量
语法
val 常量名称:数据类型 = 值
测试
scala> val aa:String = "sky"
aa: String = sky
scala> println(aa)
sky
scala> aa = “djn”
:12: error: reassignment to val
aa = “djn”
^
```
初始值
功能:用于构建一个变量时,指定初始值
语法
var 变量名称:数据类型 = _
测试
scala> var a:Int = 0
a: Int = 0
scala> var a:String = null
a: String = null
scala> var a:Boolean = false
a: Boolean = false
scala> var a:Boolean = _
a: Boolean = false
scala> var a:String = _
a: String = null
scala> var a:Int = _
a: Int = 0
注意
只能用于变量
必须指定类型,不能自动推断类型
功能:构建一个常量时不直接赋值,只构建常量对象,当用到数据内容时,再真正赋值
设计:避免值初始化以后,如果不被调用,占用内存,通过lazy使用时再进行初始化分配
语法
lazy val 常量名称:数据类型 = 值
测试
scala> val aa:String = "sky"
aa: String = sky
scala> lazy val bb:String = "djn"
bb: String =
scala> println(aa)
skt
scala> println(bb)
djn
scala> lazy var cc:String = "sky"
:1: error: lazy not allowed here. Only vals can be lazy
lazy var cc:String = "sky"
^
```
**特点及注意事项**
- Scala代码不以分号结尾
- Scala中大多数场景可以自动推断类型
- Scala中推荐使用常量,不推荐使用变量:val
- 如果需要变量的场景怎么办?可以用多个常量来代替变量的
- var i = 1/2/3
```
- val i1 = 1
- val i2 = 2
- val i3 = 3
```
- scala中名称在前、类型在后 中间以:分割
- scala中类型首字母大写,大小写敏感
- 大多数场合写可以省去类型不写,编译器可以自动推导
- 初始值不能用于常量,只能用于变量,并且必须指定数据类型
- 惰性赋值只能用于常量,不能用于变量
- 在scala中推荐使用val常量,可以使用函数式编程解决变量的问题
## 基础语法:数据类型
- **Scala中的数据类型**
- 基本类型:Int、Double……
- 变量存储的是值
- 引用类型:String、集合、对象……
- 变量存储的是内存地址
- **Scala中的数据类型运算**
- 运算符:+、-、*、/ 、% ……
- 本质:所有数据类型都是对象,所有数据类型的运算符都是这个对象的方法
- 栗子
```scala
scala> val a = 1
a: Int = 1
scala> val b = 2
b: Int = 2
scala> a + b //中缀调用
res6: Int = 3
scala> a.+(b) //后缀调用
res7: Int = 3
```
- **Scala中数据类型的层次结构**
![在这里插入图片描述](https://img-blog.csdnimg.cn/20210408092300839.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODE0Mzk5Ng==,size_16,color_FFFFFF,t_70)
- 基本类型大体与Java中是一致的
- Unit类似于Java中的void,没有任何实质性的意义,一般用于作为标识函数无返回值
- Java
```
public void name(args){
方法体
return
}
```
- Scala:没有return
```
def name(args):unit= {
方法体
1+2
4
}
```
- Null类型是所有引用类型的子类
- Nothing是所有类型的子类,一般用于作为函数返回值,用于明确的标识没有返回值
```
def name(args):Nothing= {
方法体
Nothing
}
```
## 基础语法:字符串使用及插值表达式
- **字符串定义**
- 双引号定义
```scala
scala> val s1 = "sky"
s1: String = sky
scala> println(s1)
sky
```
- 三引号定义:用于比较长的字符串定义,可读性比较强
```scala
scala> val s2 = """
| select xxxxx
| from xxxx
| where xxxx
| group by xxx
| having xxxx
| order by xxxx
| limit xxx
| """
s2: String =
"
select xxxxx
from xxxx
where xxxx
group by xxx
having xxxx
order by xxxx
limit xxx
"
```
- **字符串截取substring**
```scala
scala> s1.substring(2)
res9: String = y
scala> s1.substring(2,2)
res10: String = ""
scala> s1.substring(2)
res11: String = y
scala> s1.substring(2,3)
res12: String = y
scala> s1.substring(1,2)
res13: String = k
字符串替换replaceAll
scala> val s3 = "I like"
s3: String = I like
scala> s3.replaceAll(" ","-")
res14: String = I-like
字符串拼接
scala> println(s3+" "+s1)
I like sky
scala> s3 + " " + s1
res17: String = I like sky
scala> s3.+(s1)
res18: String = I likesky
插值表达式的使用
功能:用于字符串拼接,可以在字符串中插入变量或者表达式
语法
s"${变量 | 表达式}"
测试
scala> s3 + " " + s1
res19: String = I like sky
scala> s"${s3} ${s1}"
res20: String = I like sky
scala> println(s"${s3.replaceAll(" ","-")}")
I-like
scala> println(s"${s3.replaceAll(" ","-")}-${s1}")
I-like-sky
- **块表达式**
功能:用{}包裹多行代码的表达式,scala中使用最后一行作为表达式的返回值,如果表达式只有一行代码,{}可以省略
语法
{
第一行代码
第二行代码
……
表达式返回值
}
栗子
scala> val a = 1
a: Int = 1
scala> val b = 2
b: Int = 2
scala> val c = {
| val d = a + b
| 4
| }
c: Int = 4
scala> val c = { a+b }
c: Int = 3
scala> val c = a+b
c: Int = 3
if判断
功能:用于实现代码中的判断分支逻辑
语法
if (表达式){
true的处理逻辑
}else{
false的处理逻辑
}
if(表达式1){
表达式1为true
}else if(表达式2){
表达式2为true
}else if(表达式N){
表达式N为true
}else{
都不满足
}
栗子
scala> if (c > 10){ false } else {true}
res27: Boolean = true
scala> if (c > 10) false else true
res28: Boolean = true
if(c > 10){
println("c > 10")
}else if(c > 5){
println("c > 5")
}else{
println("c > 0")
}
Scala中for循环的语法
Java语法
for(int i = 0;i < 10 ; i++){
循环逻辑
}
Scala语法
for(i <- 集合/数值范围){
循环逻辑
}
Scala中构建数值范围表达式
scala> 1 to 10
res30: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
scala> 1.to(10)
res31: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
scala> 1.until(10)
res32: scala.collection.immutable.Range = Range(1, 2, 3, 4, 5, 6, 7, 8, 9)
for循环栗子
scala> for(i <- 1 to 10) {println(i)}
1
2
3
4
5
6
7
8
9
10
scala> for(i <- 1 to 10) println(i)
1
2
3
4
5
6
7
8
9
10
scala> for(i <- 0 to 9) println(i)
0
1
2
3
4
5
6
7
8
9
守卫条件
功能:循环过程中实现数据过滤,增加循环条件,符合条件才会执行循环逻辑
优点:不是每次循环都会执行循环体,只有符合条件才执行循环体
语法
for(x <- 集合/数值范围 守卫条件表达式){
循环逻辑
}
scala> for(i <- 1 to 10) {if(i % 2 == 0) {println(i)}}
2
4
6
8
10
scala> for(i <- 1 to 10 if i%2 == 0) {println(i)}
2
4
6
8
10
推导式yield
功能:在for循环后面加上表达式,针对循环的结果进行表达式的计算 ,计算结果组成一个新的集合
关键字:yield
语法
for(i <- 集合/数值范围) yield {
循环表达式
//计算表达式
}
- 栗子
```scala
scala> for(i <- 1 to 10) yield i*2
res40: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
scala> for(i <- 1 to 10) yield {
| println(i)
| i*2
| }
1
2
3
4
5
6
7
8
9
10
res41: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
- 语法
while(表达式){
符合条件的循环逻辑
}
do {
循环逻辑
} while( 表达式 );
栗子
scala> var a = 5
a: Int = 5
scala> while(a < 10){
| println(a)
| a = a + 1
| }
5
6
7
8
9
scala> do{
| println(a)
| a = a + 1
| }while(a < 10)
10
scala> do{
| println(a)
| a = a + 1
| }while(a < 20)
11
12
13
14
15
16
17
18
19
Java中break
和continue的作用
通过关键字来实现
break:跳出循环
continue:终止当前循环,继续下一次循环
Scala中的continue与break
栗子
import scala.util.control.Breaks._
breakable{
for(i <- 1 to 10) {
if(i >= 5) break()
else println(i)
}
}
实现continue
import scala.util.control.Breaks._
for(i <- 1 to 10){
breakable{
if(i == 5) break()
else println(i)
}
}