视频地址：尚硅谷大数据技术之Scala入门到精通教程（小白快速上手scala）_哔哩哔哩_bilibili

1. 尚硅谷大数据技术Scala教程-笔记01【Scala课程简介、Scala入门、变量和数据类型、运算符、流程控制】
2. 尚硅谷大数据技术Scala教程-笔记02【函数式编程】
3. 尚硅谷大数据技术Scala教程-笔记03【面向对象】
4. 尚硅谷大数据技术Scala教程-笔记04【集合】
5. 尚硅谷大数据技术Scala教程-笔记05【模式匹配、异常】

目录

第00章-Scala课程简介

P001【001_尚硅谷_Scala_课程简介】09:32

第01章-Scala入门

P002【002_尚硅谷_Scala_Scala概述（一）_Scala发展历史】09:25

P003【003_尚硅谷_Scala_Scala概述（二）_Scala和Java的关系】06:57

P004【004_尚硅谷_Scala_Scala概述（三）_Scala特点总结】05:40

P005【005_尚硅谷_Scala_Scala环境搭建（一）_Scala安装和交互式命令行测试】09:44

P006【006_尚硅谷_Scala_Scala环境搭建（二）_Scala源文件编写和运行】10:21

P007【007_尚硅谷_Scala_Scala环境搭建（三）_Scala编译结果的反编译深入分析】15:46

P008【008_尚硅谷_Scala_在IDE中编写HelloWorld（一）_项目创建和环境配置】06:50

P009【009_尚硅谷_Scala_在IDE中编写HelloWorld（二）_编写代码】04:33

P010【010_尚硅谷_Scala_在IDE中编写HelloWorld（三）_代码中语法的简单说明】05:24

P011【011_尚硅谷_Scala_在IDE中编写HelloWorld（四）_伴生对象的扩展说明】22:58

P012【012_尚硅谷_Scala_在IDE中编写HelloWorld（五）_关联源码和查看官方指南】02:41

第02章-变量和数据类型

P013【013_尚硅谷_Scala_变量和数据类型（一）_注释和基本编程习惯】06:56

P014【014_尚硅谷_Scala_变量和数据类型（二）_变量和常量】16:48

P015【015_尚硅谷_Scala_变量和数据类型（三）_标识符】10:05

P016【016_尚硅谷_Scala_变量和数据类型（四）_字符串】21:04

P017【017_尚硅谷_Scala_变量和数据类型（五）_控制台标准输入】03:52

P018【018_尚硅谷_Scala_变量和数据类型（六）_读写文件】07:03

P019【019_尚硅谷_Scala_变量和数据类型（七）_数据类型系统】13:44

P020【020_尚硅谷_Scala_变量和数据类型（八）_整型和浮点类型】18:43

P021【021_尚硅谷_Scala_变量和数据类型（九）_字符和布尔类型】10:19

P022【022_尚硅谷_Scala_变量和数据类型（十）_空类型】14:33

P023【023_尚硅谷_Scala_变量和数据类型（十一）_Unit类型的源码实现】04:52

P024【024_尚硅谷_Scala_变量和数据类型（十二）_类型转换（一）_Java类型转换复习】07:21

P025【025_尚硅谷_Scala_变量和数据类型（十二）_类型转换（三）_Scala自动类型转换】13:07

P026【026_尚硅谷_Scala_变量和数据类型（十二）_类型转换（四）_Scala强制类型转换】12:03

P027【027_尚硅谷_Scala_变量和数据类型（十二）_类型转换（五）_强转溢出面试题】09:22

第03章-运算符

P028【028_尚硅谷_Scala_运算符（一）_算术运算符】09:04

P029【029_尚硅谷_Scala_运算符（二）_比较运算符】09:25

P030【030_尚硅谷_Scala_运算符（三）_逻辑运算符】14:36

P031【031_尚硅谷_Scala_运算符（四）_赋值运算符】15:13

