视频地址：尚硅谷大数据技术之Scala入门到精通教程（小白快速上手scala）_哔哩哔哩_bilibili
尚硅谷大数据技术Scala教程-笔记01【Scala课程简介、Scala入门、变量和数据类型、运算符、流程控制】尚硅谷大数据技术Scala教程-笔记02【函数式编程】尚硅谷大数据技术Scala教程-笔记03【面向对象】尚硅谷大数据技术Scala教程-笔记04【集合】尚硅谷大数据技术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？
Scala——Java++
Scala基于JVM，和Java完全兼容，同样具有跨平台、可移植性好、方便的垃圾回收等特性Scala比Java更加面向对象Scala是一门函数式编程语言Scala更适合大数据的处理
Scala对集合类型数据处理有非常好的支持Spark的底层用Scala编写
scala官网：The Scala Programming Languagespark官网：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：其他特色综合讲解
本课程特色
内容详尽，重点放在后续项目的应用需要；案例驱动，由浅入深，通俗易懂，编程小白也可以快速上手；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
class：scala类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
模板字符串：
s""：前缀s模板字符串，前缀f格式化模板字符串，通过$获取变量值，%后跟格式化字符串。f""：前缀s模板字符串，前缀f格式化模板字符串，通过$获取变量值，%后跟格式化字符串。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("这是循环外的代码！")
}
}
好文阅读
您阅读本篇文章共花了：
发表评论