scala基础语法
基础语法：变量及常量
变量的定义语法及测试*
-
功能：定义一个值可变的变量
-
语法
var 变量名称：数据类型 = 值- Java中的写法：String name = “djn”
-
测试
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
-
- Scala中大多数场景下可以自动推断类型
-
常量的定义语法及测试
-
功能：定义一个值不可变的常量
-
语法
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 = <lazy>
scala> println(aa)
skt
scala> println(bb)
djn
scala> lazy var cc:String = "sky"
<console>: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中数据类型的层次结构**
- 基本类型大体与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
-
基础语法：块表达式与if判断
- **块表达式**
-
功能：用{}包裹多行代码的表达式，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{ 都不满足 }- 与Java基本一致
-
栗子
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") }
-
基础语法：for循环
-
-
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循环
- 语法
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
基础语法：跳出循环Breaks
Java中break
和continue的作用
-
通过关键字来实现
-
break：跳出循环
-
continue：终止当前循环，继续下一次循环
-
Scala中的continue与break
- Scala中的continue与break基于函数式编程的思想通过函数来实现
- 类：Breaks
- 方法：break()
- 语法：当遇到break方法时，跳出当前breakable的代码块
-
栗子
- 实现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)
}
}
1013
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