P032【032_尚硅谷_Scala_运算符（五）_位运算符】18:03

P033【033_尚硅谷_Scala_运算符（六）_运算符的本质】09:03

第04章-流程控制

P034【034_尚硅谷_Scala_流程控制（一）_条件分支（一）_If-Else常规用法】12:06

P035【035_尚硅谷_Scala_流程控制（一）_条件分支（二）_If-Else的返回值】13:48

P036【036_尚硅谷_Scala_流程控制（一）_条件分支（三）_嵌套分支】04:45

P037【037_尚硅谷_Scala_流程控制（二）_For循环（一）_范围遍历】12:27

P038【038_尚硅谷_Scala_流程控制（二）_For循环（二）_不包含边界的范围遍历】07:38

P039【039_尚硅谷_Scala_流程控制（二）_For循环（三）_集合遍历】03:17

P040【040_尚硅谷_Scala_流程控制（二）_For循环（四）_循环守卫】04:41

P041【041_尚硅谷_Scala_流程控制（二）_For循环（五）_循环步长】14:10

P042【042_尚硅谷_Scala_流程控制（二）_For循环（六）_循环嵌套】10:34

P043【043_尚硅谷_Scala_流程控制（二）_For循环（七）_循环引入变量】04:57

P044【044_尚硅谷_Scala_流程控制（二）_For循环（八）_练习_输出九层妖塔】11:03

P045【045_尚硅谷_Scala_流程控制（二）_For循环（九）_for循环返回值】10:20

P046【046_尚硅谷_Scala_流程控制（三）_While循环】06:06

P047【047_尚硅谷_Scala_流程控制（四）_循环中断】12:04

---

第00章-Scala课程简介

P001【001_尚硅谷_Scala_课程简介】09:32

scala与java类似，基于jvm的静态类型高级编程语言。spark底层是用scala编写的。

为什么要学习Scala？

1. Scala——Java++
   1. Scala基于JVM，和Java完全兼容，同样具有跨平台、可移植性好、方便的垃圾回收等特性
   2. Scala比Java更加面向对象
   3. Scala是一门函数式编程语言
2. Scala更适合大数据的处理
   1. Scala对集合类型数据处理有非常好的支持
   2. Spark的底层用Scala编写

1. scala官网：The Scala Programming Language
2. spark官网：Apache Spark™ - Unified Engine for large-scale data analytics

The Scala Programming Language

Scala combines object-oriented and functional programming in one concise, high-level language. Scala's static types help avoid bugs in complex applications, and its JVM and JavaScript runtimes let you build high-performance systems with easy access to huge ecosystems of libraries.

• 1：入门
• 2、3、4：基本语法介绍
• 5、6、7：核心特性
• 8、9、10、11：其他特色综合讲解

 

本课程特色

1. 内容详尽，重点放在后续项目的应用需要；
2. 案例驱动，由浅入深，通俗易懂，编程小白也可以快速上手；
3. Scala版本2.12，完全匹配最新版项目需要。

第01章-Scala入门

P002【002_尚硅谷_Scala_Scala概述（一）_Scala发展历史】09:25

1.1.2 Scala 发展历史

P003【003_尚硅谷_Scala_Scala概述（二）_Scala和Java的关系】06:57

Scala和Java及JVM关系图

P004【004_尚硅谷_Scala_Scala概述（三）_Scala特点总结】05:40

1、2、3、4

P005【005_尚硅谷_Scala_Scala环境搭建（一）_Scala安装和交互式命令行测试】09:44

P006【006_尚硅谷_Scala_Scala环境搭建（二）_Scala源文件编写和运行】10:21

 

public class HelloJava {
    public static void main(String[] args) {
        System.out.println("Hello, world !");
        System.out.println("小黑子~");
    }
}

object HelloScala {
    def main(args : Array[String]) : Unit = {
        println("hello, world!");
    }
}

P007【007_尚硅谷_Scala_Scala环境搭建（三）_Scala编译结果的反编译深入分析】15:46

