尚硅谷 SpringCloud md笔记

转载

jack 2024-10-29 09:40:42

文章标签 scala 学习 spark Scala 字符串 文章分类 架构后端开发

第一课 Scala语言学习-变量和数据类型

文章目录

第一课 Scala语言学习-变量和数据类型

第一节 Scala背景介绍

1.1 Scala介绍
1.2 Scala和 Java以及jvm的关系
1.3 Scala 语言的特点
1.4 Scala 环境搭建

第二节 Scala开发工具

2.1 idea中Scala 插件安装
2.2 Scala程序的执行流程
2.3 Scala 程序开发注意事项(重点)
2.4 Scala语言输出的三种方式
2.5. Scala 源码的查看的关联

第三节变量和数据类型

3.1 变量和常量
3.2 字符串输出和键盘输入
3.3 数据类型
3.4 常用类型
3.4 类型转换

第四节运算符

第一节 Scala背景介绍

1.1 Scala介绍

Spark—新一代内存级大数据计算框架，是大数据的重要内容。Spark就是使用Scala编写的。因此为了更好的学习Spark, 需要掌握Scala这门语言。
Scala 是 Scalable Language 的简写，是一门多范式(范式/编程方式[面向对象/函数式编程])的编程语言
联邦理工学院洛桑（EPFL）的Martin Odersky于2001年开始设计Scala。
Spark的兴起，带动Scala语言的发展！
创始人马丁·奥德斯基（Martin Odersky）是编译器及编程的狂热爱好者，长时间的编程之后，希望发明一语言，能够让写程序这样的基础工作变得高效，简单。所以当接触到JAVA语言后，对JAVA这门便携式，运行在网络，且存在垃圾回收的语言产生了极大的兴趣，所以决定将函数式编程语言的特点融合到JAVA中，由此发明了两种语言（Pizza & Scala）。

jdk5.0 的泛型，for循环增强, 自动类型转换等，都是从Pizza 引入的新特性。
jdk8.0 的类型推断，Lambda表达式就是从scala引入的特性。
且现在主流JVM的javac编译器就是马丁·奥德斯基编写出来的。Jdk5.0 Jdk8.0的编译器就是马丁·奥德斯基写的，因此马丁·奥德斯基一个人的战斗力抵得上一个Java开发团队。

1.2 Scala和 Java以及jvm的关系

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

// 1. 能够继续使用java的语法(部分)
System.out.Println("hello") [ok]
HashMap<String,String> hm = new HashMap() [不ok]

//2. sacla特有语法(举例)
val  tuple = (1, 20, "hello", 23.9) //元组
val  map = Map(("no",10)， ("no2", 40)) //  map

//3. 增加功能,比如 函数式编程
//（1） 偏函数
// (2) 函数的柯里化
// (3) 高阶函数。。。
// (4) 将函数作为参数传递

//4. 从形式上看，是scala 的类，但是这个类是对java的类/接口进行包装,比如
var  arr  = new Array[Int](10) 
// 表示我定义了一个数组，该数组存放Int,  10个元素

1.3 Scala 语言的特点

Scala 是一门以 java 虚拟机（JVM）为运行环境并将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言。
Scala 是一门多范式 (multi-paradigm) 的编程语言，Scala 支持面向对象和函数式编程。
Scala 源代码(.scala)会被编译成 Java 字节码(.class)，然后运行于 JVM 之上，并可以调用现有的Java 类库，实现两种语言的无缝对接。
scala 单作为一门语言来看，非常的简洁高效（三元运算， ++ ， --）
Scala 在设计时，马丁·奥德斯基是参考了 Java 的设计思想，可以说 Scala 是源于 java，同时马丁·奥德斯基也加入了自己的思想，将函数式编程语言的特点融合到 JAVA 中, 因此，对于学习过Java 的同学，只要在学习 Scala 的过程中，搞清楚 Scala 和 java 相同点和不同点，就可以快速的掌握Scala 这门语言。、
快速有效掌握 Scala 的三点建议

