Scala基础知识大全

目录

 

一、 Scala入门

1.1 概述

1.1.1 为什么学习Scala

1.1.2 Scala发展历史

1.1.3 Scala和Java关系

1.1.4 Scala语言特点

1.2 Scala环境搭建

1.3 Scala插件安装

1.4 HelloWorld案例

1.4.1 创建IDEA项目工程

1.4.2 class和object说明

1.4.3 Scala程序反编译

1.5 关联Scala源码

二、变量和数据类型

2.1 注释

2.2 变量和常量（重点）

2.3 标识符的命名规范

2.4 字符串输出

2.5 键盘输入

2.6 数据类型（重点）

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

2.8 浮点类型（Float、Double）

2.9 字符类型（Char）

2.10 布尔类型：Boolean

2.11 Unit类型、Null类型和Nothing类型（重点）

2.12 类型转换

2.12.1 数值类型自动转换

2.12.2 强制类型转换

2.12.3 数值类型和String类型间转换

三、 运算符

3.1 算术运算符

3.2 关系运算符（比较运算符）

3.3 逻辑运算符

3.4 赋值运算符

3.5 位运算符

3.6 Scala运算符本质

---

一、 Scala入门

1.1 概述

1.1.1 为什么学习Scala

1.1.2 Scala发展历史

1.1.3 Scala和Java关系

一般来说，学Scala的人，都会Java，而Scala是基于Java的，因此我们需要将Scala和Java以及JVM之间的关系搞清楚，否则学习Scala你会蒙圈。

Scala、Java与JVM关系图

1.1.4 Scala语言特点

1.2 Scala环境搭建

1）安装步骤

（1）首先确保JDK1.8安装成功

（2）下载对应的Scala安装文件scala-2.12.11.zip

（3）解压scala-2.12.11.zip，我这里解压到D:\Tools

（4）配置Scala的环境变量

注意1：解压路径不能有任何中文路径，最好不要有空格。

注意2：环境变量要大写SCALA_HOME

2）测试

需求：计算两数a和b的和。

步骤

（1）在键盘上同时按win+r键，并在运行窗口输入cmd命令

（2）输入Scala并按回车键，启动Scala环境。然后定义两个变量，并计算求和。

1.3 Scala插件安装

默认情况下IDEA不支持Scala的开发，需要安装Scala插件。

1）插件离线安装步骤

（1）建议将该插件scala-intellij-bin-2017.2.6.zip文件，放到Scala的安装目录D:\Tools\scala-2.12.11下，方便管理。

（2）打开IDEA，在左上角找到File->在下拉菜单中点击Setting... ->点击Plugins->点击右下角Install plugin from disk…，找到插件存储路径D:\Tools\scala-2.12.11\scala-intellij-bin-2017.2.6.zip，最后点击ok。

2）插件在线安装（可选）

       （1）在搜索插件框里面输入Scala->点击Install->点击ok->点击apply。

（2）重启IDEA，再次来到Scala插件页面，已经变成Uninstall。

1.4 HelloWorld案例

1.4.1 创建IDEA项目工程

1）打开IDEA->点击左侧的Flie->选择New->选择Project…

2）创建一个Maven工程，并点击next

3）GroupId输入com.aaaa->ArtifactId输入scala00000->点击next->点击Finish

注意：工程存储路径一定不要有中文和空格

4）指定项目工作目录空间

5）默认下，Maven不支持Scala的开发，需要引入Scala框架。

在scala00000项目上，点击右键-> Add Framework Support... ->选择Scala->点击OK

注意：如果是第一次引入框架，Use libary看不到，需要选择你的Scala安装目录，然后工具就会自动识别，就会显示user libary。

6）创建项目的源文件目录

右键点击main目录->New->点击Diretory -> 写个名字（比如scala）。

右键点击scala目录->Mark Directory as->选择Sources root，观察文件夹颜色发生变化。

7）在scala包下，创建包com.aaaaa.chapter01包名和Hello类名，

       右键点击scala目录->New->Package->输入com.aaaa.chapter01->点击OK。

右键点击com.aaaa.chapter01->New->Scala Class->Kind项选择Object->Name项输入Hello。

