一、Scala数据类型

Myth丶恋晨 2021-10-30 07:40 314阅读 0赞

**目录**

一、数据类型概述

1、scala数据类 型体系一览图

2、scala数据类型列表

二、数据类型

1、整数类型

2、浮点类型

3、字符类型(Char)

4、布尔类型：Boolean

5、Unit类型、Null类型和Nothing类型

三、值类型转换

1、值类型隐式转换

2、高级隐式转换和隐式函数

3、强制类型转换

4、标识符的命名规范

5、Scala关键字

--------------------

# 一、数据类型概述 #

**Scala 与 Java有着相同的数据类型，在Scala中数据类型都是对象，也就是说scala没有java中的原生类型。**

**Scala数据类型分为两大类 AnyVal(值类型) 和 AnyRef(引用类型)， 注意：不管是AnyVal还是AnyRef 都是对象。**

## **1、scala数据类 型体系一览图** ##

*  根类型Any
 *  Null是scala中的特别类型，它只有一个值null，是bottom class（底层类），是所有AnyRef的子类型
 *  Nothing也是底层类，是所有类的子类，开发中常将Nothing类型的值给任意变量或者函数，这里用来抛出异常使用很多，表名方法没有正常返回值

def sayHi():Nothing={
        throw  new Exception ("exception")
      }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3MyOTQ4NzgzMDQ_size_16_color_FFFFFF_t_70][]

## **2、scala数据类型列表** ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3MyOTQ4NzgzMDQ_size_16_color_FFFFFF_t_70 1][]

# 二、数据类型 #

## **1、整数类型** ##

![20190821174702905.png][]

**使用细节**

*  Scala各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证Scala程序的可移植性。
 *  Scala的整型 常量/字面量 默认为 Int 型，声明Long型 常量/字面量 须后加‘l’’或‘L’
 *  Scala程序中变量常声明为Int型，除非不足以表示大数，才使用Long

## **2、浮点类型** ##

**浮点型使用细节**

*  与整数类型类似，Scala 浮点类型也有固定的表数范围和字段长度，不受具体OS的影响。
 *  Scala的浮点型常量默认为Double型，声明Float型常量，须后加‘f’或‘F’。
 *  浮点型常量有两种表示形式：

十进制数形式：如：5.12 512.0f .512 (必须有小数点）

科学计数法形式:如：5.12e2 = 5.12乘以10的2次方 5.12E-2 = 5.12除以10的2次方

*  通常情况下，应该使用Double型，因为它比Float型更精确(小数点后大致7位)

## **3、字符类型(Char)** ##

字符类型可以表示单个字符,字符类型是Char， 16位无符号Unicode字符(2个字节), 区间值为 U+0000 到 U+FFFF

**（1）字符类型使用细节**

*  字符常量是用单引号(‘ ’)括起来的单个字符。例如：var c1 = 'a‘ var c2 = '中‘ var c3 = '9'
 *  Scala 也允许使用转义字符‘\\’来将其后的字符转变为特殊字符型常量。例如：var c3 = ‘\\n’ // '\\n'表示换行符
 *  可以直接给Char赋一个整数，然后输出时，会按照对应的unicode 字符输出 \['\\u0061' 97\]
 *  Char类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码.

![2019082118382496.png][]![20190821183844291.png][]

//原因及分析
    //    1、当将一个计算的结果赋值给一个变量,则编译器会进行类型转换及判断(即会看范围和类型)
    //    2、当将一个常量值(字面量)赋给一个变量时,则编译器会进行范围的判定
        val c1 :Char =98//不报错
        val c2 :Char = 97+1//报错,检查运算类型,计算后为Int,
        var c3 : Char =  'a' + 1//报错,a先转Int,计算后为Int
        var c4 :Char  = 99999//报错，范围越界

**（2）字符类型本质探讨**

*  字符型 存储到 计算机中，需要将字符对应的码值（整数）找出来 存储：字符——>码值——>二进制——>存储 读取：二进制——>码值——> 字符——>读取
 *  字符和码值的对应关系是通过字符编码表决定的(是规定好)， 这一点和Java一样。

## 4、布尔类型：Boolean ##

*  布尔类型也叫Boolean类型，Booolean类型数据只允许取值true和false
 *  boolean类型占1个字节。
 *  boolean 类型适于逻辑运算，一般用于程序流程控制

## 5、Unit类型、Null类型和Nothing类型 ##

**（1）基本说明**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3MyOTQ4NzgzMDQ_size_16_color_FFFFFF_t_70 2][]

**（2）、使用细节和注意事项**

Null类只有一个实例对象，null，类似于Java中的null引用。null可以赋值给任意引用类型(AnyRef)，但是不能赋值给值类型(AnyVal: 比如 Int, Float, Char, Boolean, Long, Double, Byte, Short)

object Test {
      def main(args: Array[String]): Unit = {
        val dog :Dog = null
        val char1 :Char = null//下划线表示隐式转化，这一行报错
      }
    }
    class Dog{
    }

Unit类型用来标识过程，也就是没有明确返回值的函数。 由此可见，Unit类似于Java里的void。Unit只有一个实例， ()，这个实例也没有实质的意义

def sayHi():Unit={
        println("被调用")
      }

Nothing，可以作为没有正常返回值的方法的返回类型，非常直观的告诉你这个方法不会正常返回，而且由于Nothing是其他任意类型的子类，**他还能跟要求返回值的方法兼容。**

def sayHi():Nothing={
        throw  new Exception ("exception")
      }

