Scala数据类型

一、数据类型

（1）Scala中一切数据都是对象，都是Any的子类。
（2）Scala中数据类型分为两大类：数值类型（AnyVal）、 引用
类型（AnyRef），不管是值类型还是引用类型都是对象。
（3）Scala数据类型仍然遵守，低精度的值类型向高精度值类型，
自动转换（隐式转换）。
（4）Scala中的StringOps是对Java中的String增强
（5）Unit：对应Java中的void，用于方法返回值的位置，表 示方法
没有返回值。Unit是一个数据类型，只有一个对象 就是()。Void不是
数据类型，只是一个关键字。
（6）Null是一个类型，只有一个对象就是null。它是所有引用类型
（AnyRef）的子类。
（7）Nothing，是所有数据类型的子类，主要用在一个函数没有明
确返回值时使用，因为这样我们可以把抛出的返回值，返回给任何
的变量或者函数。

二、常见数据类型

2.1整数类型（Byte、Short、Int、Long）

Scala 的整数类型就是用于存放整数值的，比如 12，30，3456 等等。

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

2.代码示例：

object Test5_DataType {
  def main(args: Array[String]): Unit = {
    //整数类型
    val a1: Byte = 127
    val a2: Byte = -128
    //  val a2:Byte = 128 //128超出Byte边界

    val a3 = 12  //整数默认类型是Int
    val a4:Long = 2225566556554455L //长整型数组在后边加L

    val a5:Byte = 10
    val a6:Byte =(10 + 20):Byte
    println(a6)                                  //30

    val a7:Byte = (a5 + 20).toByte  //调用方法，强制类型转换
    println(a7)                                 //30
  }
}

2.2浮点类型（ Float、 Double）

Scala 的浮点类型可以表示一个小数，比如 123.4f， 7.8， 0.12 等。

1.浮点分类

数据类型	描述
Float [4]	32 位, IEEE 754 标准的单精度浮点数
Double [8]	64 位 IEEE 754 标准的双精度浮点数

2.代码示例

object Test5_DataType {
  def main(args: Array[String]): Unit = {
    //浮点类型
    val f1:Float = 1.2345f    //Scala 的浮点型常量默认为 Double 型，声明 Float 型常量，须后加‘f’或‘F’
    val f2 = 25.6669955      //浮点类型默认是双精度浮点数
  }
}

2.3字符类型

1.介绍

字符类型可以表示单个字符，字符类型是 Char。

（1）字符常量是用单引号 ’ ’ 括起来的单个字符。
（2）\t ：一个制表位，实现对齐的功能
（3）\n ：换行符
（4）\ ：表示
（5）" ：表示"

2.代码示例

object Test5_DataType {
  def main(args: Array[String]): Unit = {
    //字符类型
    val c1:Char = 'a'
    println(c1)

    val c2:Char = '5'
    println(c2)

    //特殊字符
    val v3:Char = '\t'   //制表符
    val v4:Char = '\n'   //换行符
    println("555" + v3 +"dddd")           //555	dddd
    println("6666" + v4 +"dffsfs")
                                          //6666
                                          //dffsfs

    //转义字符
    val v5:Char = '\\'
    val v6:Char = '\"'
    println("ddf" + v5 + "65666")         //ddf\65666
    println("ddfdad" + v6 + "5565666")    //ddfdad"5565666

    //字符变量底层保存的是ASCII码
    val i1:Int = c1
    println("i1:" + i1)           //i1:97
    val i2:Int = c2
    println("i2:" + i2)           //i2:53

    val c7:Char = (i1 + 1).toChar
    println(c7)                    //b
    val c8:Char = (i2 +1).toChar
    println(c8)                     //6
  }
}

2.4布尔类型：Boolean

1.介绍

（1）布尔类型也叫Boolean 类型，Booolean 类型数据只允许取值 true 和 
false。
（2）boolean 类型占 1 个字节。

2.代码示例

	//布尔类型
    val c9:Boolean = false
    println(c9)                 //false