学习 scala 法的特有的语法。
区别 scala 和 Java 。
如何规范使用 scala。

1.4 Scala 环境搭建

Windows下搭建Scala开发环境。首先把 jdk1.8 安装, 下载对应的 scala 安装文件

# 配置 scala 的环境变量
SCALA_HOME D:\Tools\scala-2.12.11
# 测试一下, 输入 scala 的指令看看效果：
scala

Linux下搭建Scala开发环境。在实际开发中，我们的项目是部署到 linux,因此，我们需要在 Linux 下搭建 scala 的环境。具体的步骤如下：

下载对应的 scala 的安装软件scala-2.11.8.tgz
通过远程登录工具，将安装软件上传到对应的Linux 系统/opt/software目录下

# 将安装文件解压，并且移动到 /opt/module下
tar -zxvf scala-2.11.8.tgz -C  /opt/module
# 配置环境变量 `vim /etc/profile`
export SCALA_HOME=/opt/module/scala-2.11.8
export PATH=$PATH:$SCALA_HOME/bin

source /etc/profile

# 测试一下, 输入 scala 的指令看看效果：
scala

上面打开的 scala 命令行窗口，我们称之为 REPL，是指：Read->Evaluation->Print->Loop，也称之为交互式解释器。
在命令行窗口中输入 scala 指令代码时，解释器会读取指令代码®并计算对应的值(E)，然后将结果打印出来§，接着循环等待用户输入指令(L)。从技术上讲，这里其实并不是一个解释器，而是指令代码被快速的编译成 Java 字节码并被 JVM 加载执行。最终将执行结果输出到命令行中。

第二节 Scala开发工具

2.1 idea中Scala 插件安装

同Java开发一样先创建一个Maven工程。IDEA中引入全局类库。

尚硅谷 SpringCloud md笔记_spark

默认下IDEA不支持 scala 的开发,先安装Scala插件，然后引入 scala 框架：右键项目点击-> add framework support在下图选择 scala。

尚硅谷 SpringCloud md笔记_Scala_02

创建项目的源文件目录：右键 main 目录->创建一个 diretory -> 写个名字（比如 scala）-> 右键 scala 目录->mark directory -> 选择 source root 即可。

package chapter01

/*
   object: 关键字，声明一个单例对象（伴生对象）
 */
object HelloWorld {
  /*
    main 方法：从外部可以直接调用执行的方法
    def 方法名称(参数名称: 参数类型): 返回值类型 = { 方法体 }
   */
  def main(args: Array[String]): Unit = {
    println("hello world")
    System.out.println("hello scala from java")
  }
}

2.2 Scala程序的执行流程

package chapter01

class Student(name: String, var age: Int) {
  def printInfo(): Unit = {
    println(name + " " + age + " " + Student.school)
  }
}

// 引入伴生对象
object Student{
  val school: String = "atguigu"

  def main(args: Array[String]): Unit = {
    val alice = new Student("alice", 20)
    val bob = new Student("bob", 23)

    alice.printInfo()
    bob.printInfo()
  }
}

使用反编译工具jd-gui.exe,对编译后的文件反编译为java代码。实际上scala 程序的执行流程如下：

object 在底层会生成两个类 Student , Student$
StudentScala 中有个 main 函数，调用 Hello$ 类的一个静态对象 MODULES$

反编译后的Student.class，伴生类都在这里。

package chapter01;

import scala.Predef.;
import scala.reflect.ScalaSignature;

