Scala 编程—第二节：数据类型及操作、流程控制

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/HG_Harvey/article/details/82224804

1.Scala 数据类型

Scala 与 Java有着相同的数据类型，下表列出了 Scala 支持的数据类型

数据类型	描述
Byte	8位有符号补码整数。数值区间为 -128 到 127
Short	16位有符号补码整数。数值区间为 -32768 到 32767
Int	32位有符号补码整数。数值区间为 -2147483648 到 2147483647
Long	64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807
Float	32 位, IEEE 754标准的单精度浮点数
Double	32 位 IEEE 754标准的单精度浮点数
Char	16位无符号Unicode字符, 区间值为 U+0000 到 U+FFFF
String	字符序列
Boolean	true或false
Unit	表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
Null	null 或空引用
Nothing	Nothing类型在Scala的类层级的最低端；它是任何其他类型的子类型。
Any	Any是所有其他类的超类
AnyRef	AnyRef类是Scala里所有引用类(reference class)的基类

Scala的基本数据类型与Java中的基本数据类型是一一对应的，不同的是Scala的基本数据类型头字母必须大写，下面我们以Int、Long、String、Char、Double及Float类型为例介绍Scala的变量定义及数据类型

• 整数类型

scala> val intNumber = 10
intNumber: Int = 10

• 浮点类型

// Double类型定义,直接输入浮点数，编译器会将其自动推断为Double类型
scala> val doubleNumber = 3.1415
doubleNumber: Double = 3.1415

scala> val floatNumber = 3.14
floatNumber: Double = 3.14

// 要定义Float类型浮点数，需要在浮点数后面加F或f
scala> val floatNumber = 3.14F
floatNumber: Float = 3.14

scala> val floatNumber = 3.14f
floatNumber: Float = 3.14

• 字符

// 字符定义，用''将字符包裹
scala> val charType = 'A'
charType: Char = A

常用特殊字符

特殊字符	描述
\n	换行符，其Unicode编码为 (\u000A)
\b	回退符，其Unicode编码为 (\u0008)
\t	tab制表符 ，其Unicode编码(\u0009)
\”	双引号，其Unicode编码为 (\u0022)
\’	单引号，其Unicode编码为 (\u0027)
\	反斜杆，其Unicode编码为(\u005C)

• 字符串

// 字符串变量用""包裹
scala> val helloworld = "hello world"
helloworld: String = hello world

// 要定义"Hello World"，可以加入转义符\
scala> val helloworld = "\"Hello World\""
helloworld: String = "Hello World"

//如果希望能够原样输出字符串中的内容，则用三个引号"""将字符串包裹起来
scala> println("""hello world \n hello scala""")
hello world \n hello scala

• 布尔类型

scala> val flag = true
flag: Boolean = true

• 变量定义的两种修饰符
  scala中变量定义有两种修饰符，一种val，一种是var，两者区别是val修饰的变量不可变，var修改的变量可变，可再次赋值，以上面定义的helloworld为例

// val 修饰的变量不可再次赋值，否则会报错 reassignment to val
scala> val hello = "hello"
hello: String = hello

scala> hello = "hello scala"
<console>:12: error: reassignment to val
       hello = "hello scala"
             ^

scala> var hello = "hello"
hello: String = hello

scala> hello = "hello scala"
hello: String = hello scala

2.运算符

2.1 算术操作

运算符	描述
+	加号
-	减号
*	乘号
/	除号
%	取余

实例：

// 整数求和，编译器会将其转换为(1).+(2)执行
scala> var sum = 1 + 2
sum: Int = 3

//前一语句等同于下列语句
scala> var sum = (1).+(2)
sum: Int = 3

//操作符重载,编译器会将其转换为(1).+(2L)执行
scala> var longSum = 1 + 2L
longSum: Long = 3

// 减法
scala> var jian = 1-5
jian: Int = -4

// 除法
scala> val chu = 1/5
chu: Int = 0

// 取模
scala> val mo = 1%5
mo: Int = 1

// 乘法
scala> val cheng = 1L * 5L
cheng: Long = 5

