Scala数据类型与基础操作符

青旅半醒 2023-05-29 03:49 21阅读 0赞

### 1.1 类型支持 ###

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

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

**类层次结构图如下图所示**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODg1NDg4_size_16_color_FFFFFF_t_70]  
Any是所有类型的超类型，也称为顶级类型。它定义了某些通用的方法，例如`equals`，`hashCode`，和`toString`。`Any`有两个直接子类：`AnyVal`和`AnyRef`。

`AnyVal`代表值类型。有九种预定义的值类型和它们是不可为空：Double，Float，Long，Int，Short，Byte，Char，Unit，和Boolean。`Unit`是不包含有意义信息的值类型。恰好有一个实例Unit可以宣布从字面上像这样：()。所有函数都必须返回某些内容，因此有时Unit是有用的返回类型。

`AnyRef`代表参考类型。所有非值类型都定义为引用类型。Scala中的每个用户定义类型都是的子类型AnyRef。如果在Java运行时环境的上下文中使用Scala，则AnyRef与相对应`java.lang.Object`。

### 1.2 类型转换 ###

Scala的类型转换和java的类型转换基本相同  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODg1NDg4_size_16_color_FFFFFF_t_70 1]  
For example:

val x: Long = 987654321
    val y: Float = x  // 9.8765434E8 (note that some precision is lost in this case)
    
    val face: Char = '☺'
    val number: Int = face  // 9786

下面这些将不会通过编译：

val x: Long = 987654321
    val y: Float = x  // 9.8765434E8
    val z: Long = y  // Does not conform

### 1.3 变量定义 ###

Scala 的变量分为两种，val 和 var，其区别如下：

*  val ：声明常量，类似于 Java 中的 final，一旦初始化就不能被重新赋值；
 *  var ：声明变量，类似于 Java 中的非 final 变量，在整个声明周期内 var 可以被重新赋值；

val x = 1 + 1
    println(x) // 2

如果再给常量x赋值

x = 3 // This does not compile.

Scala可以推断值的类型，但是我们可以显式地声明类型：

val x: Int = 1 + 1
    val c:String="hello scala"

### 2 字面量 ###

Scala 和 Java 字面量在使用上很多相似，比如都使用 F 或 f 表示浮点型，都使用 L 或 l 表示 Long 类型。下文主要介绍两者差异部分。

scala> 1.2
    res0: Double = 1.2
    
    scala> 1.2f
    res1: Float = 1.2
    
    scala> 1.4F
    res2: Float = 1.4
    
    scala> 1
    res3: Int = 1
    
    scala> 1l
    res4: Long = 1
    
    scala> 1L
    res5: Long = 1

#### 2.1 整数字面量 ####

Scala 支持 10 进制和 16 进制，但不支持八进制字面量和以 0 开头的整数字面量。

scala> 012
    <console>:1: error: Decimal integer literals may not have a leading zero. (Octal syntax is obsolete.)

#### 2.2 字符串字面量 ####

##### 1. 字符字面量 #####

字符字面量由一对单引号和中间的任意 `Unicode` 字符组成。你可以显式的给出原字符、也可以使用字符的 Unicode 码来表示，还可以包含特殊的转义字符。

scala> '\u0041'
    res0: Char = A
    
    scala> 'a'
    res1: Char = a
    
    scala> '\n'
    res2: Char =

#### 2. 字符串字面量 ####

字符串字面量由双引号包起来的字符组成。

scala> "hello world"
    res3: String = hello world

#### 3.原生字符串 ####

**Scala 提供了 “”" … “”" 语法，通过三个双引号来表示原生字符串和多行字符串，使用该种方式，原生字符串中的特殊字符不会被转义。**

val warning =
            s"""
              |spark.driver.libraryPath was detected (set to '$value').
              |This is deprecated in Spark 1.2+.
              |
              |Please instead use: $driverLibraryPathKey
            """.stripMargin

#### 4. 插值表达式 ####

**Scala提供了一种从数据创建字符串的新机制：字符串插值。字符串插值允许用户将变量引用直接嵌入处理后的字符串文字中**

scala> val name="xiaoming"
    name: String = xiaoming
    
    scala> println(s"My name is $name,I'm ${2*9}.")
    My name is xiaoming,I'm 18.

### 3. 运算符 ###

Scala 和其他语言一样，支持大多数的操作运算符：

*  算术运算符（+，-，\*，/，%）
 *  关系运算符（==，!=，>，<，>=，<=）
 *  逻辑运算符 (&&，||，!，&，|)
 *  位运算符 (~，&，|，^，<<，>>，>>>)
 *  赋值运算符 (=，+=，-=，\*=，/=，%=，<<=，>>=，&=，^=，|=)

`+ - * /` 等操作符完成的是它们通常的工作，位操作符`~，&，|，^，<<，>>，>>>`也是一样。**有一点特别的是scala中的操作符是方法**，例如：

a+b

是如下方法的简写

a.+(b)

这里的+实际上是方法名，通常来说，我们可以用`a 方法 b`作为`a.方法(b)`的简写，如`1 to 10` 就是`1.to(10)`的简写

`Scala`操作符的第二个不同是没有提供`++`和`--`操作符

scala> var a=1
    a: Int = 1
    
    scala> a+=1
    
    scala> a
    res8: Int = 2
    
    scala> a-=1
    
    scala> a
    res10: Int = 1

如果想要判断两个对象是否相等，可以使用 == 和 !=,这两个操作符可以用于所有的对象，包括 null。

scala> 1==2
    res2: Boolean = false
    
    scala> List(1,2,3)==List(1,2,3)
    res3: Boolean = true
    
    scala> 1==1.0
    res4: Boolean = true
    
    scala> List(1,2,3)==null
    res5: Boolean = false
    
    scala> null==null
    res6: Boolean = true

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODg1NDg4_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191105145231401.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODg1NDg4,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODg1NDg4_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191105150603857.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODg1NDg4,size_16,color_FFFFFF,t_70