@ScalaSignature(bytes="\006\001\0353A!\004\b\001#!A\001\004\001B\001B\003%\021\004\003\005%\001\t\005\r\021\"\001&\021!I\003A!a\001\n\003Q\003\002\003\031\001\005\003\005\013\025\002\024\t\013E\002A\021\001\032\t\013]\002A\021\001\035\b\013er\001\022\001\036\007\0135q\001\022A\036\t\013EBA\021\001\037\t\017uB!\031!C\001}!1q\b\003Q\001\neAQ\001\021\005\005\002\005\023qa\025;vI\026tGOC\001\020\003%\031\007.\0319uKJ\004\024g\001\001\024\005\001\021\002CA\n\027\033\005!\"\"A\013\002\013M\034\027\r\\1\n\005]!\"AB!osJ+g-\001\003oC6,\007C\001\016\"\035\tYr\004\005\002\035)5\tQD\003\002\037!\0051AH]8pizJ!\001\t\013\002\rA\023X\rZ3g\023\t\0213E\001\004TiJLgn\032\006\003AQ\t1!Y4f+\0051\003CA\n(\023\tACCA\002J]R\fq!Y4f?\022*\027\017\006\002,]A\0211\003L\005\003[Q\021A!\0268ji\"9qfAA\001\002\0041\023a\001=%c\005!\021mZ3!\003\031a\024N\\5u}Q\0311'\016\034\021\005Q\002Q\"\001\b\t\013a)\001\031A\r\t\013\021*\001\031\001\024\002\023A\024\030N\034;J]\032|G#A\026\002\017M#X\017Z3oiB\021A\007C\n\003\021I!\022AO\001\007g\016Dwn\0347\026\003e\tqa]2i_>d\007%\001\003nC&tGCA\026C\021\025\031E\0021\001E\003\021\t'oZ:\021\007M)\025$\003\002G)\t)\021I\035:bs\002")
public class Student
{
  private final String name;
  private int age;

  public static void main(String[] paramArrayOfString)
  {
    Student..MODULE$.main(paramArrayOfString);
  }

  public static String school()
  {
    return Student..MODULE$.school();
  }

  public int age()
  {
    return this.age; } 
  public void age_$eq(int x$1) { this.age = x$1; } 
  public void printInfo() {
    Predef..MODULE$.println(2 + this.name + " " + age() + " " + Student..MODULE$.school());
  }

  public Student(String name, int age)
  {
  }
}

反编译后的Student$.class, 伴生对象都在这里。

package chapter01;

public final class Student$
{
  public static  MODULE$;
  private final String school;

  static
  {
    new ();
  }

  public String school()
  {
    return this.school;
  }
  public void main(String[] args) {
    Student alice = new Student("alice", 20);
    Student bob = new Student("bob", 23);

    alice.printInfo();
    bob.printInfo();
  }
  private Student$() { MODULE$ = this;

    this.school = "atguigu";
  }
}

2.3 Scala 程序开发注意事项(重点)

Scala 源文件以 “.scala" 为扩展名。
Scala 程序的执行入口是 main()函数。
Scala 语言严格区分大小写。
Scala 方法由一条条语句构成，每个语句后不需要分号(Scala 语言会在每行后自动加分号)，这也体现出Scala 的简洁性。
如果在同一行有多条语句，除了最后一条语句不需要分号，其它语句需要分号。

2.4 Scala语言输出的三种方式

字符串通过+号连接（类似 java）。
printf 用法（类似 C 语言）字符串通过 % 传值。
字符串通过$引用(类似 PHP）。

object TestPrint {
  def main(args: Array[String]): Unit = {
    var name : String = "mm"
    var age : Double = 18

    // 使用 +
    println("hello" + age + name )

    // 使用格式化的方式 printf
    printf("name=%s day=%f\n", name, age)

    //使用$引用的方式，输出变量，类似 php
    println(s"第三种方式 name=$name age = ${age + 1}")
  }
}

2.5. Scala 源码的查看的关联

在使用 scala 过程中，为了搞清楚 scala 底层的机制，需要查看源码，下面看看如果关联和查看 Scala的源码包。查看源码, 选择要查看的方法或者类, 输入 ctrl + b

将我们的源码包拷贝到 scala/lib 文件夹下scala-sources-2.12.11，一直解压。
关联即可,选中这个文件夹，进行关联, 最后，可以看到源码。

官方编程指南。在线查看：https://www.scala-lang.org/
离线查看：解压 scala-docs-2.11.11.zip，可以获得 Scala 的 API 操作。

第三节变量和数据类型

3.1 变量和常量

scala的注释和java完全一样。

package chapter02

import chapter01.Student

/*
   这是一个简单的测试程序
   测试注释
 */
object Test01_Comment {
  /**
   * 程序的入口方法
   * @param args 外部传入的参数
   */
  def main(args: Array[String]): Unit = {
    // 打印输出
    println("hello")
  }
}

变量基本语法, 注意能使用常量的地方就不用变量。

// var是变量 val是常量
var | val 变量名 [: 变量类型] = 变量值

声明变量时，类型可以省略（编译器自动推导，即类型推导)
类型确定后，就不能修改，说明Scala是强数据类型语言（同Java）
在声明/定义一个变量时，可以使用var或者 val来修饰， var修饰的变量可改变，val修饰的变量不可改。
val修饰的变量在编译后，等同于加上 final。
var 修饰的对象引用可以改变，val修饰的则不可改变，但对象的状态(值)却是可以改变的。(比如：自定义对象、数组、集合等等)
变量声明时，需要初始值。

