Scala——（常用类型与字面量，Scala类层次结构，值与变量&自动类型推断，操作符，块表达式和赋值语句，输出和输出，字符串插值器，对象相等性）

常用类型与字面量

1. Scala和Java一样，有8种数值类型 Byte、Short、Int、Long、Float、Double、Char、Boolean 类型；和 Java 不同的是 ，这些类型都是类，有自己的属性和方法。
2. Scala并不刻意的区分基本类型和引用类型。String 直接引用 Java.lang.String 中的类型，String在需要时能隐式转换为StringOps，因此不需要任何额外的转换，String就可以使用StringOps中的方法。
3. Scala每一种数据类型都有对应的Rich类型，如RichInt、RichChar等，为基本类型提供了更多的有用操作。

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

package com.scala.code

object BaseScala {
  def main(args: Array[String]): Unit = {
    println("Hello World")

    // 11
    println("11".toInt)

    // Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    println(1.to(10))

    // 10
    println(1.max(10))

    // 1
    println(1.min(11))

    // Range(1, 2, 3, 4, 5, 6, 7, 8, 9)
    println(1.until(10))
  }
}

整数字面量：整数字面量有两种形式，十进制与十六进制(0X/0x开头)

-- 十六进制整数字面量
scala> val a = 0xa
a: Int = 10

scala> val a = 0X00FF
a: Int = 255

scala> val magic = 0xcafe
magic: Int = 51966

-- 十进制整数字面量
scala> val dec1 = 255
dec1: Int = 255

scala> val dec1 = 31
dec1: Int = 31

-- Long类型整数字面量
scala> val magic = 0xcafeL
magic: Long = 51966

scala> val long1 = 255L
long1: Long = 255

-- Short 或 Byte 类型，需要明确声明，否则编译器会推断为Int类型
scala> val little: Short = 32767
little: Short = 32767


scala> val littler: Byte = 127
littler: Byte = 127

浮点数字面量

-- 十进制数、可选的小数点、可选的e开头的指数
scala> val big = 3.1415926
big: Double = 3.1415926

scala> val bigger = 3.1415926e1
bigger: Double = 31.415926

-- 浮点数字面量以F/f结尾为Float类型；否则为Double类型；
scala> val litte = 0.31415926f
litte: Float = 0.31415927

scala> val litte = 0.31415926e1F
litte: Float = 3.1415925

字符字面量

scala> val a = 'A'
a: Char = A

-- 用字符的Unicode码来表示。Unicode码前128个字符就是ASCII码
scala> val b = '\u0042'
b: Char = B

-- 转义字符
scala> val mark = '\'
<console>:1: error: unclosed character literal
val mark = '\'
				^

scala> val mark = '\\'
mark: Char = \

字符串字面量

scala> val str = "Hello Scala"
str: String = Hello Scala

Scala类层次结构

1. Scala中，所有的类，包括值类型和引用类型，都最终继承自一个统一的根类型Any。
2. Scala中定义了以下三个底层类：
   1. Any是所有类型共同的根类型，Any是AnyRef和AnyVal的超类
   2. AnyRef是所有引用类型的超类
   3. AnyVal是所有值类型的超类

3. Null是所有引用类型的子类型，Null类只有一个实例对象null，并且null可以赋值给任意引用类型，但是不能赋值给值类型。
4. Nothing位于Scala类继承关系的底部，它是其他所有其他类型的子类型
   1. Nothing对泛型结构有用 。比如，空列表Nil的类型就是List[Nothing]
   2. Nothing的可以给出非正常终止的信号。比如，使用Nothing处理异常
5. Unit类型用来标识过程，过程就是没有返回值的方法，Unit类似于Java里的void。Unit只有一个实例()。

-- null 不能赋值给值类型
scala> val i: Int = null
<console>:11: error: an expression of type Null is ineligible for implicit
conversion
			val i: Int = null

scala> val str: String = null
str: String = null

-- 使用 Nothing 处理异常
val test = false
val thing: Int = if (test) 42 else throw new Exception("ERROR!")

-- Unit类型只有一个实例()，该实例没有实际意义
scala> val a = ()
a: Unit = ()

值与变量&自动类型推断