2.4空类型（Unit 、Null 和Nothing）

1.介绍

数据类型	描述
Unit	表示无值，和其他语言中 void 等同。用作不返回任何结果的方法的结果类型。Unit 只有一个实例值，写成()
Null	null , Null 类型只有一个实例值 null
Nothing	Nothing 类型在 Scala 的类层级最低端；它是任何其他类型的子类型。当一个函数，我们确定没有正常的返回值，可以用 Nothing 来指定返回类型，这样有一个好处，就是我们可以把返回的值（异常）赋给其它的函数或者变量（兼容性）

2.代码示例

   //空值Unit 
   	//Unit 类型用来标识过程，也就是没有明确返回值的函数。
	//由此可见，Unit 类似于 Java 里的void。Unit 只有一个实例
	//( )，这个实例也没有实质意义
    def m1():Unit = {
      println("s1被调用执行")    //s1被调用执行
    }
      val a = m1()
      println("a:" + a)         //a:()

    //空引用Null
    	//（2）Null 类只有一个实例对象，Null 类似于 Java 中
    	//的 null 引用。Null 可以赋值给任意引用类型（AnyRef），
    	//但是不能赋值给值类型（AnyVal）
    	
    //val n:Int =null           //运行报错
    var student:Student = new Student("Lili",25)
    student = null
    println(student)            //null

    //Nothing
    	//Nothing，可以作为没有正常返回值的方法的返回类型，
    	//非常直观的告诉你这个方法不会正常返回，而且由于
    	// Nothing 是其他任意类型的子类，他还能跟要求返回值的方法兼容。
    def m2(n:Int):Int = {
      if (n == 0)
        throw new NullPointerException
      else
        return n
    }

//    val j:Int = m2(0)
//    println("j:" + j)           //Exception in thread "main" java.lang.NullPointerException

    val jl:Int = m2(2)
    println("jl:" + jl)           //jl:2
  }

三、数据类型转换

3.1 数值类型自动转换

当 Scala 程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数值类型，这个就是自动类型转换（隐式转换）。数据类型按精度（容量）大小排序为：

代码示例：

object Test08_DataTypeConversion {
  def main(args: Array[String]): Unit = {
    // （1）自动提升原则：有多种类型的数据混合运算时，系统首先自动
    //将所有数据转换成精度大的那种数据类型，然后再进行计算。
    val a1: Byte = 11
    val a2: Long = 2222
    val result1: Long = a1 + a2
    val result2 = a1 + a2.toInt //强转

    // （2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就
    //会进行自动类型转换。
    val a3: Byte = 11
    val a4: Int = a3 //把低精度的数值赋值给高精度的int，正常
    //val a5:Byte = a4      //把高精度的值赋值给低精度的byte，报错

    // （3）（byte，short）和 char 之间不会相互自动转换。
    val c1: Byte = 11
    val c2: Char = 'a'
    //    val c3:Byte = c2     //报错，不能把char类型赋给byte数值类型
    //    println(c3)
    val c3: Int = c2 //char类型可以转换为int类型，所有可以赋值。
    println(c3) //97
    val c4: Byte = c2.toByte //char强制转换为byte类型
    println(c4)               //97
    // （4）byte，short，char 他们三者可以计算，在计算时首先转换为 
    //int 类型。
    // byte与short做加法的时候要转换为int
    val d1:Byte = 11
    val d2:Short = 28
    val d3:Char = 'w'
    val result11:Int = d1 + d2
    val result22:Int = d1 + d2 + d3
    println(result11)                 //39
    println(result22)                 //158
  }
}

3.2 强制类型转换

    //数值转string
    val n1:Int = 27
    val n2:String = n1 + ""
    val n22:String = 27.toString
    println(n2)               //27
    println(n22)              //27

    //string转数值
    val n3:Int = "11".toInt
    val n4:Float = "12.1".toFloat
    val n5:Int = "12.1".toFloat.toInt
    println(n5)              //12