8）编写输出Hello Scala案例

在类中中输入main，然后回车可以快速生成main方法；

在main方法中输入println("hello scala")

运行后，观察控制台打印输出：

hello scala

hello scala

说明：Java中部分代码也是可以在Scala中运行。

1.4.2 class和object说明

对第一个程序进行说明

class与object的说明

1.4.3 Scala程序反编译

1）在项目的target目录Hello文件上点击右键->Show in Explorer->看到object底层生成Hello$.class和Hello.class两个文件

2）采用Java反编译工具jd-gui.exe反编译代码，将Hello.class拖到jd-gui.exe页面

 Scala程序反编译：

1.5 关联Scala源码

在使用Scala过程中，为了搞清楚Scala底层的机制，需要查看源码，下面看看如何关联和查看Scala的源码包。

1）查看源码

例如查看Array源码。按住ctrl键->点击Array->右上角出现Attach Soures…

2）关联源码

（1）将我们的源码包scala-sources-2.12.11.tar.gz拷贝到D:\Tools\scala-2.12.11\lib文件夹下，并解压为scala-sources-2.12.11文件夹

（2）点击Attach Sources…->选择D:\Tools\scala-2.12.11\lib\scala-sources-2.12.11，这个文件夹，就可以看到源码了

二、变量和数据类型

2.1 注释

Scala注释使用和Java完全一样。

注释是一个程序员必须要具有的良好编程习惯。将自己的思想通过注释先整理出来，再用代码去体现。

1）基本语法

（1）单行注释：//

（2）多行注释：/* */

（3）文档注释：

/**

*

*/

2）代码规范

（1）使用一次tab操作，实现缩进，默认整体向右边移动，用shift+tab整体向左移

（2）或者使用ctrl + alt + L来进行格式化

（3）运算符两边习惯性各加一个空格。比如：2 + 4 * 5。

（4）一行最长不超过80个字符，超过的请使用换行展示，尽量保持格式优雅

2.2 变量和常量（重点）

常量：在程序执行的过程中，其值不会被改变的变量

0）回顾：Java变量和常量语法

       变量类型 变量名称 = 初始值                 int a = 10

       final常量类型 常量名称 = 初始值          final int b = 20

1）基本语法

       var 变量名 [: 变量类型] = 初始值          var i:Int = 10

       val 常量名 [: 常量类型] = 初始值          val j:Int = 20

注意：能用常量的地方不用变量

2）案例实操

（1）声明变量时，类型可以省略，编译器自动推导，即类型推导

（2）类型确定后，就不能修改，说明Scala是强数据类型语言。

（3）变量声明时，必须要有初始值

（4）在声明/定义一个变量时，可以使用var或者val来修饰，var修饰的变量可改变，val修饰的变量不可改。

package com.aaaa.chapter02
object TestVar {
    def main(args: Array[String]): Unit = {
        //（1）声明变量时，类型可以省略，编译器自动推导，即类型推导
        var age = 18
        age = 30
        //（2）类型确定后，就不能修改，说明Scala是强数据类型语言。
//        age = "tom" // 错误
        //（3）变量声明时，必须要有初始值
//        var name //错误

//（4）在声明/定义一个变量时，可以使用var或者val来修饰，var修饰的变量可改变，val修饰的变量不可改。
        var num1 = 10   // 可变
        val num2 = 20   // 不可变
        num1 = 30  // 正确
        //num2 = 100  //错误，因为num2是val修饰的
    }
}

（5）var修饰的对象引用可以改变，val修饰的对象则不可改变，但对象的状态（值）却是可以改变的。（比如：自定义对象、数组、集合等等）

object TestVar {
    def main(args: Array[String]): Unit = {
       // p1是var修饰的，p1的属性可以变，而且p1本身也可以变

        var p1 = new Person()
        p1.name = "dalang"
        p1 = null

        // p2是val修饰的，那么p2本身就不可变（即p2的内存地址不能变），但是，p2的属性是可以变，因为属性并没有用val修饰。
        val p2 = new Person()
        p2.name="jinlian"
        // p2 = null // 错误的，因为p2是val修饰的
    }
}