java -cp %SCALA_HOME%/lib/scala-library.jar; HelloScala

P008【008_尚硅谷_Scala_在IDE中编写HelloWorld（一）_项目创建和环境配置】06:50

P009【009_尚硅谷_Scala_在IDE中编写HelloWorld（二）_编写代码】04:33

1. class：scala类
2. object：单例对象，全局只有一份的对象，类似于java中的静态对象

P010【010_尚硅谷_Scala_在IDE中编写HelloWorld（三）_代码中语法的简单说明】05:24

package chapter01

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

    System.out.println("hello world !")
    System.out.println("中文不乱码！")
    System.out.println("hello scala from java !")
  }
}

P011【011_尚硅谷_Scala_在IDE中编写HelloWorld（四）_伴生对象的扩展说明】22:58

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", 222)
    val bob = new Student("bob", 333)

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

P012【012_尚硅谷_Scala_在IDE中编写HelloWorld（五）_关联源码和查看官方指南】02:41

1.5 关联Scala源码

官方编程指南，在线查看：https://www.scala-lang.org/

第02章-变量和数据类型

P013【013_尚硅谷_Scala_变量和数据类型（一）_注释和基本编程习惯】06:56

package chapter02

import chapter01.Student

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

P014【014_尚硅谷_Scala_变量和数据类型（二）_变量和常量】16:48

variable value、

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 alice = new Student("alice", 20)
    alice = new Student("Alice", 20)
    alice = null
    val bob = new Student("bob", 23)
    bob.age = 24
    bob.printInfo()
    //bob = new Student("bob", 24)
  }
}

P015【015_尚硅谷_Scala_变量和数据类型（三）_标识符】10:05

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(-+/%) // hello

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

P016【016_尚硅谷_Scala_变量和数据类型（四）_字符串】21:04

模板字符串：

1. s""：前缀s模板字符串，前缀f格式化模板字符串，通过$获取变量值，%后跟格式化字符串。
2. f""：前缀s模板字符串，前缀f格式化模板字符串，通过$获取变量值，%后跟格式化字符串。
3. raw""：不作格式化处理，按照原始样子输出。

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()
    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")//raw不作格式化处理

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

P017【017_尚硅谷_Scala_变量和数据类型（五）_控制台标准输入】03:52

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}来到尚硅谷学习！")
  }
}

P018【018_尚硅谷_Scala_变量和数据类型（六）_读写文件】07:03

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)//Source.fromFile()读文件、foreach()遍历操作

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

P019【019_尚硅谷_Scala_变量和数据类型（七）_数据类型系统】13:44

回顾：Java数据类型

Java基本类型：char、byte、short、int、long、float、double、boolean。

Java引用类型：（对象类型）

由于Java有基本类型，而且基本类型不是真正意义的对象，即使后面产生了基本类型的包装类，但是仍然存在基本数据类型，所以Java语言并不是真正意思的面向对象。

Java基本类型的包装类：Character、Byte、Short、Integer、Long、Float、Double、Boolean。

注意：Java中基本类型和引用类型没有共同的祖先。

Scala数据类型

P020【020_尚硅谷_Scala_变量和数据类型（八）_整型和浮点类型】18:43

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
  }
}

P021【021_尚硅谷_Scala_变量和数据类型（九）_字符和布尔类型】10:19

package chapter02

import chapter01.Student

object Test07_DataType {
  def main(args: Array[String]): Unit = {
    //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)
  }
}

P022【022_尚硅谷_Scala_变量和数据类型（十）_空类型】14:33

package chapter02

import chapter01.Student

