Scala是一门 综合了 面向对象的 函数式编程的 基于JVm的 语言
特点:
1 语法简洁
2 开发速度快 , 运行速度快
3 兼容 Java 可以访问Java类库
4 很多大数据框架的源码或编程接口都支持Scala
5 使用广泛 国际认可
运行环境: JDK 8 或者11(长期支持)
ScalaSDK 2.12.11 稳定(或者2.12.12)
1 Scala语句最后不要加分号
2 Scala中类型可以可以省略,因为Scala编译器 支持类型判断
3 val修饰的修饰的变量不能重新赋值 (类似于Java中的final)
4 var可以重新赋值
5 开发中 常用val
6 可以使用type给类型起别名
7 可以使用lazy修饰变量,延迟变量的初始化
测试: type 给类型起别名 可以用数字吗??? (针对6)
答: 不可以
Any 父类( 类似Java中的 Object )
值类型 Scala中的值类型都是大写开头
Byte
Short
Int
Long
Double
Float
Boolean
Char
String: 定义方式1: " "
定义方式2: “”" 这里面可以写SQL “”"
定义方式3: 字符串拼接可以使用插值表达式
定义方式4: 插值表达式 加 “”" “”"
语法详解
Scala中的+ - * / %等操作符的作用与Java一样,
位操作符 & | ^ >> <<也一样。
注意:
1.Scala中的操作符实际上是方法
2.Scala中没有++、–操作符,需要通过+=、-=来实现同样的效果
3.+ - * / %是方法,那么就可以进行操作符重载,完成特殊的运算
(也就是自己在类中定义+ - * / %方法表示特殊的运算)
定义变量时可以使用 {} 包含一系列表达式,其中{}块的最后一个表达式的值就是整个块表达式的值。
cala条件表达式的语法和Java一样,只是更加简洁,且Scala中if else表达式是有返回值的
注意:
Scala中没有三元表达式,如果if或者else返回的类型不一样,就返回Any类型,对于没有返回值的,使用Unit,写做(),相当于java中的void
在scala中,可以使用for循环和while循环,但一般推荐使用for表达式,因为for表达式语法更简洁
● 简单for循环:
for (变量 <- 表达式/数组/集合) {循环体}
for(i <- 1 to 10) println(i)
● 嵌套for循环
for (变量1 <- 表达式/数组/集合; 变量2 <- 表达式/数组/集合) {循环体}
for(i <- 1 to 9; j <- 1 to 9){
if(i >= j ) print(s"${j} * ${i} = ${j*i}")
if(j == 9) println()
}
● 守卫
for表达式中,可以添加if判断语句,这个if判断就称之为守卫。我们可以使用守卫让for表达式更简洁。
for(i <- 表达式/数组/集合 if 表达式) {循环体}
for(i <- 1 to 10 if i % 3 == 0) println(i)
● for推导式
在for循环体中,可以使用yield表达式构建出一个集合,我们把使用yield的for表达式称之为推导式,即可以使用for推导式生成一个新的集合(一组数据)
//该for表达式会构建出一个集合
val l = for(i <- 1 to 10) yield i * 10
● 注意:
while语句本身没有值,即整个while语句的结果是Unit类型的()
var n = 1;
val result = while(n <= 10){
n += 1
}
println(result) //()
println(n) //10
Scala中没有break和continue 关键字来退出循环,如果需要使用break/continue,可以使用scala.util.control.Breaks对象的breakable和break方法。
Scala中的方法和Java中的方法一样,都是用来封装某些功能的,他可以接收参数,并在方法体中进行一些处理操作,最后还可以返回处理的结果
定义格式:
def 方法名(参数名1: 参数类型1, 参数名2: 参数类型2) : 返回类型 = {方法体}
语法细节:
1.方法的返回值类型和return可以不写,编译器可以自动推断出来
2.对于递归方法,必须指定返回类型
3.如果方法没有返回值,返回Unit类型(类似于void,也可以不写)
4.返回值类型有多种情况则返回Any
5.带有默认值参数的方法,调用时,可以给定新值,也可以使用默认值
6.可以通过参数名来指定传递给哪一个参数,
这样传递参数时就可以不按照顺序传递
7.方法没有参数,调用时可以省略(),如果定义时()省略,调用时则必须省略
8.可变参使用 变量名:类型* (类似Java的…)
函数的本质是: 对象
(函数就和方法都是用来封装一些操作的)
格式
●完整语法:
val函数名称:(参数类型)=>函数返回值类型=(参数名称:参数类型)=>{函数体}
●简写语法:
val函数名称=(参数名称:参数类型)=>{函数体}//如果只有一行{}可以省略
●符号解释
= 表示将右边的函数赋给左边的变量
=> 左面表示输入参数名称和类型,右边表示函数的实现和返回值类型
证明Scala中的函数本质也是对象
●注意:
严格的来说,函数与方法是不同的东西。定义方式上也有很多的区别,但是在Scala中,函数本身是对象,方法可以通过下划线_转换为函数。
集合分类
分类方式
一: 按照集合数据结构分类
Seq序列
Set
Map
二: 按照可变不可变进行分类
不可变集合 scala.collection.immutable (默认)
开发时建议Scala优先采用不可变集合 默认即为不可变
可变集合 scala.collection.
●不可变/定长数组:
val/var 变量名= new Array[T](数组长度)
val/var 变量名 = Array(元素1, 元素2, 元素3...)
●可变/变长数组:
//需要导入import scala.collection.mutable.ArrayBuffer包
val/var 变量名 = ArrayBuffer[T]()
val/var 变量名 = ArrayBuffer(元素1, 元素2, 元素3...)
●不可变列表(默认)
import scala.collection.immutable._
创建方式1.使用List(元素1, 元素2, 元素3, ...)来创建一个不可变列表
val/var 变量名 = List(元素1, 元素2, 元素3...)
创建方式2.使用::方法创建一个不可变列表
val/var 变量名 = 元素1 :: 元素2 :: Nil
注意:
使用::拼接方式来创建列表,必须在最后添加一个Nil
●可变列表
import scala.collection.mutable._
创建方式1.使用ListBuffer[元素类型]()创建空的可变列表
val/var 变量名 = ListBuffer[Int]()
创建方式2.使用ListBuffer(元素1, 元素2, 元素3...)创建可变列表
val/var 变量名 = ListBuffer(元素1,元素2,元素3...)
●Set说明
Set代表一个没有重复元素的无序集合;
即无法加入重复元素且不保证插入顺序的。
●不可变Set(默认)
import scala.collection.immutable._
1.创建一个空的不可变集,语法格式:
val/var 变量名 = Set[类型]()
2.给定元素来创建一个不可变集,语法格式:
val/var 变量名 = Set(元素1, 元素2, 元素3...)
●可变Set
import scala.collection.mutable._
格式相同,导包不同
注意:在main方法里导包是导包下面的集合是可变的
在首行导包是main方法中的全部 set都是可变的
val/var 变量名 = Set[类型]()
1.语法详解
元组也是可以理解为一个容器,可以用来存放各种相同或不同类型的数据。
例如:姓名,年龄,性别,出生年月。
元组的元素是不可变的。
●创建元组
方式一:使用括号来定义元组
val/var 元组 = (元素1, 元素2, 元素3....)
方式二:使用箭头来定义元组(元组只有两个元素)
al/var 元组 = 元素1->元素2 //对偶/二元组是最简单的元组(k,v)
注意:如果定义二元组使用方式一/二都可以 但是如果是三元组,则需要注意只能用方式2
●获取元组中的值
使用下划线加脚标 ,例如 tuple._1 tuple._2 tuple._3
注意:元组中的元素脚标是从1开始的
●将对偶(二元组)组成的数组转换成映射(映射就相当于Java中的Map)
将对偶/二元组的集合转换成映射: 调用其toMap 方法
●遍历
可以调用元组的productIterator方法获取迭代器对象进行遍历
2.拉链操作:
使用zip将多个值绑定在一起,如果两个数组的元素个数不一致,拉链操作后生成的数组的长度为较小的那个数组的元素个数, 使用zipAll将多个值绑定在一起,缺少的用默认的元素填充
Map Map是多个二元组
在Scala中,把哈希表这种数据结构叫做映射。类比Java的map集合
●不可变Map
import scala.collection.immutable.Map
格式一: 使用箭头
val/var map = Map(键->值, 键->值, 键->值...) // 推荐,可读性更好
格式二:利用元组
val/var map = Map((键, 值), (键, 值), (键, 值), (键, 值)...)
●可变Map
import scala.collection.mutable.Map
//与 不可变Map 格式相同,导包不同
●获取值
map(键)
map.getOrElse(键,默认值)
●修改值
map(键)=值
队列数据存取符合先进先出的策略,有 scala.collection.mutable.Queue 和 scala.collection.immutable.Queue ,一般来说我们在开发中队列通常使用可变队列
●常见操作
+= //追加
enqueue //入队
dequeue //出队
代码
package cn.itcast.collection
/**
* Author caowei
* Date 2019/7/3 20:16
* Desc
*/
object QueueDemo {
def main(args: Array[String]): Unit = {
//队列的创建
import scala.collection.mutable.Queue
val q1 = new Queue[Int]
println(q1) //Queue()
//队列元素的追加
q1 += 1;
println(q1)//Queue(1)
//向队列中追加List
q1 ++= List(2, 3, 4)
println(q1)//Queue(1, 2, 3, 4)
//按照进入队列的顺序删除元素
q1.dequeue()
println(q1)//Queue(2, 3, 4)
//塞入数据
q1.enqueue(9, 8, 7)
println(q1)//Queue(2, 3, 4, 9, 8, 7)
//返回队列的第一个元素
println(q1.head)//2
//返回队列最后一个元素
println(q1.last)//7
//返回除了第一个以外的元素
println(q1.tail)//Queue(3, 4, 9, 8, 7)
}
}
今日分享这么多, 仅代表个人理解 , 有借鉴部分 有任何疑问或者侵权问题 欢迎咨询 QQ 2211572344 交流探讨