class Person{
    var name : String = "jinlian"
}

2.3 标识符的命名规范

Scala对各种变量、方法、函数等命名时使用的字符序列称为标识符。即：凡是自己可以起名字的地方都叫标识符。

1）命名规则

Scala中的标识符声明，基本和Java是一致的，但是细节上会有所变化，有以下三种规则：

（1）以字母或者下划线开头，后接字母、数字、下划线

（2）以操作符开头，且只包含操作符（+ - * / # !等）

（3）用反引号`....`包括的任意字符串，即使是Scala关键字（39个）也可以

• package, import, class, object, trait, extends, with, type, for
• private, protected, abstract, sealed, final, implicit, lazy, override
• try, catch, finally, throw
• if, else, match, case, do, while, for, return, yield
• def, val, var
• this, super
• new
• true, false, null

2）案例实操

       需求：判断hello、Hello12、1hello、h-b、x h、h_4、_ab、Int、_、+*-/#!、+*-/#!1、if、`if`，这些名字是否合法。

object TestName {

    def main(args: Array[String]): Unit = {
        // （1）以字母或者下划线开头，后接字母、数字、下划线

        var hello: String = "" // ok
        var Hello12: String = "" // ok
        var 1hello: String = "" // error 数字不能开头

        var h-b: String = "" // error   不能用-
        var x h: String = "" // error   不能有空格
        var h_4: String = "" // ok
        var _ab: String = "" // ok
        var Int: String = "" // ok 因为在Scala中Int是预定义的字符,不是关键字，但不推荐

        var _: String = "hello" // error 单独一个下划线不可以作为标识符，因为_被认为是一个方法
        println(_)

        //（2）以操作符开头，且只包含操作符（+ - * / # !等）

        var +*-/#! : String = "" // ok
        var +*-/#!1 : String = "" // error 以操作符开头，必须都是操作符

        //（3）用反引号`....`包括的任意字符串，即使是Scala关键字（39个）也可以

        var if : String = "" // error 不能用关键字
        var `if` : String = "" // ok 用反引号`....`包括的任意字符串,包括关键字

    }

}

2.4 字符串输出

1）基本语法

（1）字符串，通过+号连接

（2）printf用法：字符串，通过%传值。

（3）字符串模板（插值字符串）：通过$获取变量值

2）案例实操

package com.aaaa.chapter02
object TestCharType {
    def main(args: Array[String]): Unit = {

        var name: String = "jinlian"
        var age: Int = 18

        //（1）字符串，通过+号连接
        println(name + " " + age)

        //（2）printf用法字符串，通过%传值。
       printf("name=%s age=%d\n", name, age)

        //（3）字符串，通过$引用
        //多行字符串，在Scala中，利用三个双引号包围多行字符串就可以实现。
        //输入的内容，带有空格、\t之类，导致每一行的开始位置不能整洁对齐。
        //应用scala的stripMargin方法，在scala中stripMargin默认是“|”作为连接符，
        //在多行换行的行头前面加一个“|”符号即可。

        val s =
            """
              |select
              |    name,
              |    age
              |from user
              |where name="zhangsan"
            """.stripMargin
        println(s)


        //如果需要对变量进行运算，那么可以加${}
        val s1 =
            s"""
              |select
              |    name,
              |    age
              |from user
              |where name="$name" and age=${age+2}
            """.stripMargin
        println(s1)

       val s2 = s"name=$name"
        println(s2)
    }
}

2.5 键盘输入

在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。

1）基本语法

StdIn.readLine()、StdIn.readShort()、StdIn.readDouble()

2）案例实操

需求：可以从控制台接收用户信息，【姓名，年龄，薪水】。

import scala.io.StdIn
object TestInput {
    def main(args: Array[String]): Unit = {

        // 1 输入姓名
        println("input name:")
        var name = StdIn.readLine()

        // 2 输入年龄
        println("input age:")
        var age = StdIn.readShort()

        // 3 输入薪水
        println("input sal:")
        var sal = StdIn.readDouble()

        // 4 打印
        println("name=" + name)
        println("age=" + age)
        println("sal=" + sal)
    }
}

2.6 数据类型（重点）