object Test07_DataType {
  def main(args: Array[String]): Unit = {
    //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，nothing不会正常返回
    def m2(n: Int): Int = {
      if (n == 0)
        throw new NullPointerException
      else
        return n
    }

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

P023【023_尚硅谷_Scala_变量和数据类型（十一）_Unit类型的源码实现】04:52

/*
 * Scala (https://www.scala-lang.org)
 *
 * Copyright EPFL and Lightbend, Inc.
 *
 * Licensed under Apache License 2.0
 * (http://www.apache.org/licenses/LICENSE-2.0).
 *
 * See the NOTICE file distributed with this work for
 * additional information regarding copyright ownership.
 */

// DO NOT EDIT, CHANGES WILL BE LOST
// This auto-generated code can be modified in "project/GenerateAnyVals.scala".
// Afterwards, running "sbt generateSources" regenerates this source file.

package scala


/** `Unit` is a subtype of [[scala.AnyVal]]. There is only one value of type
 *  `Unit`, `()`, and it is not represented by any object in the underlying
 *  runtime system. A method with return type `Unit` is analogous to a Java
 *  method which is declared `void`.
 */
final abstract class Unit private extends AnyVal {
  // Provide a more specific return type for Scaladoc
  override def getClass(): Class[Unit] = ???
}

object Unit extends AnyValCompanion {

  /** Transform a value type into a boxed reference type.
   *
   *  @param  x   the Unit to be boxed
   *  @return     a scala.runtime.BoxedUnit offering `x` as its underlying value.
   */
  def box(x: Unit): scala.runtime.BoxedUnit = scala.runtime.BoxedUnit.UNIT

  /** Transform a boxed type into a value type.  Note that this
   *  method is not typesafe: it accepts any Object, but will throw
   *  an exception if the argument is not a scala.runtime.BoxedUnit.
   *
   *  @param  x   the scala.runtime.BoxedUnit to be unboxed.
   *  @throws     ClassCastException  if the argument is not a scala.runtime.BoxedUnit
   *  @return     the Unit value ()
   */
  def unbox(x: java.lang.Object): Unit = x.asInstanceOf[scala.runtime.BoxedUnit]

  /** The String representation of the scala.Unit companion object. */
  override def toString = "object scala.Unit"
}

P024【024_尚硅谷_Scala_变量和数据类型（十二）_类型转换（一）_Java类型转换复习】07:21

public class TestDataTypeConversion {
    public static void main(String[] args) {
        byte b = 10;
        test(b);//bbbb
        char c = 'a';
        //short c2 = (short) c;
        test(c);//ssss
    }

    public static void test(byte b) {
        System.out.println("bbbb");
    }

    public static void test(short s) {
        System.out.println("ssss");
    }

    public static void test(char c) {
        System.out.println("cccc");
    }

    public static void test(int i) {
        System.out.println("iiii");
    }
}

P025【025_尚硅谷_Scala_变量和数据类型（十二）_类型转换（三）_Scala自动类型转换】13:07

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

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)
  }
}

P026【026_尚硅谷_Scala_变量和数据类型（十二）_类型转换（四）_Scala强制类型转换】12:03

package chapter02

object Test08_DataTypeConversion {
  def main(args: Array[String]): Unit = {
    //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)
  }
}

P027【027_尚硅谷_Scala_变量和数据类型（十二）_类型转换（五）_强转溢出面试题】09:22

package chapter02

/*
128: Int类型，占据4个字节，32位
原码 0000 0000 0000 0000 0000 0000 1000 0000
补码 0000 0000 0000 0000 0000 0000 1000 0000

截取最后一个字节，Byte
得到补码 1000 0000
表示最大负数 -128

130: Int类型，占据4个字节，32位
原码 0000 0000 0000 0000 0000 0000 1000 0010
补码 0000 0000 0000 0000 0000 0000 1000 0010

截取最后一个字节，Byte
得到补码 1000 0010
对应原码 1111 1110
-126
 */

object Test09_Problem_DataTypeConversion {
  def main(args: Array[String]): Unit = {
    var n: Int = 130
    val b: Byte = n.toByte
    println(b)
  }
}

第03章-运算符

P028【028_尚硅谷_Scala_运算符（一）_算术运算符】09:04