// scala中可以用+ -符号来表示正负数，例如-3 +3，并且可以加入到运算符当中
scala> val num = 1 + -5
num: Int = -4

2.2 关系运算

运算符	描述
==	等于
!=	不等于
>	大于
<	小于
>=	大于等于
<=	小于等于

实例：

scala> 5 > 1
res1: Boolean = true

scala> 5 < 1
res2: Boolean = false

scala> 5 <= -1
res3: Boolean = false

scala> 5 <= 10
res4: Boolean = true

// "!" 表示求反
scala> !(5 <= -5)
res5: Boolean = true

scala> 5 != -5
res6: Boolean = true

scala> 5 == 5
res7: Boolean = true

2.3 逻辑运算

运算符	描述
&&	逻辑与
||	逻辑或
!	逻辑非

实例：

scala> val a = true
a: Boolean = true

scala> val b = false
b: Boolean = false

scala> a && b
res8: Boolean = false

scala> a || b
res9: Boolean = true

scala> !(a || b)
res10: Boolean = false

scala> a && !b
res11: Boolean = true

##2.4 赋值运算符

运算符	描述	实例
=	简单的赋值运算，指定右边操作数赋值给左边的操作数	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

实例：

object Test {
  def main(args: Array[String]): Unit = {
    var a = 2;
    var b = 5;
    var c = 0;

    c += b
    println("c += b = " + c) // c += b = 5

    c -= a
    println("c -= a = " + c) // c -= a = 3

    c *= 5
    println("c *= 5 = " + c) // c *= 5 = 15

    c /= b
    println("c /= a = " + c) // c /= a = 3

    c %= a
    println("c %= a = " + c) // c %= a = 1
  }
}

3. 流程控制

• if使用

scala> val num = if("hello"=="hello") 1 else 0
num: Int = 1

• while使用

scala> var a = 1
a: Int = 1

scala> while(a <= 10) {
     | println("a = " + a)
     | a += 1
     | }
a = 1
a = 2
a = 3
a = 4
a = 5
a = 6
a = 7
a = 8
a = 9
a = 10

• do while 使用

scala> do{
     | println("a = " + a)
     | a += 1
     | } while(a <= 10)
a = 1
a = 2
a = 3
a = 4
a = 5
a = 6
a = 7
a = 8
a = 9
a = 10

• for使用

// 1 to 10 表示1到10
scala> for(a <- 1 to 10){
     | println("a = " + a)
     | }
a = 1
a = 2
a = 3
a = 4
a = 5
a = 6
a = 7
a = 8
a = 9
a = 10

// 1 until 10 表示1到10但不包括10
scala> for(a <- 1 until 10){
     | println("a = " + a)
     | }
a = 1
a = 2
a = 3
a = 4
a = 5
a = 6
a = 7
a = 8
a = 9

// 在 for 循环 中你可以使用分号 (;) 来设置多个区间，它将迭代给定区间所有的可能值
scala> for(a <- 1 to 3; b <- 1 to 3){
     | println("a = " + a)
     | println("b = " + b)
     | }
a = 1
b = 1
a = 1
b = 2
a = 1
b = 3
a = 2
b = 1
a = 2
b = 2
a = 2
b = 3
a = 3
b = 1
a = 3
b = 2
a = 3
b = 3

// 可以将 for 循环的返回值作为一个变量存储。语法格式如下：
var retVal = for{ var x <- List
     if condition1; if condition2...
}yield x
// 大括号中用于保存变量和条件，retVal 是变量，循环中的 yield 会把当前的元素记下来，保存在集合中，循环结束后将返回该集合
实例：
scala> var a = 0
a: Int = 0

scala> val numList = List(1,2,3,4,5,6,7,8,9,10)
numList: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> var retVal = for{ a<- numList if a != 3; if a < 8 } yield a
retVal: List[Int] = List(1, 2, 4, 5, 6, 7)

scala> for(a <- retVal){
     | println("a = " + a)
     | }
a = 1
a = 2
a = 4
a = 5
a = 6
a = 7