2.7 整数类型（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）案例实操

（1）Scala各整数类型有固定的表示范围和字段长度，不受具体操作的影响，以保证Scala程序的可移植性。

object TestDataType {
    def main(args: Array[String]): Unit = {

        // 正确
        var n1:Byte = 127
        var n2:Byte = -128

        // 错误
        // var n3:Byte = 128
        // var n4:Byte = -129
    }
}

（2）Scala的整型，默认为Int型，声明Long型，须后加‘l’或‘L’

object TestDataType {
    def main(args: Array[String]): Unit = {

        var n5 = 10
        println(n5)
        var n6 = 9223372036854775807L
        println(n6)
    }
}

（3）Scala程序中变量常声明为Int型，除非不足以表示大数，才使用Long

2.8 浮点类型（Float、Double）

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

1）浮点型分类

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

2）案例实操

Scala的浮点型常量默认为Double型，声明Float型常量，须后加‘f’或‘F’。

object TestDataType {
    def main(args: Array[String]): Unit = {

        // 建议，在开发中需要高精度小数时，请选择Double
        var n7 = 2.2345678912f
        var n8 = 2.2345678912

        println("n7=" + n7)
        println("n8=" + n8)
    }
}
//运行的结果
n7=2.2345679
n8=2.2345678912

2.9 字符类型（Char）

1）基本说明

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

2）案例实操

（1）字符常量是用单引号 ' ' 括起来的单个字符。

（2）\t ：一个制表位，实现对齐的功能

（3）\n ：换行符

（4）\\ ：表示\

（5）\" ：表示"

object TestCharType {
    def main(args: Array[String]): Unit = {

        //（1）字符常量是用单引号 ' ' 括起来的单个字符。
        var c1: Char = 'a'
        println("c1=" + c1)

      //注意：这里涉及自动类型提升，其实编译器可以自定判断是否超出范围，
       //不过idea提示报错
      var c2:Char = 'a' + 1
      println(c2)
       
        //（2）\t ：一个制表位，实现对齐的功能

        println("姓名\t年龄")

        //（3）\n ：换行符
        println("西门庆\n潘金莲")

        //（4）\\ ：表示\
        println("c:\\岛国\\avi")

        //（5）\" ：表示"
        println("同学们都说：\"大哥最帅\"")
    }
}

2.10 布尔类型：Boolean

1）基本说明

（1）布尔类型也叫Boolean类型，Booolean类型数据只允许取值true和false

（2）boolean类型占1个字节。

2）案例实操

object TestBooleanType {
    def main(args: Array[String]): Unit = {       

        var isResult : Boolean = false
        var isResult2 : Boolean = true
    }
}

2.11 Unit类型、Null类型和Nothing类型（重点）

1）基本说明

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

2）案例实操

（1）Unit类型用来标识过程，也就是没有明确返回值的函数。

由此可见，Unit类似于Java里的void。Unit只有一个实例——( )，这个实例也没有实质意义

object TestSpecialType {
    def main(args: Array[String]): Unit = {
        def sayOk : Unit = {// unit表示没有返回值，即void         
        }
        println(sayOk)
    }
}

（2）Null类只有一个实例对象，Null类似于Java中的null引用。Null可以赋值给任意引用类型（AnyRef），但是不能赋值给值类型（AnyVal）

object TestDataType {
    def main(args: Array[String]): Unit = {
        //null可以赋值给任意引用类型（AnyRef），但是不能赋值给值类型（AnyVal）
        var cat = new Cat();
        cat = null   // 正确
        var n1: Int = null // 错误
        println("n1:" + n1)
    }
}
class Cat {
}

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

object TestSpecialType {
    def main(args: Array[String]): Unit = {
        def test() : Nothing={
            throw new Exception()
        }
        test
    }
}

2.12 类型转换

扩展Java面试题（隐式类型转换）：

 结果为：bbbb

2.12.1 数值类型自动转换

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

1）基本说明

（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算。

（2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。

（3）（byte，short）和char之间不会相互自动转换。

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

2）案例实操