package chapter03

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

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

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

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

    val result4: Int = 10 % 3
    println(result4) //1
  }
}

P029【029_尚硅谷_Scala_运算符（二）_比较运算符】09:25

package chapter03

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

object Test01_TestOperator {
  def main(args: Array[String]): Unit = {
    //2、比较运算符
    println("===================2、比较运算符")
    val s1: String = "hello"
    val s2: String = new String("hello")

    println(s1 == s2) //true
    println(s1.equals(s2)) //true
    println(s1.eq(s2)) //false
  }
}

P030【030_尚硅谷_Scala_运算符（三）_逻辑运算符】14:36

package chapter03

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

object Test01_TestOperator {
  def main(args: Array[String]): Unit = {
    //3、逻辑运算符
    println("===================3、逻辑运算符")

    def m(n: Int): Int = {
      println("m被调用")
      return n
    }

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

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

    println(isNotEmpty(null)) //false
  }
}

P031【031_尚硅谷_Scala_运算符（四）_赋值运算符】15:13

package chapter03

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

object Test01_TestOperator {
  def main(args: Array[String]): Unit = {
    //4、赋值运算符
    println("===================4、赋值运算符")
    //var b: Byte = 10
    var i: Int = 12
    //b += 1
    i += 1
    println(i) //13

    //i ++
  }
}

P032【032_尚硅谷_Scala_运算符（五）_位运算符】18:03

package chapter03

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

object Test01_TestOperator {
  def main(args: Array[String]): Unit = {
    //5、位运算符
    println("===================5、位运算符")
    val a: Byte = 60
    println(a << 3) //480
    println(a >> 2) //15

    val b: Short = -13
    println(b << 2) //-52
    println(b >> 2) //-4
    println(b >>> 2) //1073741820
  }
}

P033【033_尚硅谷_Scala_运算符（六）_运算符的本质】09:03

package chapter03

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

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

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

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

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

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

    println(s1 == s2) //true
    println(s1.equals(s2)) //true
    println(s1.eq(s2)) //false

    //3、逻辑运算符
    println("===================3、逻辑运算符")

    def m(n: Int): Int = {
      println("m被调用")
      return n
    }

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

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

    println(isNotEmpty(null)) //false

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

    //i ++

    //5、位运算符
    println("===================5、位运算符")
    val a: Byte = 60
    println(a << 3)//480
    println(a >> 2)//15

    val b: Short = -13
    println(b << 2)//-52
    println(b >> 2)//-4
    println(b >>> 2)//1073741820

    //6、运算符的本质
    println("===================6、运算符的本质")
    val n1: Int = 12
    val n2: Int = 37

    println(n1.+(n2))//49
    println(n1 + n2)//49

    println(1.34.*(25))//33.5
    println(1.34 * 25)//33.5

    //println(7.5 toInt toString)
  }
}

第04章-流程控制

P034【034_尚硅谷_Scala_流程控制（一）_条件分支（一）_If-Else常规用法】12:06

package chapter04

import scala.io.StdIn

object Test01_IfElse {
  def main(args: Array[String]): Unit = {
    println("请输入您的年龄：")
    val age: Int = StdIn.readInt()

    // 1. 单分支
    if (age >= 18) {
      println("成年")
    }

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

    // 2. 双分支
    if (age >= 18) {
      println("成年")
    } else {
      println("未成年")
    }

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

    // 3. 多分支
    if (age <= 6) {
      println("童年")
    } else if (age < 18) {
      println("青少年")
    } else if (age < 35) {
      println("青年")
    } else if (age < 60) {
      println("中年")
    } else {
      println("老年")
    }
    println("===================")
  }
}

P035【035_尚硅谷_Scala_流程控制（一）_条件分支（二）_If-Else的返回值】13:48

package chapter04

import scala.io.StdIn