1. Scala当中的声明变量可以使用以下两种方式：
   1. val，值 – value，用val定义的变量，值是不可变的
   2. var，变量 – variable，用var定义的变量，值是可变的
2. 声明变量时，可以不指定变量的数据类型，编译器会根据赋值内容自动推断当前变量的数据类型。
   1. 简单数据类型可以省略，对于复杂的数据类型建议明确声明；
   2. 声明变量时，可以将多个变量放在一起声明。

   -- val定义的变量不可更改，变量的类型编译器可以进行自动类型推断
   val name = "zhangsan"
   
   -- 必要时可以指定数据类型
   var name: String = null
   
   -- 可以将多个值或变量放在一起声明
   val x, y = 100;
   var name, message: String = null
   

操作符

1. Scala的算术操作符、位操作符与 Java中的效果一样的，但是Scala中的操作符都是方法

2. Scala 没有提供 ++、-- 操作符，但是可以使用+=、-=

   a + b 等价 a.+(b)
   1 to 10 等价 1.to(10)
   

块表达式和赋值语句

1. {} 块包含一系列表达式，其结果也是一个表达式，块中最后一个表达式的值就是块的值。赋值语句返回Unit类型，代表没有值；

   val x1 = 1
   val y1 = 1
   val x2 = 0
   val y2 = 0
   val distance = {
     val dx = x1 - x2
     val dy = y1 - y2
     math.sqrt(dx*dx + dy*dy)
     
     //1.4142135623730951
     println( math.sqrt(dx*dx + dy*dy))
   }
   
   -- 赋值语句的值是Unit类型，不要把它们串接在一起。
   var y = 0
   val x = y = 1
   
   // (x=(),y=1)
   println( "x="+x,"y="+y)
   

输出和输出

1. 通过readLine 从控制台读取一行输入。

2. 如果要读取数字、Boolean或者字符，可以用readInt、readDouble、readByte、readShort、readLong、readFloat、readBoolean或者readChar。

3. print、println、printf 可以将结果输出到屏幕；

   -- printf 带有C语言风格的格式化字符串的 printf 函数
   printf("Hello, %s! You are %d years old.", "Scala", 18)
   

字符串插值器

1. Scala 提供了三种字符串插值器：

   1. s 插值器，对内嵌的每个表达式求值，对求值结果调用toString，替换掉字面量中的那些表达式
   2. f 插值器，它除s插值器的功能外，还能进行格式化输出，在变量后用%指定输出格式，使用java.util.Formatter中给出的语法
   3. raw 插值器，按照字符串原样进行输出

   package com.scala.code
   
   object InterpolationScala {
     def main(args: Array[String]): Unit = {
   
       // s插值器
       val subject = "Spark"
       val str1 = s"Hello, $subject"
       // Hello, Spark
       println(str1)
   
       val arr = (1 to 10).toArray
       val str2 = s"arr.length = ${arr.length}"
       // arr.length = 10
       println(str2)
       // The answer is 36
       println(s"The answer is ${6*6}")
   
       // f插值器
       val year=2020
       val month=6
       val day=9
       
       // 2020-6-9
       println(s"$year-$month-$day")
   
       // yyyy-MM-dd，不足2位用0填充 2020-06-09
       println(f"$year-$month%02d-$day%02d")
   
       // raw插值器
       // a
       // b	c
       println("a\nb\tc")
       // a\nb\tc
       println(raw"a\nb\tc")
       // a\nb\tc
       println("""a\nb\tc""")
     }
   }
   

对象相等性

1. Java 中可以 == 来比较基本类型和引用类型：

   1. 对基本类型而言，比较的是值的相等性
   2. 对引用类型而言，比较的是引用相等性，即两个变量是否指向JVM堆上的同个对象

2. Scala中，要比较两个基础类型的对象是否相等，可以使用 == 或 !=；

   // true
   println(1==1)
   // true
   println(1 !=2 )
   

3. == 或 != 可以比较同一类型的两个对象；

   // true
   println(List(1,2,3) == List(1,2,3))
   // true
   println(List(1,2,3) != Array(4,5,6))
   

4. == 或 != 还可以比较不同类型的两个对象：

   // true
   println(2 == 2.0)
   // false
   println(List(1,2,3) == "Scala")