object TestValueTransfer {
    def main(args: Array[String]): Unit = {

        //（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数值类型，然后再进行计算。

        var n = 1 + 2.0
        println(n)  // n 就是Double

        //（2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。

        var n2 : Double= 1.0
        //var n3 : Int = n2 //错误，原因不能把高精度的数据直接赋值和低精度。

        //（3）（byte，short）和char之间不会相互自动转换。
        var n4 : Byte = 1
        //var c1 : Char = n4  //错误
        var n5:Int = n4

        //（4）byte，short，char他们三者可以计算，在计算时首先转换为int类型。
        var n6 : Byte = 1
        var c2 : Char = 1
        // var n : Short = n6 + c2 //当n6 + c2 结果类型就是int
       // var n7 : Short = 10 + 90 //错误
    }
}

注意：Scala还提供了非常强大的隐式转换机制（隐式函数，隐式类等），我们放在高级部分专门用一个章节来讲解。

2.12.2 强制类型转换

1）基本说明

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

Java  :  int num = (int)2.5
Scala :  var num : Int = 2.7.toInt

2）案例实操

（1）将数据由高精度转换为低精度，就需要使用到强制转换

（2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级

object TestForceTransfer {
    def main(args: Array[String]): Unit = {
        //（1）将数据由高精度转换为低精度，就需要使用到强制转换
        var n1: Int = 2.5.toInt // 这个存在精度损失       

        //（2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
        var r1: Int = 10 * 3.5.toInt + 6 * 1.5.toInt  // 10 *3 + 6*1 = 36
        var r2: Int = (10 * 3.5 + 6 * 1.5).toInt  // 44.0.toInt = 44
        println("r1=" + r1 + " r2=" + r2)
    }
}

2.12.3 数值类型和String类型间转换

1）基本说明

在程序开发中，我们经常需要将基本数值类型转成String类型。或者将String类型转成基本数值类型。

2）案例实操

（1）基本类型转String类型（语法：将基本类型的值+"" 即可）

（2）String类型转基本数值类型（语法：s1.toInt、s1.toFloat、s1.toDouble、s1.toByte、s1.toLong、s1.toShort）

object TestStringTransfer {
    def main(args: Array[String]): Unit = {

        //（1）基本类型转String类型（语法：将基本类型的值+"" 即可）
        var str1 : String = true + ""
        var str2 : String = 4.5 + ""
        var str3 : String = 100 +""

        //（2）String类型转基本数值类型（语法：调用相关API）

        var s1 : String = "12"
        var n1 : Byte = s1.toByte
        var n2 : Short = s1.toShort
        var n3 : Int = s1.toInt
        var n4 : Long = s1.toLong
    }
}

（3）注意事项

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

var n5:Int = "12.6".toInt会出现NumberFormatException异常。

扩展面试题

结果：

三、 运算符

Scala运算符的使用和Java运算符的使用基本相同，只有个别细节上不同。

3.1 算术运算符

1）基本语法

运算符	运算	范例	结果
+	正号	+3	3
-	负号	b=4; -b	-4
+	加	5+5	10
-	减	6-4	2
*	乘	3*4	12
/	除	5/5	1
%	取模(取余)	7%5	2
+	字符串相加	“He”+”llo”	“Hello”

（1）对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。

（2）对一个数取模a%b，和Java的取模规则一样。

2）案例实操

object TestArithmetic {
    def main(args: Array[String]): Unit = {

        //（1）对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
        var r1: Int = 10 / 3 // 3
        println("r1=" + r1)
        var r2: Double = 10 / 3 // 3.0
        println("r2=" + r2)

        var r3: Double = 10.0 / 3 // 3.3333
        println("r3=" + r3)
        println("r3=" + r3.formatted("%.2f")) // 含义：保留小数点2位，使用四舍五入

        //（2）对一个数取模a%b，和Java的取模规则一样。
        var r4 = 10 % 3 // 1
        println("r4=" + r4)
    }
}

3.2 关系运算符（比较运算符）

1）基本语法

运算符	运算	范例	结果
==	相等于	4==3	false
!=	不等于	4！=3	true
<	小于	4<3	false
>	大于	4>3	true
<=	小于等于	4<=3	false
>=	大于等于	4>=3	true

2）案例实操

       （1）需求1：