object Test01_IfElse {
  def main(args: Array[String]): Unit = {
    println("请输入您的年龄：")
    val age: Int = StdIn.readInt()

    // 4. 分支语句的返回值
    val result: Any = if (age <= 6) {
      println("童年")
      "童年"
    } else if (age < 18) {
      println("青少年")
      "青少年"
    } else if (age < 35) {
      println("青年")
      age
    } else if (age < 60) {
      println("中年")
      age
    } else {
      println("老年")
      age
    }
    println("result: " + result)

    // java中三元运算符 String res = (age >= 18)?"成年":"未成年"

    val res: String = if (age >= 18) {
      "成年"
    } else {
      "未成年"
    }

    val res2 = if (age >= 18) "成年" else "未成年"
  }
}

P036【036_尚硅谷_Scala_流程控制（一）_条件分支（三）_嵌套分支】04:45

package chapter04

import scala.io.StdIn

object Test01_IfElse {
  def main(args: Array[String]): Unit = {
    println("请输入您的年龄：")
    val age: Int = StdIn.readInt()

    // 5. 嵌套分支
    if (age >= 18) {
      println("成年")
      if (age >= 35) {
        if (age >= 60) {
          println("老年")
        } else {
          println("中年")
        }
      } else {
        println("青年")
      }
    } else {
      println("未成年")
      if (age <= 6) {
        println("童年")
      } else {
        println("青少年")
      }
    }
  }
}

P037【037_尚硅谷_Scala_流程控制（二）_For循环（一）_范围遍历】12:27

package chapter04

import scala.collection.immutable

object Test02_ForLoop {
  def main(args: Array[String]): Unit = {
    // java for语法： for(int i = 0; i < 10; i++){ System.out.println(i + ". hello world") }

    // 1. 范围遍历
    for (i <- 1 to 10) {
      println(i + ". hello world")
    }
    for (i: Int <- 1.to(10)) {
      println(i + ". hello world")
    }
  }
}

P038【038_尚硅谷_Scala_流程控制（二）_For循环（二）_不包含边界的范围遍历】07:38

package chapter04

import scala.collection.immutable

object Test02_ForLoop {
  def main(args: Array[String]): Unit = {
    for (i <- Range(1, 10)) {
      println(i + ". hello world")
    }

    for (i <- 1 until 10) {
      println(i + ". hello world")
    }
  }
}

P039【039_尚硅谷_Scala_流程控制（二）_For循环（三）_集合遍历】03:17

package chapter04

import scala.collection.immutable

object Test02_ForLoop {
  def main(args: Array[String]): Unit = {
    // 2. 集合遍历
    for (i <- Array(12, 34, 53)) {
      println(i)
    }
    for (i <- List(12, 34, 53)) {
      println(i)
    }
    for (i <- Set(12, 34, 53)) {
      println(i)
    }
  }
}

P040【040_尚硅谷_Scala_流程控制（二）_For循环（四）_循环守卫】04:41

    // 3. 循环守卫
    for (i <- 1 to 10) {
      if (i != 5) {
        println(i)
      }
    }

    for (i <- 1 to 10 if i != 5) {
      println(i)
    }

P041【041_尚硅谷_Scala_流程控制（二）_For循环（五）_循环步长】14:10

    // 4. 循环步长
    for (i <- 1 to 10 by 2) {
      println(i)
    }
    println("-------------------")
    for (i <- 13 to 30 by 3) {
      println(i)
    }

    println("-------------------")
    for (i <- 30 to 13 by -2) {
      println(i)
    }
    for (i <- 10 to 1 by -1) {
      println(i)
    }
    println("-------------------")
    for (i <- 1 to 10 reverse) {
      println(i)
    }
    println("-------------------")

    //for (i <- 30 to 13 by 0) {
    //  println(i)
    //} // error，step不能为0

    for (data <- 1.0 to 10.0 by 0.3) {//0.3精度会出现问题
      println(data)
    }