package chapter02

import chapter01.Student

object Test02_Variable {
  def main(args: Array[String]): Unit = {
    // 声明一个变量的通用语法
    var a: Int = 10

    // 1. 声明变量时，类型可以省略，编译器自动推导，即类型推导
    var a1 = 10
    val b1 = 23

    // 2. 类型确定后，就不能修改，说明Scala是强数据类型语言。
    var a2 = 15    // a2类型为Int
//    a2 = "hello"

    // 3. 变量声明时，必须要有初始值
//    var a3: Int

    // 4. 在声明/定义一个变量时，可以使用var或者val来修饰，var修饰的变量可改变，val修饰的变量不可改。
    a1 = 12
//    b1 = 25

	// var 对象可以变 属性可以变
    var alice = new Student("alice", 20)
    alice = new Student("Alice", 20)
    alice = null
    // val 对象不能变 但是var属性是可以更改的
    val bob = new Student("bob", 23)
    bob.age = 24
    bob.printInfo()
//    bob = new Student("bob", 24)
  }
}

标识符的命名规范。

以字母母或者下划线开头，后接字母、数字、下划线
以操作符开头，且只包含操作符(±*/#!等)
用反引号....包括的任意字符串，即使是Scala关键字(39个)也可以

package, import, class, object, trait, extends, with, type, forSome
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

package chapter02

object Test03_Identifier {
  def main(args: Array[String]): Unit = {
    //（1）以字母或者下划线开头，后接字母、数字、下划线
    val hello: String = ""
    var Hello123 = ""
    val _abc = 123

//    val h-b = ""
//    val 123abc = 234

    //（2）以操作符开头，且只包含操作符（+ - * / # !等）
    val -+/% = "hello"
    println(-+/%)

    //（3）用反引号`....`包括的任意字符串，即使是Scala关键字（39个）也可以
    val `if` = "if"
    println(`if`)
  }
}

3.2 字符串输出和键盘输入

字符串，通过+号连接
printf用法:字符串，通过%传值。
字符串模板（插值字符串)∶通过$获取变量值

package chapter02

object Test04_String {
  def main(args: Array[String]): Unit = {
    //（1）字符串，通过+号连接
    val name: String = "alice"
    val age: Int = 18
    println(age + "岁的" + name + "在尚硅谷学习")

    // *用于将一个字符串复制多次并拼接
    println(name * 3)

    //（2）printf用法：字符串，通过%传值。
    printf("%d岁的%s在尚硅谷学习", age, name)
    println()

    //（3）字符串模板（插值字符串）：通过$获取变量值
    println(s"${age}岁的${name}在尚硅谷学习")

    val num: Double = 2.3456
    println(f"The num is ${num}%2.2f")    // 格式化模板字符串
    println(raw"The num is ${num}%2.2f")

    // 三引号表示字符串，保持多行字符串的原格式输出
    val sql = s"""
       |select *
       |from
       |  student
       |where
       |  name = ${name}
       |and
       |  age > ${age}
       |""".stripMargin
    println(sql)
  }
}

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

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

键盘输入案例。

package chapter02

import scala.io.StdIn