object TestRelation {
    def main(args: Array[String]): Unit = {
        // 测试：>、>=、<=、<、==、!=
        var a: Int = 2
        var b: Int = 1

        println(a > b)      // true
        println(a >= b)     // true
        println(a <= b)     // false
        println(a < b)      // false
        println("a==b" + (a == b))    // false
        println(a != b)     // true
    }
}

（2）需求2：Java和Scala中关于==的区别

Java：

==比较两个变量本身的值，即两个对象在内存中的首地址；

       equals比较字符串中所包含的内容是否相同。

public static void main(String[] args) {
   
    String s1 = "abc";
    String s2 = new String("abc");
    System.out.println(s1 == s2);
    System.out.println(s1.equals(s2));
}

输出结果：

false
true

Scala：==更加类似于Java中的equals，参照jd工具

def main(args: Array[String]): Unit = {
    val s1 = "abc"
    val s2 = new String("abc")
    println(s1 == s2)
println(s1.eq(s2))
}

输出结果：

true
false

3.3 逻辑运算符

1）基本语法

用于连接多个条件（一般来讲就是关系表达式），最终的结果也是一个Boolean值。

假定：变量A为true，B为false

运算符	描述	实例
&&	逻辑与	(A && B) 运算结果为 false
||	逻辑或	(A || B) 运算结果为 true
!	逻辑非	!(A && B) 运算结果为 true

2）案例实操

object TestLogic {
    def main(args: Array[String]): Unit = {

        // 测试：&&、||、!
        var a = true
        var b = false

        println("a&&b=" + (a && b))     // a&&b=false
        println("a||b=" + (a || b))     // a||b=true
        println("!(a&&b)=" + (!(a && b))) // !(a&&b)=true
    }
}

扩展避免逻辑与空指针异常

isNotEmpty(String s){

   //如果按位与，s为空，会发生空指针

   return s!=null && !"".equals(s.trim());

}

3.4 赋值运算符

1）基本语法

赋值运算符就是将某个运算后的值，赋给指定的变量。

运算符	描述	实例
=	简单的赋值运算符，将一个表达式的值赋给一个左值	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
<<=	左移后赋值	C <<= 2等于 C = C << 2
>>=	右移后赋值	C >>= 2 等于 C = C >> 2
&=	按位与后赋值	C &= 2  等于 C = C & 2
^=	按位异或后赋值	C ^= 2  等于 C = C ^ 2
|=	按位或后赋值	C |= 2  等于 C = C | 2

注意：Scala中没有++、--操作符，可以通过+=、-=来实现同样的效果；

2）案例实操

object TestAssignment {
      def main(args: Array[String]): Unit = {
         var r1 = 10

        r1 += 1 // 没有++
        r1 -= 2 // 没有--
    }
}

3.5 位运算符

1）基本语法

       下表中变量 a 为 60，b 为 13。

运算符	描述	实例
&	按位与运算符	(a & b) 输出结果 12 ，二进制解释： 0000 1100
|	按位或运算符	(a | b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符	(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<<	左移动运算符	a << 2 输出结果 240 ，二进制解释： 0011 0000
>>	右移动运算符	a >> 2 输出结果 15 ，二进制解释： 0000 1111
>>>	无符号右移	a >>>2 输出结果 15, 二进制解释: 0000 1111

2）案例实操

object TestPosition {

    def main(args: Array[String]): Unit = {

        // 测试：1000 << 1 =>10000
        var n1 :Int =8
        n1 = n1 << 1
        println(n1)
    }
}

3.6 Scala运算符本质

在Scala中其实是没有运算符的，所有运算符都是方法。

1）当调用对象的方法时，点.可以省略

2）如果函数参数只有一个，或者没有参数，()可以省略

object TestOpt {
    def main(args: Array[String]): Unit = {
        // 标准的加法运算
        val i:Int = 1.+(1)

       // （1）当调用对象的方法时，.可以省略
        val j:Int = 1 + (1)

        // （2）如果函数参数只有一个，或者没有参数，()可以省略
        val k:Int = 1 + 1
       
        println(1.toString())
        println(1 toString())
        println(1 toString)
    }
}