# 三、值类型转换 #

**当Scala程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数据类型，这个就是自动类型转换(隐式转换)。**

数据类型按精度(容量)大小排序为

![20190821195259368.png][]

## 1、值类型隐式转换 ##

**（1）自动类型转换细节说明**

*  有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。 5.6 + 10 =>double
 *  当我们把精度(容量)大 的数据类型赋值给精度(容量)小 的数据类型时，就会报错，反之就会进行自动类型转换。
 *  (byte, short) 和 char之间不会相互自动转换。

var b :Byte = 10
    var c:Char = b//error

*  byte，short，char 他们三者可以计算，在计算时首先转换为int类型。

var b : Byte = 10
        var c : Char = 90
        var s : Short = b + c//error
        var s2 : Short = 10 + 90//error
        var s3 : Short = 100

*  自动提升原则： 表达式结果的类型自动提升为 操作数中最大的类型

## 2、高级隐式转换和隐式函数 ##

（后面再学）

## 3、强制类型转换 ##

自动类型转换的**逆过程**，将容量大的数据类型转换为容量小的数据类型。使用时要加上**强制转函数**，但可能造成**精度降低或溢出**,格外要注意。

java  :  int num = (int)2.5
    scala :  var num : Int =  2.7.toInt

**（1）强制类型转换细节说明**

*  当进行数据的 从 大——>小，就需要使用到强制转换
 *  强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级

val num1: Int = 10 * 3.5.toInt + 6 * 1.5.toInt  // 36
    val num2: Int = (10 * 3.5 + 6 * 1.5).toInt // 44
    println(num1 + " " + num2)

*  Char类型可以保存 Int的常量值，但不能保存Int的变量值，需要强转

val char1 : Char = 1
        val num :Int = 1
        val char2 : Char = num //error

*  Byte和Short类型在进行运算时，当做Int类型处理

**（2）值类型和String类型的转换**

*  基本类型转String类型

将基本类型的值+""

val d1 = 1.2
    val s1 = d1 + "" //加好下有下划线，表示编译器做了转换

*  String类型转基本数据类型

通过基本类型的String的 toXxx方法

在将String 类型转成 基本数据类型时，要确保String类型能够转成有效的数据，比如 我们可以把 "123" , 转成一个整数，但是不能把 "hello" 转成一个整数

//    2、 String 转基本数据类型
        val s2 = "12"
        val num1 = s2.toInt
        val num2 = s2.toByte
        val num3 = s2.toDouble
        val num4 = s2.toLong
    //  字符串"12.5"是否可以转成Int
        val s3 = "hello"
        val s4 = "12.5"
        val d2 =s2.toInt
        val d3 = s3.toInt //error
        val d4 = s4.toInt//error, 转成Double，在将Double 赋值给Int变量则报错
        val d5 = s4.toDouble
        val d6 = s4.toFloat

## 4、标识符的命名规范 ##

**（1）标识符概念**

Scala 对各种变量、方法、函数等命名时使用的字符序列称为标识符

凡是自己可以起名字的地方都叫标识符

**（2）标识符的命名规则(记住)**

*  首字符为字母，后续字符任意字母和数字，美元符号，可后接下划线\_
 *  数字不可以开头。

首字符为操作符(比如+ - \* / )，后续字符也需跟操作符 ,至少一个(反编译)。

val ++ = "hello"
    val -+ = 90
    val ++q = 100//error

*  操作符(比如+-\*/)不能在标识符中间和最后。
 *  用反引号\`....\`包括的任意字符串，即使是关键字(39个)也可以 \[true\]。

val `true` = "hello scala!"

**（3）标识符举例**

hello    // ok
    hello12 // ok
    1hello  // error
    h-b   // error
    x h   // error
    h_4   // ok
    _ab   // ok
    Int    // ok, 在scala中，Int 不是关键字，而是预定义标识符,可以用，但是不推荐
    Float  // ok
    _   // 不可以，因为在scala中，_ 有很多其他的作用，因此不能使用
    Abc    // ok
    +*-   // ok
    +a  // error

（4）标识符命名注意事项

*  包名：尽量采取有意义的包名，简短，有意义
 *  变量名、函数名 、方法名 采用驼峰法。

## 5、Scala关键字 ##

Scala有39个关键字

1.  package, import, class, object, trait, extends, with, type, forSome
2.  private, protected, abstract, sealed, final, implicit, lazy, override
3.  try, catch, finally, throw
4.  if, else, match, case, do, while, for, return, yield
5.  def, val, var
6.  this, super
7.  new
8.  true, false, null

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3MyOTQ4NzgzMDQ_size_16_color_FFFFFF_t_70]: /images/20211029/20289b050b4b4e0691bd78a1b92fe0c3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3MyOTQ4NzgzMDQ_size_16_color_FFFFFF_t_70 1]: /images/20211029/c491f9d58da4460d99abb921306b5f7f.png
[20190821174702905.png]: /images/20211029/62f73b43fa82421eb1520ba8a1817ade.png
[2019082118382496.png]: https://img-blog.csdnimg.cn/2019082118382496.png
[20190821183844291.png]: /images/20211029/c49ae5d04b59463193d550ed3bf9e854.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3MyOTQ4NzgzMDQ_size_16_color_FFFFFF_t_70 2]: /images/20211029/3fab9edc50fc4315836685e29302fdc8.png
[20190821195259368.png]: /images/20211029/dc06f47c263c476cba27b4e4796e5eba.png