object Test05_StdIn {
  def main(args: Array[String]): Unit = {
    // 输入信息
    println("请输入您的大名：")
    val name: String = StdIn.readLine()
    println("请输入您的芳龄：")
    val age: Int = StdIn.readInt()

    // 控制台打印输出
    println(s"欢迎${age}岁的${name}来到尚硅谷学习")
  }
}

文件读取数据案例。

package chapter02

import java.io.{File, PrintWriter}
import scala.io.Source

object Test06_FileIO {
  def main(args: Array[String]): Unit = {
    // 1. 从文件中读取数据
    Source.fromFile("src/main/resources/test.txt").foreach(print)

    // 2. 将数据写入文件
    val writer = new PrintWriter(new File("src/main/resources/output.txt"))
    writer.write("hello scala from java writer")
    writer.close()
  }
}

3.3 数据类型

java中数据类型回顾。

Java基本类型:char、 byte、short、int、long、float、double、boolean。
Java引用类型:（对象类型)由于Java有基本类型，而且基本类型不是真正意义的对象，即使后面产生了基本类型的包装类，但是仍然存在基本数据类型，所以Java语言并不是真正意思的面向对象。
Java基本类型的包装类:Character、Byte、Short、Integer、Long、Float、Double、Boolean·注意: Java中基本类型和引用类型没有共同的祖先。

Scala中数据类型

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

3.4 常用类型

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

尚硅谷 SpringCloud md笔记_学习_03

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

尚硅谷 SpringCloud md笔记_学习_04

字符类型可以表示单个字符，字符类型是 Char。
布尔类型也叫 Boolean 类型，Booolean 类型数据只允许取值 true 和 false, boolean 类型占 1 个字节
Unit类型、Null类型和Nothing 类型

Unit 类型用来标识过程，也就是没有明确返回值的函数。由此可见，Unit 类似于 Java 里的 void。Unit 只有一个实例()，这个实例也没有实质意义
Null类只有一个实例对象，Null类似于Java 中的null引用。Null可以赋值给任意引用类型(AnyRef )，但是不能赋值给值类型(AnyVal)
Nothing，可以作为没有正常返回值的方法的返回类型，非常直观的告诉你这个方法不会正常返回，而且由于Nothing 是其他任意类型的子类，他还能跟要求返回值的方法兼容。

package chapter02

import chapter01.Student