P042【042_尚硅谷_Scala_流程控制（二）_For循环（六）_循环嵌套】10:34

    // 5. 循环嵌套
    for (i <- 1 to 3) {
      for (j <- 1 to 3) {
        println("i = " + i + ", j = " + j)
      }
    }
    println("-------------------")
    for (i <- 1 to 4; j <- 1 to 5) {
      println("i = " + i + ", j = " + j)
    }

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

package chapter04

//输出九九乘法表
object Test03_Practice_MulTable {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 9) {
      for (j <- 1 to i) {
        print(s"$j * $i = ${i * j} \t")
      }
      println()
    }

    //简写
    for (i <- 1 to 9; j <- 1 to i) {
      print(s"$j * $i = ${i * j} \t")
      if (j == i) println()
    }
  }
}

P043【043_尚硅谷_Scala_流程控制（二）_For循环（七）_循环引入变量】04:57

    // 6. 循环引入变量
    for (i <- 1 to 10) {
      val j = 10 - i
      println("i = " + i + ", j = " + j)
    }

    for (i <- 1 to 10; j = 10 - i) {
      println("i = " + i + ", j = " + j)
    }

    for {
      i <- 1 to 10
      j = 10 - i
    } {
      println("i = " + i + ", j = " + j)
    }

P044【044_尚硅谷_Scala_流程控制（二）_For循环（八）_练习_输出九层妖塔】11:03

package chapter04

//打印输出一个九层妖塔
object Test04_Practice_Pyramid {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 9) {
      val stars = 2 * i - 1
      val spaces = 9 - i
      println(" " * spaces + "*" * stars)
    }

    for (i <- 1 to 9; stars = 2 * i - 1; spaces = 9 - i) {
      println(" " * spaces + "*" * stars)
    }

    for (stars <- 1 to 17 by 2; spaces = (17 - stars) / 2) {
      println(" " * spaces + "*" * stars)
    }
  }
}

P045【045_尚硅谷_Scala_流程控制（二）_For循环（九）_for循环返回值】10:20

    // 7. 循环返回值
    val a = for (i <- 1 to 10) {
      i
    }
    println("a = " + a)//a = ()，for循环默认返回值为空

    val b: immutable.IndexedSeq[Int] = for (i <- 1 to 10) yield i * i
    println("b = " + b)//b = Vector(1, 4, 9, 16, 25, 36, 49, 64, 81, 100)

P046【046_尚硅谷_Scala_流程控制（三）_While循环】06:06

package chapter04

object Test05_WhileLoop {
  def main(args: Array[String]): Unit = {
    // while
    var a: Int = 10
    while (a >= 1) {
      println("this is a while loop: " + a)
      a -= 1
    }

    var b: Int = 0
    do {
      println("this is a do-while loop: " + b)
      b -= 1
    } while (b > 0)
  }
}

P047【047_尚硅谷_Scala_流程控制（四）_循环中断】12:04

public class TestBreak {
    public static void main(String[] args) {
        try {
            for (int i = 0; i < 5; i++) {
                if (i == 3)
                    //break;
                    throw new RuntimeException();
                System.out.println(i);
            }
        } catch (Exception e) {
            //什么都不做，只是退出循环
        }
        System.out.println("这是循环外的代码！");
    }
}

package chapter04

import scala.util.control.Breaks
import scala.util.control.Breaks._

object Test06_Break {
  def main(args: Array[String]): Unit = {
    //1.采用抛出异常的方式，退出循环
    try {
      for (i <- 0 until 5) {
        if (i == 3)
          throw new RuntimeException
        println(i)
      }
    } catch {
      case e: Exception => //什么都不做，只是退出循环
    }

    //2.使用Scala中的Breaks类的break方法，实现异常的抛出和捕捉
    Breaks.breakable(
      for (i <- 0 until 5) {
        if (i == 3)
          Breaks.break()
        println(i)
      }
    )

    breakable(
      for (i <- 0 until 5) {
        if (i == 3)
          break()
        println(i)
      }
    )

    println("这是循环外的代码！")
  }
}