Scala数据类型以及运算符
一、变量和数据类型
1.1 注释
- 和java完全一样
package tiger.scala.chapter02
// 单行注释：可以出现在程序中的任意位置
/*
* 多行注释
*
* */
/**
* 文档注释：只能出现在类和方法上
* @param args
*
* */
object Scala01_TestComm {
}
1.2 变量和常量
1.2.1 基本语法
var 变量名:变量类型 = 值
val 常量名:常量类型 = 值1.2.2 案例
- 声明变量时，类型可以省略，编译器自动推导，即类型推导
- 类型确定后，就不能修改，说明Scala是强数据类型语言
- 变量声明时，必须要有初始值
- 在声明/定义一个变量时，可以使用var或者val来修饰，var修饰的变量可改变，val修饰的变量不可改
- var修饰的对象引用可以改变，val修饰的对象则不可改变，但对象的状态（值）却是可以改变的。（比如：自定义对象、数组、集合等等）
package tiger.scala.chapter02
import tiger.scala.chapter01.Student
/*
* 变量：在程序执行过程中，其值可以改变
* 常量：在程序执行的过程中，其值不可以改变
* Scala
* 变量
* var 变量名:数据类型 = 值
* var a:Int = 10
* 常量
* val 常量名:数据类型 = 初始值
*
* */
object Scala02_Val {
def main(args: Array[String]): Unit = {
// 声明一个整数类型变量 a，并将10赋值给a
var a:Int = 10
println(a)
// 声明变量时，类型可以省略，编译器自动推导，即类型推导
var b = 20
println(b)
// 类型确定后，就不能修改，说明Scala是强数据类型语言。
// 变量声明时，必须要有初始值
// 在声明/定义一个变量时，可以使用var或者val来修饰，var修饰的变量可改变
// var修饰的对象引用可以改变，val修饰的对象则不可改变，但对象的状态（属性）却是可以改变的（比如：自定义对象，数组，集合等等）。
// 在实际开发中，var和val优先选val
}
}1.3 标识符的命名规范
1.3.1 命名规则
- Scala对各种变量、方法、函数等命名时使用的字符序列称为标识符。即：凡是自己可以起名字的地方都叫标识符。
- 命名规则：Scala中的标识符声明，基本和Java是一致的，但是细节上会有所变化，有以下四种规则：
- 以字母或者下划线开头，后接字母、数字、下划线
- 以操作符开头，且只包含操作符（+ - * / # !等）
- 用反引号`....`包括的任意字符串，即使是Scala关键字（39个）也可以
1.3.2 案例
object TestName {
def main(args: Array[String]): Unit = {
// （1）以字母或者下划线开头，后接字母、数字、下划线
var hello: String = "" // ok
var Hello12: String = "" // ok
var 1hello: String = "" // error 数字不能开头
var h-b: String = "" // error 不能用-
var x h: String = "" // error 不能有空格
var h_4: String = "" // ok
var _ab: String = "" // ok
var Int: String = "" // ok 因为在Scala中Int是预定义的字符,不是关键字，但不推荐
var _: String = "hello" // ok 单独一个下划线不可以作为标识符，因为_被认为是一个方法
println(_)
//（2）以操作符开头，且只包含操作符（+ - * / # !等）
var +*-/#! : String = "" // ok
var +*-/#!1 : String = "" // error 以操作符开头，必须都是操作符
//（3）用反引号`....`包括的任意字符串，即使是Scala关键字（39个）也可以
var if : String = "" // error 不能用关键字
var `if` : String = "" // ok 用反引号`....`包括的任意字符串,包括关键字
}
}
1.4 字符串输出
1.4.1 基本语法
- 字符串，通过+号连接
- printf用法：字符串，通过%传值。类似于c语言中的printf
- 字符串模板（插值字符串）：通过$获取变量值
1.4.2 案例
package com.atguigu.chapter02
object TestCharType {
def main(args: Array[String]): Unit = {
var name: String = "jinlian"
var age: Int = 18
//（1）字符串，通过+号连接
println(name + " " + age)
//（2）printf用法字符串，通过%传值。
printf("name=%s age=%d\n", name, age)
//（3）字符串，通过$引用
//多行字符串，在Scala中，利用三个双引号包围多行字符串就可以实现。//输入的内容，带有空格、\t之类，导致每一行的开始位置不能整洁对齐。
//应用scala的stripMargin方法，在scala中stripMargin默认是“|”作为连接符，//在多行换行的行头前面加一个“|”符号即可。
val s =
"""
|select
| name,
| age
|from user
|where name="zhangsan"
""".stripMargin
println(s)
//如果需要对变量进行运算，那么可以加${}
val s1 =
s"""
|select
| name,
| age
|from user
|where name="$name" and age=${age+2}
""".stripMargin
println(s1)
val s2 = s"name=$name"
println(s2)
}
}
1.5 键盘输入
1.5.1 基本语法
StdIn.readLine()、StdIn.readShort()、StdIn.readDouble()1.5.2 案例
package tiger.scala.chapter02
import scala.io.StdIn
/*
* 获取键盘输入
*
* */
object Scala05_TestStdIn {
def main(args: Array[String]): Unit = {
println("请输入你的名字")
val name: String = StdIn.readLine()
println("请输入你的年龄")
val age: Int = StdIn.readInt()
println(s"欢迎${age}的${name}来到中国")
var a:Null = null
var a1:Null = null
}
}
1.6 数据类型
1.6.1 基本结构
- Scala中一切数据都是对象，都是Any的子类
- Scala中数据类型分为两大类：数值类型(AnyVal)、引用类型(AnyRef)，不管是数值类型还是引用类型都是对象
- Scala数据类型仍然遵守，低精度的值类型向高精度值类型，自动转换（隐式转换）
- Scala中的StringOps是对Java中的String增强
- Unit：对应Java中的void，用于方法放回值的位置，表示方法没有返回值。Unit是一个数据类型，只有一个对象就是()。void不是数据类型，只是一个关键字。
- Null是一个类型，只有一个对象就是null。它是所有引用类型(AnyRef)的子类
- Nothing，是所有数据类型的子类，主要用在一个函数没有明确返回值时使用，因为这样我们可以把抛出的返回值，返回给任何变量或者函数
1.6.2 案例
package tiger.scala.chapter02
/*
*
*
* */
object Scala06_DataType {
def main(args: Array[String]): Unit = {
// 整数类型
// 正确
var n1:Byte = 127
var n2:Byte = -128
// 错误
// var n3:Byte = -129
// 在编译的时候会判断数值是否在当前类型表示的范围之内，如果在，底层默认进行转换
var b:Byte = 10 + 20
println(b)
var a = 10L
println(a)
// 字符类型
//（1）字符常量是用单引号 ' ' 括起来的单个字符。
var c1: Char = 'a'
println("c1=" + c1)
//注意：这里涉及自动类型提升，其实编译器可以自定判断是否超出范围，
//不过idea提示报错
// var c2:Char = 'a' + 1
// println(c2)
//
// //（2）\t ：一个制表位，实现对齐的功能
// println("姓名\t年龄")
//
// //（3）\n ：换行符
// println("西门庆\n潘金莲")
//
// //（4）\\ ：表示\
// println("c:\\岛国\\avi")
//
// //（5）\" ：表示"
// println("同学们都说：\"大海哥最帅\"")
// println(m1())
// println(m2(2))
}
// 演示Unit
def m1(): Unit = {
println("m1方法被执行了")
}
// 演示Nothing
def m2(n:Int): Nothing = {
if (n == 0) {
throw new NullPointerException
} else {
// 在Scala语言中，Nothing类型表示发生了异常
throw new RuntimeException
}
}
}
1.7 整数类型
1.7.1 分类
| 数据类型 |
描述 |
| Byte [1] |
8位有符号补码整数。数值区间为 -128 到 127 |
| Short [2] |
16位有符号补码整数。数值区间为 -32768 到 32767 |
| Int [4] |
32位有符号补码整数。数值区间为 -2147483648 到 2147483647 |
| Long [8] |
64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807 = 2的(64-1)次方-1 |
1.7.2 案例
- Scala各整数类型有固定的表示范围和字段长度，不受具体操作的影响，以保证Scala程序的可移植性。
object TestDataType {
def main(args: Array[String]): Unit = {
// 正确
var n1:Byte = 127
var n2:Byte = -128
// 错误
// var n3:Byte = 128
// var n4:Byte = -129
}
}
- Scala的整型，默认为Int型，声明Long型，须后加‘l’或‘L‘
object TestDataType {
def main(args: Array[String]): Unit = {
var n5 = 10
println(n5)
var n6 = 9223372036854775807L
println(n6)
}
}
- Scala程序中变量常声明为Int型，除非不足以表示大数，才使用Long
1.8 浮点类型
1.8.1 分类
| 数据类型 |
描述 |
| Float [4] |
32 位，IEEE 754标准的单精度浮点数 |
| Double [8] |
64位，IEEE 754标准的双精度浮点数 |
1.8.2 案例
-
Scala的浮点型常量默认为Double型，声明Float型常量，须后加‘f’或‘F’。
object TestDataType {
def main(args: Array[String]): Unit = {
// 建议，在开发中需要高精度小数时，请选择Double
var n7 = 2.2345678912f
var n8 = 2.2345678912
println("n7=" + n7)
println("n8=" + n8)
}
}
1.9 字符类型
1.9.1 基本说明
- 字符类型可以表示单个字符，字符类型是Char。
1.9.2 案例
- 字符常量是用单引号 ' ' 括起来的单个字符。
- \t ：一个制表位，实现对齐的功能
- \n ：换行符
- \\ ：表示\
- \" ：表示"
object TestCharType {
def main(args: Array[String]): Unit = {
//（1）字符常量是用单引号 ' ' 括起来的单个字符。
var c1: Char = 'a'
println("c1=" + c1)
//注意：这里涉及自动类型提升，其实编译器可以自定判断是否超出范围，
//不过idea提示报错
var c2:Char = 'a' + 1
println(c2)
//（2）\t ：一个制表位，实现对齐的功能
println("姓名\t年龄")
//（3）\n ：换行符
println("西门庆\n潘金莲")
//（4）\\ ：表示\
println("c:\\hhh\\avi")
//（5）\" ：表示"
println("同学们都说：\"hhh最帅\"")
}
}
1.10 布尔类型
1.10.1 基本说明
- 布尔类型也叫Boolean类型，Booolean类型数据只允许取值true和false
- boolean类型占1个字节。
1.10.2 案例
object TestBooleanType {
def main(args: Array[String]): Unit = {
var isResult : Boolean = false
var isResult2 : Boolean = true
}
}
1.11 Unit类型、Null类型和Nothing类型
1.11.1 基本说明
| 数据类型 |
描述 |
| Unit |
表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。 |
| Null |
null , Null 类型只有一个实例值null |
| Nothing |
Nothing类型在Scala的类层级最低端；它是任何其他类型的子类型。 当一个函数，我们确定没有正常的返回值，可以用Nothing来指定返回类型，这样有一个好处，就是我们可以把返回的值（异常）赋给其它的函数或者变量（兼容性） |
1.11.2 案例
- Unit类型用来标识过程，也就是没有明确返回值的函数。相当于Java中的void，Unit只有一个实例——( )，这个实例也没有实质意义
object TestSpecialType {
def main(args: Array[String]): Unit = {
def sayOk : Unit = {// unit表示没有返回值，即void
}
println(sayOk)
}
}
- Null类只有一个实例对象，Null类似于Java中的null引用。Null可以赋值给任意引用类型（AnyRef），但是不能赋值给值类型（AnyVal）
object TestDataType {
def main(args: Array[String]): Unit = {
//null可以赋值给任意引用类型（AnyRef），但是不能赋值给值类型（AnyVal）
var cat = new Cat();
cat = null // 正确
var n1: Int = null // 错误
println("n1:" + n1)
}
}
class Cat {
}- Nothing，可以作为没有正常返回值的方法的返回类型，非常直观的告诉你这个方法不会正常返回，而且由于Nothing是其他任意类型的子类，他还能跟要求返回值的方法兼容。
object TestSpecialType {
def main(args: Array[String]): Unit = {
def test() : Nothing={
throw new Exception()
}
test
}
}
1.12 类型转换
1.12.1 数值类型自动转换
-
当Scala程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数值类型，这个就是自动类型转换（隐式转换）。数据类型按精度（容量）大小排序为：
- 基本说明
- 自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算。
- 把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
- (byte，short)和char之间不会相互自动转换。
- byte，short，char他们三者可以计算，在计算时首先转换为int类型。
1.12.2 隐式类型转换案例
object TestValueTransfer {
def main(args: Array[String]): Unit = {
//（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数值类型，然后再进行计算。
var n = 1 + 2.0
println(n) // n 就是Double
//（2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
var n2 : Double= 1.0
//var n3 : Int = n2 //错误，原因不能把高精度的数据直接赋值和低精度。
//（3）（byte，short）和char之间不会相互自动转换。
var n4 : Byte = 1
//var c1 : Char = n4 //错误
var n5:Int = n4
//（4）byte，short，char他们三者可以计算，在计算时首先转换为int类型。
var n6 : Byte = 1
var c2 : Char = 1
// var n : Short = n6 + c2 //当n6 + c2 结果类型就是int
// var n7 : Short = 10 + 90 //错误
}
1.12.3 强制类型转换
- 基本说明
-
自动类型转换的逆过程，将精度大的数值类型转换为精度小的数值类型。使用时要加上强制转函数，但可能造成精度降低或溢出，格外要注意。
-
1.12.4 强制类型转换案例
- 将数据由高精度转换为低精度，就需要使用到强制转换
- 强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
object TestForceTransfer {
def main(args: Array[String]): Unit = {
//（1）将数据由高精度转换为低精度，就需要使用到强制转换
var n1: Int = 2.5.toInt // 这个存在精度损失
//（2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
var r1: Int = 10 * 3.5.toInt + 6 * 1.5.toInt // 10 *3 + 6*1 = 36
var r2: Int = (10 * 3.5 + 6 * 1.5).toInt // 44.0.toInt = 44
println("r1=" + r1 + " r2=" + r2)
}
}
1.12.5 数值类型和String类型间转换
- 基本说明
-
在程序开发中，我们经常需要将基本数值类型转成String类型。或者将String类型转成基本数值类型。
-
1.12.6 数值类型和String类型间转换案例
- 基本类型转String类型（语法：将基本类型的值+"" 即可）
- String类型转基本数值类型（语法：s1.toInt、s1.toFloat、s1.toDouble、s1.toByte、s1.toLong、s1.toShort）
object TestStringTransfer {
def main(args: Array[String]): Unit = {
//（1）基本类型转String类型（语法：将基本类型的值+"" 即可）
var str1 : String = true + ""
var str2 : String = 4.5 + ""
var str3 : String = 100 +""
//（2）String类型转基本数值类型（语法：调用相关API）
var s1 : String = "12"
var n1 : Byte = s1.toByte
var n2 : Short = s1.toShort
var n3 : Int = s1.toInt
var n4 : Long = s1.toLong
}
}
- 注意
-
在将String类型转成基本数值类型时，要确保String类型能够转成有效的数据，比如我们可以把"123"，转成一个整数，但是不能把"hello"转成一个整数。
-
二、运算符
2.1 算数运算符
2.1.1 基本语法
| 运算符 |
运算 |
范例 |
结果 |
| + |
正号 |
+3 |
3 |
| - |
负号 |
b=4; -b |
-4 |
| + |
加 |
5+5 |
10 |
| - |
减 |
6-4 |
2 |
| * |
乘 |
3*4 |
12 |
| / |
除 |
5/5 |
1 |
| % |
取模(取余) |
7%5 |
2 |
| + |
字符串相加 |
“He”+”llo” |
“Hello” |
- 对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
- 对一个数取模a%b，和Java的取模规则一样。
2.1.2 案例
object TestArithmetic {
def main(args: Array[String]): Unit = {
//（1）对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
var r1: Int = 10 / 3 // 3
println("r1=" + r1)
var r2: Double = 10 / 3 // 3.0
println("r2=" + r2)
var r3: Double = 10.0 / 3 // 3.3333
println("r3=" + r3)
println("r3=" + r3.formatted("%.2f")) // 含义：保留小数点2位，使用四舍五入
//（2）对一个数取模a%b，和Java的取模规则一样。
var r4 = 10 % 3 // 1
println("r4=" + r4)
}
}
2.2 关系运算符
2.2.1 基本语法
| 运算符 |
运算 |
范例 |
结果 |
| == |
相等于 |
4==3 |
false |
| != |
不等于 |
4！=3 |
true |
| < |
小于 |
4<3 |
false |
| > |
大于 |
4>3 |
true |
| <= |
小于等于 |
4<=3 |
false |
| >= |
大于等于 |
4>=3 |
true |
2.2.2 案例
- 案例一
object TestRelation {
def main(args: Array[String]): Unit = {
// 测试：>、>=、<=、<、==、!=
var a: Int = 2
var b: Int = 1
println(a > b) // true
println(a >= b) // true
println(a <= b) // false
println(a < b) // false
println("a==b" + (a == b)) // false
println(a != b) // true
}
}
- 关于Scala中的==与equals
package tiger.scala.chapter02
object Scala09_Operator {
def main(args: Array[String]): Unit = {
// 比较运算符
/*
* Scala
* ==和equals功能一样，比较的是内容是否相等，底层调用的是equals
*
* */
var s1:String = new String("abc")
var s2:String = "abc"
println(s1 == s2) // true
println(s1.equals(s2)) // true
println(s1.eq(s2)) // 比较地址
var b:Int = 10
b += 1 // 在java语言中，+=运算符可以自动进行强转，但是在scala语言中，+=底层不会自动进行强转
println(b)
// println(10 toString)
}
}
2.3 逻辑运算符
2.3.1 基本语法
-
假定：变量A为true，B为false
| 运算符 |
描述 |
实例 |
| && |
逻辑与 |
(A && B) 运算结果为 false |
| || |
逻辑或 |
(A || B) 运算结果为 true |
| ! |
逻辑非 |
!(A && B) 运算结果为 true |
2.3.2 案例
object TestLogic {
def main(args: Array[String]): Unit = {
// 测试：&&、||、!
var a = true
var b = false
println("a&&b=" + (a && b)) // a&&b=false
println("a||b=" + (a || b)) // a||b=true
println("!(a&&b)=" + (!(a && b))) // !(a&&b)=true
}
}
2.4 赋值运算符
2.4.1 基本语法
| 运算符 |
描述 |
实例 |
| = |
简单的赋值运算符，将一个表达式的值赋给一个左值 |
C = A + B 将 A + B 表达式结果赋值给 C |
| += |
相加后再赋值 |
C += A 等于 C = C + A |
| -= |
相减后再赋值 |
C -= A 等于 C = C - A |
| *= |
相乘后再赋值 |
C *= A 等于 C = C * A |
| /= |
相除后再赋值 |
C /= A 等于 C = C / A |
| %= |
求余后再赋值 |
C %= A 等于 C = C % A |
| <<= |
左移后赋值 |
C <<= 2等于 C = C << 2 |
| >>= |
右移后赋值 |
C >>= 2 等于 C = C >> 2 |
| &= |
按位与后赋值 |
C &= 2 等于 C = C & 2 |
| ^= |
按位异或后赋值 |
C ^= 2 等于 C = C ^ 2 |
| |= |
按位或后赋值 |
C |= 2 等于 C = C | 2 |
-
注意：Scala中没有++、--操作符，可以通过+=、-=来实现同样的效果；
2.4.2 案例
object TestAssignment {
def main(args: Array[String]): Unit = {
var r1 = 10
r1 += 1 // 没有++
r1 -= 2 // 没有--
}
}
2.5 位运算符
2.5.1 基本语法
- 下表中变量 a 为 60，b 为 13。
| 运算符 |
描述 |
实例 |
| & |
按位与运算符 |
(a & b) 输出结果 12 ，二进制解释： 0000 1100 |
| | |
按位或运算符 |
(a | b) 输出结果 61 ，二进制解释： 0011 1101 |
| ^ |
按位异或运算符 |
(a ^ b) 输出结果 49 ，二进制解释： 0011 0001 |
| ~ |
按位取反运算符 |
(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。 |
| << |
左移动运算符 |
a << 2 输出结果 240 ，二进制解释： 0011 0000 |
| >> |
右移动运算符 |
a >> 2 输出结果 15 ，二进制解释： 0000 1111 |
| >>> |
无符号右移 |
a >>>2 输出结果 15, 二进制解释: 0000 1111 |
2.5.2 案例
object TestPosition {
def main(args: Array[String]): Unit = {
// 测试：1000 << 1 =>10000
var n1 :Int =8
n1 = n1 << 1
println(n1)
}
}
2.6 Scala运算符本质
- 在Scala中其实是没有运算符的，所有运算符都是方法。
- 如果函数参数只有一个，或者没有参数，()可以省略
object TestOpt {
def main(args: Array[String]): Unit = {
// 标准的加法运算
val i:Int = 1.+(1)
// （1）当调用对象的方法时，.可以省略
val j:Int = 1 + (1)
// （2）如果函数参数只有一个，或者没有参数，()可以省略
val k:Int = 1 + 1
println(1.toString())
println(1 toString())
println(1 toString)
}
}