object Test07_DataType {
  def main(args: Array[String]): Unit = {
    // 1. 整数类型
    val a1: Byte = 127
    val a2: Byte = -128

//    val a2: Byte = 128    // error

    val a3 = 12    // 整数默认类型为Int
    val a4: Long = 1324135436436L    // 长整型数值定义

    val b1: Byte = 10
    val b2: Byte = 10 + 20
    println(b2)

//    val b3: Byte = b1 + 20
    val b3: Byte = (b1 + 20).toByte
    println(b3)

    // 2. 浮点类型
    val f1: Float = 1.2345f
    val d1 = 34.2245

    // 3. 字符类型
    val c1: Char = 'a'
    println(c1)

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

    // 控制字符
    val c3: Char = '\t'    // 制表符
    val c4: Char = '\n'    // 换行符
    println("abc" + c3 + "def")
    println("abc" + c4 + "def")

    // 转义字符
    val c5 = '\\'    // 表示\自身
    val c6 = '\"'    // 表示"
    println("abc" + c5 + "def")
    println("abc" + c6 + "def")

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

    val c7: Char = (i1 + 1).toChar
    println(c7)
    val c8: Char = (i2 - 1).toChar
    println(c8)

    // 4. 布尔类型
    val isTrue: Boolean = true
    println(isTrue)

    // 5. 空类型
    // 5.1 空值Unit
    def m1(): Unit = {
      println("m1被调用执行")
    }

    val a: Unit = m1()
    println("a: " + a)

    // 5.2 空引用Null
//    val n: Int = null    // error
    var student: Student = new Student("alice", 20)
    student = null
    println(student)

    // 5.3 Nothing
    def m2(n: Int): Int = {
      if (n == 0)
        throw new NullPointerException
      else
        return n
    }

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

3.4 类型转换

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

自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算。
把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
（byte，short）和 char 之间不会相互自动转换。
byte，short，char 他们三者可以计算，在计算时首先转换为 int 类型。

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

将数据由高精度转换为低精度，就需要使用到强制转换
强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级

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

基本类型转 String 类型（语法：将基本类型的值+“” 即可）
String 类型转基本数值类型（语法：s1.toInt、s1.toFloat、s1.toDouble、s1.toByte、s1.toLong、s1.toShort）

package chapter02

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

    // 1. 自动类型转换
    //    （1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算。
    val a1: Byte = 10
    val b1: Long = 2353
    val result1: Long = a1 + b1
    val result11: Int = (a1 + b1.toInt) // 强转

    //    （2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
    val a2: Byte = 10
    val b2: Int = a2
    //    val c2: Byte = b2    // error

    //    （3）（byte，short）和char之间不会相互自动转换。
    val a3: Byte = 10
    val b3: Char = 'b'
    //    val c3: Byte = b3    // error
    val c3: Int = b3
    println(c3)

    //    （4）byte，short，char他们三者可以计算，在计算时首先转换为int类型。
    val a4: Byte = 12
    val b4: Short = 25
    val c4: Char = 'c'
    val result4: Int = a4 + b4
    val result44: Int = a4 + b4 + c4
    println(result44)

    // 2. 强制类型转换
    //    （1）将数据由高精度转换为低精度，就需要使用到强制转换
    val n1: Int = -2.9.toInt
    println("n1: " + n1)

    //    （2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
    val n2: Int = 2.6.toInt + 3.7.toInt
    val n3: Int = (2.6 + 3.7).toInt
    println("n2: " + n2)
    println("n3: " + n3)

    // 3. 数值类型和String类型的转换
    // (1) 数值转String
    val n: Int = 27
    val s: String = n + ""
    println(s)

    // (2) String转数值
    val m: Int = "12".toInt
    val f: Float = "12.3".toFloat
    val f2: Int = "12.3".toDouble.toInt
    println(f2)
  }
}

第四节运算符

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

对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
对一个数取模 a%b，和 Java 的取模规则一样。

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

==比较两个变量本身的值，即两个对象在内存中的首地址；
equals 比较字符串中所包含的内容是否相同。

逻辑运算符
赋值运算符

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

位运算符

package chapter03

import com.sun.javafx.scene.control.behavior.DatePickerBehavior

object Test01_TestOperator {
  def main(args: Array[String]): Unit = {
    // 1. 算术运算符
    val result1: Int = 10 / 3
    println(result1)

    val result2: Double = 10 / 3
    println(result2)

    val result3: Double = 10.0 / 3
    println(result3.formatted("%5.2f"))

    val result4: Int = 10 % 3
    println(result4)

    // 2. 比较运算符
    val s1: String = "hello"
    val s2: String = new String("hello")

    println(s1 == s2)
    println(s1.equals(s2))
    println(s1.eq(s2))

    println("===================")

    // 3. 逻辑运算符
    def m(n: Int): Int = {
      println("m被调用")
      return n
    }

    val n = 1
    println((4 > 5) && m(n) > 0)

    // 判断一个字符串是否为空
    def isNotEmpty(str: String): Boolean = {
      return str != null && !("".equals(str.trim))
    }

    println(isNotEmpty(null))

    // 4. 赋值运算符
    //    var b: Byte = 10
    var i: Int = 12
    //    b += 1
    i += 1
    println(i)

    //    i ++

    // 5. 位运算符
    val a: Byte = 60
    println(a << 3)
    println(a >> 2)

    val b: Short = -13
    println(b << 2)
    println(b >> 2)
    println(b >>> 2)

    // 6. 运算符的本质
    val n1: Int = 12
    val n2: Int = 37

    println(n1.+(n2))
    println(n1 + n2 )

    println(1.34.*(25))
    println(1.34 * 25)

//    println(7.5 toInt toString)
  }
}