Scala学习笔记

2022-04-03 21:14:50   34  举报





AI智能生成

Scala是一种功能强大的编程语言，它集成了面向对象编程和函数式编程的特性。Scala的设计目标是提高程序员的生产力，让代码更简洁、更易读。学习Scala需要掌握一些基本概念，如变量、数据类型、函数、类和对象等。此外，还需要了解Scala的一些特性，如模式匹配、高阶函数、闭包和隐式转换等。在学习过程中，可以通过阅读官方文档、参加在线课程或参考相关书籍来提高自己的技能。总之，Scala是一门值得学习的编程语言，它可以帮助你更好地解决实际问题并提高编程效率。

大数据

scala

作者其他创作

大纲/内容

Scala语法基础（重要）

变量声明

变量声明的格式：var | val 变量名 [: 变量类型] = 变量值

var和val

var表示变量是可变的，可以重新赋值

val表示变量不可变

推荐使用val，没有线程安全问题，效率更高

val类型的变量底层是使用了final修饰

同时在idea中，如果使用var修饰变量，但是后面没有重新给变量赋值，var会变成灰色

idea代码示例

和Java类似，Scala也是值传递，对于引用数据类型，例如对象，只是地址不变，但是对象的属性是可以改变的

变量类型可以省略，由编译器自行推导，推荐省略，代码更简洁

在idea中配置Scala数据类型灰色提示

Settings -> Editor -> Inlay Hints -> Scala -> Type hints -> Show type hints for

数据类型

在Scala中没有基本数据类型，都是引用数据类型。这点和Java不一样

Scala数据类型分为两大类AnyVal（值类型）和AnyRef（引用类型）。不管是AnyVal和AnyRef都是对象

数据类型一览

①Byte 8位有符号补码整数。数值区间为 -128 到 127 ②Short 16位有符号补码整数。数值区间为 -32768 到 32767 ③Int 32位有符号补码整数。数值区间为 -2147483648 到 2147483647。如果是整数且不加L，默认为Int，和Java一样。 ④Long 64位有符号补码整数。例如123L。数值区间为 -9223372036854775808 到 9223372036854775807 ⑤Float 32 位。IEEE 754 标准的单精度浮点数。例如0.1F。如果是小数且不加F或者D，默认为Float类型，和Java一样。 ⑥Double 64 位 IEEE 754 标准的双精度浮点数。例如0.1D。 ⑦Char 16位无符号Unicode字符, 区间值为 U+0000 到 U+FFFF ⑧String 字符序列 ⑨Boolean true或false ⑩Unit 表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。 11.Null null 或空引用 12.Nothing Nothing类型在Scala的类层级的最底端；它是任何其他类型的子类型。 13.Any Any是所有其他类的超类 14.AnyRef AnyRef类是Scala里所有引用类(reference class)的基类

Symbol

属于基本类型，被映射成scala.Symbol 2.当两个Symbol值相等时，指向同一个实例 3.Symbol类型存在的意义：作为不可变的字符串，同时不必重复地为相同对象创建实例，节省资源 4.定义变量val s=‘my_symbol时，s值即为 s:Symbol = ’my_symbol。 而s.name为Sting类型，值为my_symbol

数据类型说明

1.Scala的数据类型与Java的基本一样

2.在Scala中有一个根类型Any，它是是所有类的父类

3.Scala中一切皆为对象，分为两大类AnyVal(值类型)和AnyRef(引用类型)

4.Null类型是Scala的特别类型，它只有一个值null，它是bottom class，是所有AnyRef类型的子类

5.Nothing类型也是bottom class，它是所有类的子类，在开发过程中可以将Nothing类型的值返回给任意变量或者函数，这里抛出异常使用很多

6.在Scala中仍然遵守，低精度的值向高精度的值自动转换（implictit conversion）隐式转换

小结 1.在Scala中，所有引用类型的类都是AnyRef的子类，类似于Java的object 2.AnyVal和AnyRef都扩展自Any类。Any类是根节点 3.Any中定义了isInstanceOf、asInstanceOf方法，以及哈希方法等 4.Null类型的唯一实例就是null对象，可以将null赋值给任何引用，但不能赋值给值类型的变量 5.Nothing类型没有实例。它对于泛型结构是有用处的，举例：空列表nuil的类型时List[Nothing]，它是List[T]的子类型，T可以时任何类

标识符（变量名）

和Java一样

运算符

和Java基本一样

Scala不存在i++或者++i这样的写法，只能使用i = i + 1

Scala不支持三目运算符，在Scala中使用if - else的方式实现

var num2 = if (5 > 6) "大于" else "小于"

分支控制

和Java完全一样

if() ... else if(...) else  

循环控制

for循环

1. 基本案例 for (i <- 1 to 3) {       println(i) } 1 to 3左闭右闭 i表示循环中的变量，并且i是val修饰的，不能改变值 1 until 3表示左闭右开

2. 循环守卫 for(i <- 1 to 3 if i!=2){ println(i) } 循环守卫，即循环保护式（也称条件判断式），保护式为true则进入循环体内部，为false则跳过，类似于continue

3. 引入变量 for (i <- 1 to 10; j = 1 + i) {       println("i = " + i + ", j = " + j)     }

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

5. 循环返回值 val rest = for (i <- 1 to 10 ) yield {       if (i % 2 == 0) {         i       } else {         "不是偶数"       }     } 案例说明 将遍历过程中处理的结果返回到一个新的Vector集合中，使用yield关键字，yield后可以接收一段代码块

6. 循环控制步长 方法一 for (i <- Range(1, 10, 2)) {       println(i)     } 说明Range(1, 10, 2) 1代表start值，10代表end值，2代表步长 for(i <- 1 to 10 if i%2==1){ print(i) } 说明：利用循环守卫控制步长

while循环

和Java完全一致

//1. 计算1-100的和     var i = 1     var sum = 0     while (i < 101) {       sum += i       i += 1     }     println(sum)

do while循环

和Java完全一致

//使用do while循环, 输出10次"hello, 尚硅谷"     var i = 0     do {       println("Hello, 尚硅谷")       i += 1     } while (i < 10)

高版本已经废弃

实现Java的continue和break关键字的效果

for循环

continue

//continue。通过循环守卫实现     for (i <- 1 to 10 if i % 2 == 0) {       println(i)     }     //直接在代码中进行if判断     for (i <- 1 to 10) {       if (i % 2 == 0) {         println(i)       }     }

break

//2. 使用循环守卫实现break     println("*******************")     var loop = true     var sum = 0     for (i <- 1 to 100 if loop) {       sum += i       if (sum > 20) {         loop = false       }       println("i = " + i)     }     println("sum = " + sum)

while和do while循环

continue

类似于for循环的循环守卫，定义一个变量

break

//breakable()函数     //说明     //1. breakable是一个高阶函数: 可以接收函数的函数就是高阶函数     import scala.util.control.Breaks._     var n = 10     breakable {       while (n <= 20) {         n += 1         println(n)         if (n == 18) {           break()         }       }     }

推荐使用for循环，while循环和do while循环不能返回值，变量必须定义在外部，且必须定义成var

字符串插值

Scala提供了一种新的机制来根据数据生成字符串：字符串插值。字符串插值允许使用者将变量引用直接插入处理过的字面字符中

val name="James" println(s"Hello,$name")//Hello,James

Scala函数式编程（重要）

函数式编程介绍

函数定义的基本格式 def 函数名([参数名: 参数类型], ...)[[: 返回值类型] = ] {    函数体    [return ]返回值 }

返回值形式1：:返回值的类型 =

返回值形式2：只有一个等号=，表示返回值类型不确定，由编译器自行推导

返回值形式3：什么都没有，表示没有返回值，等价于:Unit=

函数的注意事项和细节

如果函数没有形参，在进行函数调用的时候可以不写()，建议不要省略

Scala中的函数可以根据函数体最后一行代码自行推断出函数的返回类型，那么在这种情况下，return关键字可以省略 因为Scala可以自行推断，所以函数声明处的返回值的类型也可以省略

如果函数明确使用return关键字，那么函数的返回类型就不能自行推断了，这时就要写成：返回值类型 =，如果不写，即使有return，返回值为()

如果函数需要声明无返回值（Unit），那么函数体中有return关键字，也不会有返回值

Scala语法中任何语法结构都可以嵌套其他语法结构，即：函数中可以在声明定义函数，类中可再声明类，方法中可再声明方法

在Scala函数中形参默认是val，因此不能在函数中进行修改

Scala函数支持可变参数，可变参数只能放在参数列表的最后 ①//支持0到多个参数 def sum(args:Int*):Int={} ②支持1到多个参数 def sum(n:Int,args:Int*):Int={} 说明：args是集合，通过for循环可以访问到各个值

默认形参和命名参数

和Java不同的是，Scala可以给函数的形参设定默认值

Scala函数的形参，在声明参数时，直接赋初始值（默认值），这时调用函数，如果没有指定实参，则会使用默认值。如果指定了实参，则实参覆盖默认值。

如果函数存在多个参数，每一参数都可以设定默认值。 在进行函数调用的时候，参数到底是覆盖默认值，还是赋值给没有默认值的参数，这就不确定了

这种情况下，可以采用命名参数 def getSum(n1:Int=1){} getSum(n1=2)

过程

将函数的返回类型为Unit的函数称为过程，如果没有明确函数没有返回值，那么等号可以去掉。

简单来说：没有返回值的函数称为过程。

惰性函数、惰性变量（lazy关键字）

一.惰性函数使用的场景 惰性计算（尽可能延迟表达式计算）是许多函数式编程语言的特性。惰性集合在需要时提供其元素，无需预先计算它们，这带来一些好处。 首先，可以将耗时计算推迟到绝对需要的时候。其次，可以创造无限个集合，只要它们继续收到请求，就会继续提供元素。 函数的惰性使用可以得到更高效的代码。Java并没有为惰性提供原生支持，Scala提供了lazy关键字来支持惰性函数

二.惰性函数介绍 当函数返回值被声明为lazy时，函数执行将会被推迟，直到我没首次对此取值，该函数才会执行。这种函数称之为惰性函数

三.注意事项和细节 1.lazy不能修饰var类型的变量，只能修饰val类型的变量 2.不但是在调用函数时，加了lazy，会导致函数的执行被推迟，我们在声明一个变量时，如果声明了lazy，那么变量值的分配也会被推出例如：lazy val i =10

代码示例

//main方法开始执行 //sum方法之后 //sum函数执行了。。。。。。。。 //3 object LazyDemo01 {   def main(args: Array[String]): Unit = {     println("main方法开始执行")     //当函数返回值被声明为lazy时，函数的执行将被推迟，直到我们首次对此取值，该函数才会执行。     //这种函数我们称之为惰性函数，在Java的某些框架代码中称之为懒加载(延迟加载)。     //val result = sum(1, 2)     lazy val result = sum(1, 2)     println("sum方法之后")     println(result)   }   def sum(arg1 : Int, arg2 : Int): Int = {     println("sum函数执行了。。。。。。。。")     arg1 + arg2   } }

exception

Scala的异常处理机制和Java基本一致。使用try...catch...finally的形式。 catch的时候使用模式匹配，而不是多个从小到大的catch代码块。 Scala没有编译期异常的概念，都是运行时异常。 如果在代码中想要抛出异常，直接使用throw new XXXException即可和Java一样。

同时如果想要和Java一样，提醒代码可能会报错，可以使用throws关键字，但是方法调用处也不需要显示处理

代码示例

try {       var i = 1 / 0     } catch {       case ex: Exception =>         ex.printStackTrace()         throw new RuntimeException("测试手动抛出运行时异常")     } finally {       println("finally最终执行了")     }

object ExceptionDemo02 {   def main(args: Array[String]): Unit = {     val unit: Unit = f1()     println(unit)   }   //scala提供了throws关键字来声明异常。可以使用方法定义声明异常。 它向调用者函数提供了此方法可能引发此异常的信息   //方法的调用处也不需要显示处理   //和java不同的是, scala不需要在方法上声明类型, 没有编译时异常, 都是运行时异常   @throws(classOf[NumberFormatException])   def f1(): Unit = {     "abc".toInt   } }

Scala面向对象初级

面向对象基础

创建对象 基本语法 val | var 对象名[:类型] = new 类型() 1.如果我们不希望改变对象的引用（即：内存地址），应该声明val，否则声明var。Scala设计者推荐使用val，因为一般来说，我们只改变对象属性值，而不是改变对象的引用 2.Scala在声明对象变量时，可以根据创建对象的类型自动判断，所以类型声明可以省略，但是当类型和后面new对象类型有继承和多态时，就必须写了

class Person{ var age:Short=90 var name:String=_ def this(n:String,a:Int){ this() this.name=n this.age=a } } var p:Person=new Person("马云","20") 流程分析 ①加载类的信息（属性信息、方法信息） ②在内存（堆）中开辟空间 ③使用父类的构造器（主和辅助）进行初始化 ④使用主构造器对属性进行初始化 ⑤使用辅助构造器对属性进行初始化 ⑥将开辟的对象地址赋给p这个引用 以上流程基本上和Java一致

成员变量|属性

成员变量定义格式：var | val 属性名[: 数据类型] = 属性值 定义在类的内部

和Java类似成员变量可以是任意数据类型值类型和引用类型

Scala中没有静态成员变量，这点和Java不同

成员变量必须显示初始化, 可以使用_代替对应的值（需要指定数据类型） 不能使用var name = _ 因为编译器无法推断参数类型

属性默认都是private的，但是提供了对应public的XXX()和XXX_eq()方法

Bean属性，使用@BeanProperty注解会在底层自动生成getXxx()和setXxx()方法 @BeanProperty var name ="张三"

成员方法

和函数使用类似

调用对象的方法为对象名.方法名(形参列表)

成员方法默认都是public的

成员方法可以访问成员变量，使用this.成员变量 也可以给成员变量重新赋值

成员方法使用和Java类似

Scala没有静态方法，这点和Java不一样

构造器

基本说明

Scala构造器的基本语法 class 类名(形参列表){//主构造器 //类体 def this(形参列表){//辅助构造器 } def this(形参列表){//辅助构造器 } 说明:主构造器只有一个，辅助构造器函数名称为this，可以有多个。 编译器通过不同参数来区分多个构造器

构造器使用注意事项和细节

1.Scala构造器作用是完成对对象的初始化，构造器没有返回值，和Java一样 2.主构造器的声明直接放置于类名之后 3.主构造器会执行类定义中的所有语句，这里可以体会到Scala的函数式编程和面向对象编程融合在一起。 即：构造器也是方法（函数），传递方法以及使用方法和前面函数部分内容没有区别 4.如果主构造器无参数，小括号可以省略，构造对象时调用构造方法的小括号也可以省略，建议不要省略 5.辅助构造器的名称为this（这个和Java是不一样的），多个辅助构造器通过不同参数列表进行区分，在底层就是构造器重载。 6.辅助构造器一定要先调用主构造器，执行主构造器中的逻辑，并且需要在第一行调用 7.Java里辅助构造器可以直接super去调用父类的主构造器，但是在Scala中只允许主构造器去调用父类的主构造器，使用辅助构造器先要调用主构造器，主构造器会默认先执行父类中的构造器 8.如果想让主构造器变成私有的，可以在()之前加上private，这样用户只能通过辅助构造器来创建对象 9.辅助构造器的声明和主构造器的声明一致，否则会发生错误

属性高级（结合构造器）

1.Scala类主构造器的形参未用任何修饰符，那么这个参数就是局部变量。可以理解主构造方法就是一个普通方法 class B(name:String){}，在类中的任意地方都可以使用，且不允许重新赋值 2.如果参数使用val关键字声明，那么Scala会将参数作为类的私有的只读属性 class A(val name:String){} 3. 如果参数使用var关键字声明，那么Scala会将参数作为类的成员属性使用， class A(var name:String){}

包

Scala包介绍

作用

区分同名类

将类按照文件夹进行管理

控制访问范围

对类的功能进行扩展

命名规则

只能包含数字、字母、下划线，不能使用数字开头，也不能使用关键字

命名规范

小写字母+小圆点

常见如com.公司名.项目名.业务模块

Scala自动导入的包

java.lang.*

scala包

Predef包

import详解

1.在Scala中，import语句可以出现在任何地方，并不和Java一样限于文件顶部，import语句的作用一致延申到包含该语句的块末尾，这样做的好处是：在需要时引入包，缩小import包的作用范围，提高效率 2.Java中如果想要导入包的所有类，可以通过通配符*，Scala采用_ 3.如果不想要某个包中的全部类，而是其中的几个类，可以采用选取器（大括号） 4.如果引入的多个包中含有相同的类，那么可以将不需要的类进行重命名进行区分，这个就是重命名 //将Java的HashMap重命名成JavaHashMap} import java.util.{HashMap => JavaHashMap} 5.如果某个冲突的类根本不会用到，那么这个类可以直接隐藏掉 //将Java的HashMap这个包隐藏掉，其他包可以使用 import java.util.{HashMap => _,_} 6.Scala在定义包时，源码文件和定义的包可以不再同一个文件夹下。 但是编译后，会在同一个文件夹下(由编译器完成)

代码实现

import 导入包

object ScalaPackageDemo03 {   def main(args: Array[String]): Unit = {     //1. scala中import可以出现在任何地方。可以缩小类的使用范围。其实感觉没啥用     //2. scala中采用下 _ 代替java中的 *     //3. 如果不想要某个包中全部的类，而是其中的几个类，可以采用选取器(大括号)import scala.collection.mutable.{HashMap, HashSet}     //4. scala可以对包进行重命名和隐藏     test2()   }   def test(): Unit = {     import scala.collection.mutable.{HashMap, HashSet}     var map = new HashMap()     var set = new HashSet()   }   def test2(): Unit = {     //重命名     //这个对于多个包有同名类非常有用     import java.util.{HashMap => JavaHashMap}     //隐藏     import scala.collection.mutable.{HashMap => _}     val intToString = new JavaHashMap[Int, String]()     println(intToString)     //    new ScalaHashMap[]() 直接报错   } }

Scala包对象

基本介绍

Java的package本质上就是文件夹，不能定义类、成员变量、方法 这是Java虚拟机的局限，为了弥补这一点不足，Scala提供包对象来解决这个问题

包对象使用注意事项

1.每个包中只能有一个包对象

2.包对象名称需要与包名一致，一般用来对包的功能补充

代码示例

// 有一个 Fruit 类和三个 Fruit 对象在包 gardening.fruits 中 package gardening.fruits case class Fruit(name: String, color: String) object Apple extends Fruit("Apple", "green") object Plum extends Fruit("Plum", "blue") object Banana extends Fruit("Banana", "yellow") // 在包对象 fruits 中定义变量 planted 和方法 showFruit package gardening package object fruits { val planted = List(Apple, Plum, Banana) def showFruit(fruit: Fruit): Unit = { println(s"${fruit.name}s are ${fruit.color}") } } // 在同一个包下使用包对象中的成员，可以直接使用 // 在不同包中使用包对象中定义的变量和方法：import gardening.fruits._，和导入类的方式相同。 import gardening.fruits._ object PrintPlanted { def main(args: Array[String]): Unit = { for (fruit <- fruits.planted) { showFruit(fruit) } } }

因为包对象中的所有方法和属性，包下面的所有类都能访问，类似于抽取的作用。之前使用工具类，现在可以使用包对象

因此在包对象中一般定义隐式值、隐式转换函数、隐式类和通用方法等 详情可以见org.apache.flink.streaming.api.scala包对象，里面定义了隐式转换函数

高版本已经废弃

访问权限

1.成员变量访问权限为默认时，从底层看属性时private，但是提供了xxx_$eq()【类似setter】/xxx()【类似getter】方法，因此从效果上看时任何地方都可以访问 2.当方法访问权限问默认时，默认为public访问权限 3.private时私有权限，只能在类的内部和伴生对象中使用 4.protected为受保护权限，在Scala中受保护权限比Java更严格，只能子类访问，同包无法访问 5.在Scala中没有public关键字，即不能用public显式的修饰属性和方法

代码示例

object VisitTest {   def main(args: Array[String]): Unit = {     val demo0 = new VisitDemo01     //报错, private修饰的字段只能在本类和伴生对象中使用     //demo0.sal     println(demo0.name)     demo0.showInfo()     //protected只能在子类中使用, 同包无法访问     //demo0.age   } } object VisitDemo01 {   def test1(visitDemo01: VisitDemo01): Unit = {     //private为私有权限, 只能在类的内部和伴生对象中使用     println(visitDemo01.sal)   } } /**  * scala中字段、方法等访问权限和java不一样，有四种public、protected、private  * scala中没有public关键字, 默认就是public  * protected为受保护的权限, 只能子类访问, 同包不能访问  * private为私有权限, 只能在类的内部和伴生对象中使用  */ class VisitDemo01 {   //可以理解为public, 可以在任意地方使用   var name = "jack"   //私有属性, 只能在类的内部和伴生对象中使用   private val sal = 9999.9D   //protected只能在子类中使用, 同包无法访问   protected var age = 10   def showInfo(): Unit = {     println(s"薪资: $sal")   } }

Scala面向对象高级

继承

和Java一样，Scala也支持继承，也只支持单继承。

基本语法格式：class 子类名 extends 父类名 { 类体 }

子类继承了父类的所有属性和方法，但是父类中私有的属性和方法不能访问

访问父类的成员变量和方法使用super.的方式

重写父类方法

子类重写父类的非抽象方法需要使用override关键字修饰

class Person {   var name : String = "jack"   private val sal : Double = 9999.9   protected  var age = 10   var job : String = "大数据工程师"   def showInfo(): Unit = {     println("name = " + name + ", sal = " + sal + ", job = " + job)   }   def printName(): Unit = {     println(name)   } } class Student extends Person {   def study(): Unit = {     println("name = " + name + ", job = " + job) //    子类无法访问父类的私有属性，因为sal()方法被私有了 //    println(sal)   }   override def printName(): Unit = {     println("子类重写父类的方法")     println(name)   } }

显示调用父类构造器

如果类之间存在继承关系那么在声明子类时必须要给父类的主构造器传值 可以简单地理解为子类主构造器必须显示调用父类的主构造器

不存在super(...)调用父类的构造器的方式

代码示例

class Student100(studentName: String) extends Person100(studentName) {   println(s"Student100住构造器被调用了。。。。传入的参数$studentName")   def this(age: Int, className: String, studentName: String) {     //不存在super(...)调用父类的构造器     //super(studentName)     this(studentName)     println(s"辅助构造器被调用了, age: $age, 班级名称: $className, 学生姓名: $studentName")   }   override def toString: String = {     s"学生姓名是: $studentName"   } } class Person100(name: String) {   println(s"Person100主构造被调用了。。。。传入的参数: $name") }

重写父类字段

在Scala中支持重写子类重写父类的字段，复写的字段需要使用override关键字修饰

class AAA {   val age : Int = 20 } class BBB extends AAA{   override val age : Int = 20 }

覆写字段的注意事项和细节 1.def只能重写另一个def（即方法只能重写另一个方法） 2.val只能重写另一个val属性或不带参数的def 3.var只能重写另一个抽象的var属性

class AAAA {   //这里运行报错，编译不报错 //  var age : Int = 10   val age : Int = 20 } class BBBB extends AAAA {   override val age: Int = 20 }

抽象类

Scala中可以使用abstract关键字用来标识不能实例化的类 抽象类中的可以有抽象字段、实例字段、抽象方法以及普通方法

抽象字段就是没有初始化的字段

抽象方法就是没有方法体的方法

抽象属性

声明未初始化的变量就是抽象的属性，抽象属性在抽象类

var重写抽象的var属性小结

①一个属性没有初始化，那么这个属性就是抽象属性 ②抽象属性在编译成字节码文件时，属性并不会声明，但是会自动生成抽象方法，所有类必须声明为抽象类 ③如果时覆写一个父类的抽象属性，那么override关键字可以省略 （原因：父类的抽象属性生成的时抽象方法，因此就不会涉及到方法重写的概念，因此override可以省略）

代码示例

abstract class Animal { //  抽象字段，只会生成抽象的name()方法   val name : String //  抽象字段，会生成抽象的age()和age_$eq()方法   var age : Int //  非抽象字段，普通属性，生成color()和color_$eq()方法   var color : String = "黄色" //  非抽象字段，不可变属性，生成sex()方法   val sex : String = "公" //  抽象方法不需要生命abstract，只需要省略方法体即可   def eat(): Unit   //普通方法, 有方法体   def eat2(): Unit = {     println("eat2普通方法被调用了。。。。")   } }

想要实例化一个抽象类，必须要要重写所有的抽象字段和抽象方法

val animal: Animal = new Animal {       override val name: String = ""       override var age: Int = _       override def eat(): Unit = {}     }

子类继承自抽象类，必须要重写所有的抽象字段和抽象方法，否则自己也声明成抽象类

抽象类中可以没有抽象方法或者抽象字段, 这点和Java类似

伴生对象和伴生类

静态概念介绍

Scala语言完全是面向对象的（万物皆对象）的语言，所以并没静态的操作（即在Scala中没有静态的概念）。

但是为了和Java语言交互（因为Java中有静态概念），就产生了一种特殊的对象来模拟类对象，我们称之为伴生对象。

这个类的所有静态内容都可以放置在它的伴生对象中声明和调用

伴生对象小结

1.scala中伴生对象用object关键字声明，伴生对象中的内容全部是静态 2.伴生对象对应的是伴生类，伴生对象的名称和伴生类的名称要一致 3.伴生对象中的属性和方法可以直接通过伴生对象名称调用 4.从语法上来看，所谓的伴生对象就是静态方法和静态属性的集合 5.从技术上来看，Scala还是没有生成静态的内容，只不过是将伴生对象生成了一个新的类，实现属性和方法的调用 6.从底层原理上看，伴生对象静态特性是依赖于public static final MODULE$实现的 7.伴生对象和伴生类的声明必须在同一个源码文件中，但是没有伴生类，就没有所谓的伴生对象了，所有放哪里无所谓，但是底层还是生成了一个空的伴生类 8.如果class A独立存在，那么A就是一个类；如果object A独立存在，那么A就是一个“静态”性质的对象（类对象） 9.当一个文件中同时存在伴生对象和伴生类，那么文件的图标会发生变化 10.伴生对象是一种特殊的类，可以继承类、也可以实现trait等，但是只有一个实例

apply方法

伴生对象apply方法 1.在伴生对象中定义apply方法，可以实现类名()的方式创建对象实例

代码示例

伴生类和伴生对象简单使用

object VisitDemo01 {   def main(args: Array[String]): Unit = {     //如果new对象没有形参, 那么可以省略()     val person = new Person     person.showInfo()     //对于伴生对象而言, 调用方法或者字段的方式就是伴生对象名.方法名或者字段名。和Java类似     //伴生对象名.方法名     Person.test(person)     //伴生对象.字段名, 获取字段的值     println(Person.xxx)   } } //当一个文件中出现了 class Person 和 object Person时 //伴生对象和伴生类必须写在同一个文件中 //1. class Person 称之为伴生类 //2. object Person 称之为伴生对象 //3. scala设计者将static拿掉，因为static并不是oop的内容，于是设计了伴生类和伴生对象的概念 //4. 在伴生类中写非静态的内容，在伴生对象写静态内容 //5. 如何理解呢？把伴生对象当成普通的类即可, 只不过只有一个对象, 而且是已经创建好的对象, 可以直接使用。 //   可以声明方法、字段、继承类等 class Person {   var name : String = "jack"   private val sal : Double = 9999.9   protected  var age = 10   var job : String = "大数据工程师"   def showInfo(): Unit = {     println("name = " + name + ", sal = " + sal + ", job = " + job)   } } object Person {   val xxx = 20   def test(p : Person): Unit = {     p.showInfo()   }   def testVisit(person: Person): Unit = {     println(s"测试字段的访问权限, sal: ${person.sal}")   } }

伴生对象apply方法

object Demo02 {   def main(args: Array[String]): Unit = {     //这里可以使用伴生对象的名称例如Pig(参数1, 参数2)。直接得到实例化对象     //会自动调用伴生对象的apply方法构建实例对象     println(Pig("李四"))   } } class Pig(var name: String = "王五") {   Pig.test1()   println(s"伴生对象的编号字段的值: ${Pig.number}")   override def toString: String = s"小猪的名字是$name" } object Pig {   val number = 0L   def apply(name: String): Pig = new Pig(name)   def apply(): Pig = new Pig()   def test1(): Unit = {     println("伴生对象Pig中的方法test1()被调用了。。。。")   } }

特质（trait）

特质基本介绍与快速入门

一.特质的声明 trait 特质名{ trait体 } trait的命名一般首字母大写

二.Scala中特质的使用 一个类中具有某种特质（特征），就意味着这个类满足了这个特质（特征）的所有要素，所有在使用时也是用extends关键字，如果有多个特征存在父类，那么需要用with关键字连接 1.没有父类 class 类名 extends 特质1 with 特质2 with 特质3 2.有父类 class 类名 extends 父类 with 特质1 with 特质2

三.快速入门 1.可以把特质看作是对继承的一种补充。Scala的继承是单继承，也就是一个类最多只能有一个父类，这就对子类功能的扩展有一定的影响。所以我们认为：Scala引入trait特质，第一可以替代Java的接口，第二也是对单继承的一种补充

四.特质的再说明 1.trait可以同时拥有抽象方法和具体方法，一个类可以实现或者继承多个特质 2.Java中的接口可以直接当成Scala特质使用

代码示例

object TraitDemo01 {   def main(args: Array[String]): Unit = {     new Demo01().sayHello()     new Demo01().sayHi("张三")     Demo01.sayHello()   } } trait Trait01 { //  var age : Int   def sayHi(name: String): Unit = {     println("Hi " + name)   }   def sayHello() } class Demo01 extends Trait01 {   override def sayHello(): Unit = {     println("Hello")   } } object Demo01 extends Trait01 {   override def sayHello(): Unit = {     println("Hello")   } }

Scala用特质代替接口

1.从面向对象来看，接口并不属于面向对象的范畴，Scala是纯面向对象的语言，在Scala中没有接口 2.Scala语言中采用特质trait（特征）来代替接口的概念，多个类具有相同的特征时，就可以将这个特征独立出来，采用关键字trait声明。 简单理解为 trait等价于 interface+abstract class

动态混入

动态混入是Scala特有的方式（Java没有动态混入），可在不修改类声明/定义的情况下，扩展类的功能，非常的灵活，耦合性低 。 动态混入可以在不影响原有的继承关系的基础上，给指定的类扩展功能。

在不修改类的定义基础，让他们可以使用trait中的方法 除了可以在类声明时继承特质以外，还可以在构建对象时混入特质，扩展目标类的功能 此种方式也可以应用于对抽象类功能进行扩展

代码示例

object MixInDemo01 {   def main(args: Array[String]): Unit = {     val oracleDB = new OracleDB with Operate3 //OCP原则。开闭原则     oracleDB.insert(100) //     val mySQL = new MySQL3 with Operate3     mySQL.insert(200)     //如果一个抽象类有抽象方法，如何动态混入特质     val mySql_ = new MySQL3_ with Operate3 {         override def say(): Unit = {         println("say")       }     }     mySql_.insert(999)     mySql_.say()   } } trait Operate3 { //特质   def insert(id: Int): Unit = { //方法（实现）     println("插入数据 = " + id)   } } class OracleDB { //空 } abstract class MySQL3 { //空 } abstract class MySQL3_ { //空   def say() }

叠加特质

一.叠加特质的基本介绍 构建对象的同时如果混入多个特质，称之为叠加特质 那么特质声明顺序从左到右，方法执行顺序从左到右

二.叠加特质的注意事项和细节 1.特质声明顺序从左到右 2.Scala在执行叠加对象方法时，会首先从最右边的特质开始执行，类似于数据结构栈 3.Scala特质中如果调用super方法，并不是表示调用父特质中的方法，而是向左边继续查找特质，如果左边没有特质，此时就会调用父特质 4.如果想要调用具体特质的方法，可以指定super[特质名].方法，其中泛型必须是该类的直接超类类型

三.在特质中重写抽象方法 trait A{ def insert() //抽象方法 } trait B extends A{ override def insert(): Unit = { println("将数据保存到文件中！") super.insert() //思考这里super如何调用父特质中的抽象方法 } } 以上代码会出错，原因：是没有完全实现insert方法，同时还要声明abstract override 解决方法：①去掉super.insert() ②调用父特质的抽象方法，那么在实际使用中，没有方法的具体实现，无法通过编译，为了避免这种情况的发生。可以重写抽象方法，这样在使用过程中必须考虑动态混入的顺序问题

一.富接口的概念 当一个特质中既有抽象方法，又有非抽象方法，这种特质我们称之为富接口

二.特质中的具体字段 特质中可以定义具体字段，如果初始化了就是具体字段，如果没有初始化就是抽象字段。混入该特质的类就具有了该字段，字段不是继承而是直接加入类，成为自己的字段

特质扩展

三.特质构造顺序 1.特质也是有构造器的，构造器中的内容由“字段初始化”和一些其他语句构成。具体实现请参考“叠加特质” 第一种特质构造顺序（声明类的同时混入特质【静态混入】） ①调用当前类的超类构造器 ②第一个特质的父类构造器 ③第一个特质构造器 ④第二个特质构造器的父特质构造器，如果已经执行，就不会在执行 ⑤第二个特质构造器 ⑥重复4，5步骤（如果有第3，4个特质） ⑦最后执行本类的构造 第二种特质构造顺序（构建类的同时混入特质【动态混入】） ①调用当前类的超类构造器，然后执行本类的构造 ②第一个特质的父类构造器 ③第一个特质构造器 ④第二个特质构造器的父特质构造器，如果已经执行，就不会在执行 ⑤第二个特质构造器 ⑥重复4，5步骤（如果有第3，4个特质） 分析两种方式对构造顺序的影响 第1种方式实际是构建类对象，在混入特质时，该对象还没有创建 第2种方式实际是构造匿名子类，可以理解成在混入特质时，该对象已经创建

四.扩展类的特质 1.特质可以继承类，以用来扩展该特质的一些功能 2.所有混入该特质的类，会自动成为那个特质所继承的超类的子类 3.如果混入该特质的类，已经继承了另一个类（A类），则要求A类是特质超类的子类，否则就出现了多继承，就会报错。

五.自身类型 说明：自身类型主要是为了解决特质的循环依赖问题，同时可以确保特质在不扩展某个类的情况下，依然可以做到限制混入该特质的类的类型

嵌套类

Scala类型检查和转换

①obj.isInstanceOf[T] 就如同Java中的obj isInstanceOf T 判断obj是不是T类型 ②obj.asInstanceOf[T] 就如同Java的(T).obj 将obj强转成T类型 ③classOf[String] 就如同Java的 String.class 输出方法的类名

Scala中推荐使用匹配代替强制转换

隐式转换（重要）

隐式转换函数（隐式方法）

一.隐式转换的实际需要 指定某些类型的相互转换比如 Double <=> Int

二.隐式转换基本介绍 隐式转换函数是以implicit关键字声明的带有单个参数的函数。这种函数将会自动应用，将值从一种类型转换成另一种类型

三.快速入门 implicit def f1(d:Double):Int={ //将double类型转换成int类型 d.toInt }

四.隐式转换注意事项和细节 1.隐式转换函数的函数名可以是任意的，隐式转换于函数名称无关，只与函数签名（函数参数类型和返回值类型）有关 2.隐式函数可以有多个（隐式函数列表），但是要保证当前环境下只有一个隐式函数能被识别

五.隐式转换丰富类库的功能 1.如果需要为一个类增加一个方法，可以通隐式转换来实现。（动态增加功能），比如想为MySQL类增加一个delete方法 2.当前程序中，如果想要给MySQL类增加功能是非常简单的，但是在实际项目中，如果想要增加新的功能就要修改源代码，这是很难接受的。而且违背了软件开发的OCP开发原则（闭合原则：open close priceple），这种情况下，可以通过隐式转换函数给类添加功能

代码示例

//导入对应的规则类，以免出现警告 import scala.language.implicitConversions //指定某些数据类型的相互转化 //隐式转换函数的函数名可以是任意的, 与函数名无关, 只与函数的签名有关, 即函数的形参和返回值 object ImplicitFunDemo01 {   def main(args: Array[String]): Unit = {     //这里定义了隐式转换函数, 使用implicit关键字修饰只有单个参数的方法, 并且有返回值     //隐式转换函数只在当前作用于生效     //可以使用import关键字导入相应的隐式函数     implicit def f1(num: Double): Int = num.toInt     implicit def f2(num: Float): Int = num.toInt     //隐式函数可以有多个, 当时需要保证在当前环境下, 只能有一个函数被识别, 否则会发生编译错误     //implicit def f3(num: Float): Int = num.toInt     //scala中有下划线的就是有隐式转换, 编译器识别了隐式转换函数     val num: Int = 3.5D     println(num)     val num2: Int = 3.5f     println(num2)   } }

隐式类

一.隐式类的基本介绍 在Scala2.10后提供了隐式类，可以使用implicit声明类，隐式类非常强大，同时可以扩展类的功能，比前面使用的隐式转换（函数）丰富类库功能更加方便，在集合中隐式类会发挥重要作用

二.隐式类的特点 1.其他带有构造参数有且只能有一个 2.隐式类必须定义在“类“、”伴生对象”、“包对象”中，既即隐式类不能是顶级的（top-class objects） 3.隐式类不能是case class样例类 4.作用域内不能有与之相同名称的标识符（名称）

三.创建方式 implicit class BBB(i: Int){ def add(j: Int) = i + j } }

代码示例

//在scala2.10后提供了隐式类, 可以使用implicit声明类, 隐式类非常强大, 同样可以拓展类的功能 //比前面使用隐式转换函数使用上更加方便, 在集合中隐式类会发挥重要的作用 object ImplicitClassDemo {   def main(args: Array[String]): Unit = {     //使用implicit关键字修饰类     //隐式类不能是顶级的class, 必须定义在其他顶级类中     //类的主构造方法就是要增强的类, 且只能是一个参数, 一般也是转换前的类型     //隐式类不能是case class     implicit class DB1(var mySQL1: MySQL1) {       def addSuffix(): String = {         mySQL1.hashCode() + " scala"       }     }     val mySQL = new MySQL1     mySQL.sayOk()     println(mySQL.addSuffix())   } } class MySQL1 {   def sayOk(): Unit = {     println("sayOk")   } }

隐式参数（隐式形参）、隐式值（隐式变量）

隐式值（隐式变量）

隐式值也叫隐式变量，将变量标记使用implicit修饰。隐式值只要配合隐式参数

隐式参数（隐式形参）

指方法或者函数的形参使用了implict关键字修饰

隐式值和隐式参数的关系

1.编译器会在方法省略隐式参数的情况下，去搜索作用域中的隐式变量作为缺省参数（默认值） 2.当同时有implicit值和默认值时，会调用implicit值，因为implicit值的优先级高 3.当同时有implicit值和默认值时，但是两则类型不匹配，则会调用默认值 4.当同时有implicit值和没有默认值时，但是implicit值类型与形参类型不匹配，此时会报错

隐式值和隐式参数的作用

在于可以给方法的形参设置默认值，但是优先级高于参数的默认值

在方法调用时，省略形参的赋值，让代码看上去更加简洁

一般隐式参数使用科里化的方式，而且也是最后一个形参

隐式参数和隐式值的代码示例

代码示例1

object ImplicitValDemo01 {   def main(args: Array[String]): Unit = {     //隐式值或者隐式变量     //可以使用import关键字导入相应的隐式值     implicit val string: String = "Jack"     //隐式值和隐式转换函数类似, 在作用域内只能有一个隐式值匹配, 不能有多个, 不然编译器无法确定选择哪个隐式值     //implicit val string2: String = "Jack"     //name就是隐式参数     def hello(implicit name: String): Unit = {       println(s"hello $name")     }     //这里不用传递name参数, 编译器会自动在作用域内寻找隐式值, 然后传入改方法     hello     //当然也可以传递参数覆盖隐式值     hello(name = "张三")   } }

代码示例2

object ImplicitValDemo02 {   def main(args: Array[String]): Unit = {     // 隐式变量（值）     //implicit val name2: String = "Scala"     implicit val name1: String = "World"     //隐式参数     def hello(implicit content: String): Unit = {       println("Hello " + content)     }     //调用hello, 打印Hello World     hello     //当同时有隐式值和默认值，隐式优先级高     def hello2(implicit content: String = "jack"): Unit = {       println("Hello2 " + content)     }     //调用hello2, 打印Hello2 World     hello2     //当一个隐式参数匹配不到隐式值，仍然会使用默认值     def hello3(implicit content: Int = 123): Unit = {       println("Hello3 " + content)     }     //调用hello3, 打印Hello3 123     hello3     //当没有隐式值，没有默认值，又没有传值，就会报错     def hello4(implicit content: Double): Unit = {       println("Hello4 " + content)     }     //编译器直接报错, No implicits found for parameter content     //hello4   } }

总结： ①在程序中，同时有隐式值默认值传值时 ②优先级为传值 > 隐式值 > 默认值 ③在隐式值匹配时，不能有二义性 ④如果隐式值默认值传值都不存在，则程序会报错

使用隐式参数常见问题

1）当函数没有柯里化时，implicit关键字会作用于函数列表中的的所有参数。 2）隐式参数使用时要么全部不指定，要么全不指定，不能只指定部分。 3）同类型的隐式值只能在作用域内出现一次，即不能在同一个作用域中定义多个相同类型的隐式值。 4）在指定隐式参数时，implicit 关键字只能出现在参数开头。 5）如果想要实现参数的部分隐式参数，只能使用函数的柯里化， 如要实现这种形式的函数，def test(x:Int, implicit  y: Double)的形式，必须使用柯里化实现：def test(x: Int)(implicit y: Double). 6) 柯里化的函数， implicit 关键字只能作用于最后一个参数。否则，不合法。 7）implicit 关键字在隐式参数中只能出现一次，柯里化的函数也不例外！

隐式对象

隐式对象和隐式参数、隐式值类似, 相当于一个默认值

使用implicit关键字修饰object

隐式对象不能是顶级对象, 必须要在其他类或者对象中

代码示例

object ImplicitObjectDemo01 {   def main(args: Array[String]): Unit = {     trait S1 {       def fun(): Unit     }     //隐式对象不能是顶级对象, 必须要在其他类或者对象中     implicit object S2 extends S1 {       override def fun(): Unit = println("Spark")     }     def g(arg1: String)(implicit arg2: S1): Unit = {       println(s"隐式对象的解析!!!, 参数: $arg1")       arg2.fun()     }     g("Scala")(() => println("不是隐式对象"))     //这里隐式对象S2在这里当做隐式值使用     g("Scala")   } }

上面的代码中的S2隐式对象，可以看成特质S1的一个默认实现。在调用时，就能够省略这个默认实现

隐式转换细节

一.隐式转换时机 1.当方法中的参数的类型与目标类型不一致时 2.当对象调用所在类中不存在的方法和成员时，编译器会自动将对象进行隐式转换

二.隐式解析机制 即：编译器是如何查找到缺失信息的，解析具有以下两种规则 1.首先会在当前代码作用域下查找隐式实体（隐式方法，隐式类，隐式对象），这是一般情况 2.如果第一条规则查找隐式实体失败，会继续在隐式参数的类型的作用域查找。 类型的作用域是指与该类型相关联的全部伴生模块，一个隐式实体的类型T它的查找范围如下（这种情况复杂并且使用范围广，应当避免出现）

三.隐式转换的规则 1.隐式转换不能有二义性 2.隐式操作不能嵌套使用

idea配置和显示下划线显示隐式转换

Setting -> Languages & Frameworks -> Scala -> Hignligting

效果1

效果2

Scala数据结构

集合

集合的基本介绍

一.Scala集合基本介绍 1.Scala同时支持不可变集合和可变集合，不可变集合可以安全的并发访问 2.两个主要的包 不可变集合：scala.collection.immutable 可变集合：scala.collection.mutable 3.Scala默认采用不可变集合，对于几乎所有的集合类，Scala都同时提供了可变（mutable）和不可变（immutable）的版本， 4.Scala的集合有三大类：序列Seq、集Set、映射Map，所有集合都扩展自Iterable特质，在Scala中集合有可变（mutable）和不可变（immutable）两种类型

二.可变集合和不可变集合 1.不可变集合：Scala不可变集合，就时这个集合本身不能动态变化。类似于Java的数组，是不可以动态增长的 2.可变集合：就是这个集合本身可以动态变化，是可以动态增长的

三.集合的种类 1.数组Array 2.元组Tuple 3.列表List 4.队列Queue 5.映射Map 6.集Set

数组(Array)

定长数组

第一种方式定义数组（动态创建） 这里的数组等同于Java中的数组，中括号的类型就是数组的类型，小括号中的数字代表数组的长度 var arr1 = new Array[int](10)

第二种方式定义数组（静态创建） 在定义数组时，直接赋值 //使用apply方法创建数组对象 val arr = Array(1,2,zhangsan)

注意：如果赋值元素全部为Int，则该数组的泛型就是Int；如果有各种类型的元素，则该数组的泛型为Any

变长数组

一.变长数组的基本使用 val array = new ArrayBuffer[Int]() arrar.append(7) //追加元素 array.remove(0) //删除元素，索引位置 array(0) = 7 //重新赋值

二.变长数组分析小结 1.ArrayBuffer是变长数组，类似于Java的ArrayList 2.val arr = ArrayBuffer[Int]() 3.def append(elems:A*) {append(elems)}接受的是可变参数 4.每append一次，arr在底层会重新分配空间，进行扩容，arr的内存地址会发生变化，也就成为新的ArrayBuffer

定长数组与变长数组相互转换

三.定长数组和变长数组的转换 arr1.toBuffer //定长数组转变长数组 arr2.toArray //变长数组转可变数组 ①arr2.toArray 返回的结果才是一个定长数组，arr2本身没有发生变化 ②arr1.toBuffer返回结果才是一个可变数组，arr1本身没有发生变化

多维数组

一.多维数组的基本操作 //说明：二维数组中有三个一维数组，每个一维数组中有四个元素 val arr = Array.ofDim[Double](3,4) //赋值 arr(1)(1) = 11

二.多维数组的遍历 for (item <- arr){ for (item2 <- item){ print(item) } }

元组(Tuple)

一.tuple介绍 元组可理解成一个容器，可以存放各种相同和不同的数据。简单来说，就是将多个无关的数据封装成一个整体，称为元组。注意：元组内最多只能有22个数据

二.元组的创建 val tuple = (1,2,3,"hello",2,2)

三.小结 1.tuple的类型取决于tuple中有多少个元素，比如有 6个元素，则类型就是tuple6 2.元组中最大只能有22个元素

四.元组的访问 访问元组中的数据，可以采用顺序序号（_顺序号），也可以通过索引（productElement）访问 tuple1._1 //1代表顺序号 tuple1.productElement(0) //0代表索引

五.元组的遍历 1.元组的遍历需要用到迭代器 2.即 for(item <- tuple1.productIterator){ print(item) }

列表(List)

一.列表的基本介绍 Scala中list和Java List本不一样，Java中的List是一个接口，真正存放数据的是ArrayList，而Scala的list可以直接存放数据，就是一个object，默认情况下，Scala的list是不可变的，list属于序列Seq

二.说明 1.在默认情况下list是Scala.collection.immutable.list，即list是不可变的 2.在Scala中，list就是不可变的，如果需要使用可变的list，则使用listBuffer 3.Nil代表空集合

三.小结 1.list默认为不可变的集合 2.list在Scala包对象声明的，因此不需要引入其他包也可以使用 3.val List = scala.collection.immutable.List 4.list中可以存放任何数据类型，比如arr1的类型为list[Any] 5.如果希望得到一个空列表，可以使用Nil对象，在Scala包对象声明的，因此不需要引入其他包也可以使用 val Nil = scala.collection.immuteable.Nil

四.列表的元素追加 1.基本介绍 向列表中增加元素，会返回新的列表/集合对象，本身的集合并没有发生变化。注意Scala列表追加元素的形式非常独特，和Java不一样 val list01 = List(1,2,3) var list02 = list01:+9 //创建一个新的列表并在这个列表的最后添加 var list03 = 4 +: list01 //（同上）在列表的最前面添加 2.添加数据::符号 ①符号::表示向集合中新建集合添加元素 ②运算时，集合对象一定要放置在最右边 ③运算规则，从左向右 ④:::运算符是将集合中的每一个元素加入到空集合中，并且:::符号左右两边都为集合，不然会报错 ⑤ //将元素1 2 和 list列表存放到空列表Nil中 val list2 = 1 :: 2 :: list :: Nil println(list2) //List(1, 2, List(1, 2, 3, 4))

五.listBuffer可变列表 ①列表创建 val list = new ListBuffer[Int]() ②访问列表 list(0) ③动态追加元素 list += 1 和 list.appent(1,2,3) 和 list :+ 5 ④列表中添加列表 list ++= list01 ⑤删除元素 list.remove(1) //索引值（下标值）

六.listBuffer的操作案例 //listBuffer列表添加元素或列表 listBuffer += (99,22) //可以添加一个或多个元素 listBuffer.append(29,100) listBuffer ++= list //添加一个列表 println(listBuffer) //listBuffer删除元素 listBuffer -= 2 //删除2这个元素 listBuffer -= 1000 //如果删除的这个元素不存在，则不执行，也不会报错 listBuffer.remove(1) //删除下标为 1 的元素 listBuffer.remove(1,3) //从下标为 1 的元素开始，往后删除 3 个元素 println(listBuffer)

七.列表的其他操作 list.head //返回列表的第一个元素 list.tail //返回列表除第一个元素外的元素 list.isEmpty //判断列表是否为空，空true，非空false list.last //返回列表最后一个元素 list.init //返回列表除最后一个元素外的元素

队列(Queue)

一.队列的基本介绍 1.队列是一个有序列表，再底层可以用数组或链表来实现 2.其输出和输入要遵循先入先出的原则。即：先存入队列的数据先取出，后存入的数据后取出 3.在Scala中，由设计者直接给我们提供队列类型使用 4.在Scala中，由scala.collection.mutable.Queue 和 scala.collect.immutable.Queue 我们使用最多的是可变的队列

二.队列的创建 val queue = new mutable.Queue[Int] //Int为队列的泛型

三.队列添加元素 1.queue += 20 2.queue ++= list(2,3,4) //将列表中每个元素取出后加入队列 3.queue += list(2,3,4) //将list直接加入队列，前提是queue的泛型是Any

三.出入队列 1.（出队列）删除第一个元素并返回 queue.dequeue() 2.（入队列）在队尾添加元素 queue.enqueue(100,2,100) //元素是有序的，并且可以重复

四.返回队列中的元素 1.返回队列第一个元素 queue.head 2.返回队列最后一个元素 queue.last 3.返回队列尾部元素，返回的是一个队列，所以可以级联使用该方法（除了第一个元素，其他元素都返回） queue.tail queue.tail.tail

映射(Map)

Map的创建

一.回顾：Java中的Map的基本介绍 HashMap 是一个散列表（数组+链表），它存储的内容是键值对映射（key-value），key不能重复，Java中的Hash是无序的

二.Scala中的Map 1.Scala中的Map和Java类似，也是一个散列表，它存储的内容也是键值对（key-value）映射，Scala中不可变的Map是有序的，可变的Map是无序的 2.Scala中，有可变Map：scala.collection.mutable.Map 不可变Map：scala.collection.immutable.Map

三.构建不可变的Map //Map默认是不可变的 val map1 = Map("zhangsan" -> 10,"lisi" -> 18) //key-value的类型不做限制 小结 ①从输出结构看，输出顺序和声明顺序一致 ②构建Map集合中，集合中元素其实是Tuple2类型 ③默认情况下（即在没有引包），Map是不可变的

四.构建可变映射Map val map2 = mutable.Map("name" -> "zhangsan") 五.创建空的映射 val map3 = new scala.collection.mutable.HashMap[Any,Any] 六.对偶元组创建 val map4 = mutable.Map(("A",12),("B",18),("C",20)) 说明：即创建包含键值对的二元组，和第四种方式等价，只是形式上不同。对偶元组就是只包含两个数据的元组。

Map的操作

val map = mutable.Map("name"<- "张三","age" <- 18) 一.Map的取值（方式一) val value1 = map("name") print(value1) 说明：①如果key存在，则返回对应的值 ②如果key不存在，则会抛出异常【java.util.NoSuchElementException】。可以用map.contains("name")检查name是否存在 ③在Java中，如果key不存在则返回null 二.Map取值（方式二） map.get("name").get 说明：如果key存在，map.get("name")就会返回some，在用get方法就可以取出值；如果key不存在则会返回None 三.Map取值（方式三） map.getOrElse("name","默认值") //如果key存在，则返回对应的值，不存在则返回默认值 四.Map取值方式建议 1.如果确定map中有这个key，则使用map(key)，速度快 2.如果不确定map中是否有这个key，则使用map.contains(key)，可以加入逻辑 3.如果只是简单的希望得到一个值，使用map.getOrElse("Ip","127.0.0.1")

五.更新map中的元素 val map2 = mutable.Map("name"-> "张三","age" -> 18) map2("name")="王五" 说明：更新的前提是map是可变的，不然会报错；如果key存在则会修改，如果不存在则会添加一个key-value

六.增加map中的元素 map2 += ("D" -> 2) //添加单个元素，如果key已经存在，则会更新 map2 += ("C" -> 3,"E" -> 4) //添加多个元素 七.删除map中的元素 map2 -= ("D") //删除只需要写key map2 -= ("D","E") //可以同时删除多个key-value 说明：删除时只需要写key，可以同时删除多个；如果key存在则删除，不存在也不会报错

八.map的遍历 1.for((k,v) <- map2) println(k,v) //遍历map的key和value 2.for(k <- map2.keys) println(k) //只遍历map的key 3.for(v <- map2.values) println(V) //只遍历map的value 4.for(t <- map2) println(t) //遍历map结果以二元组的方式返回key-value，返回结果时Tuple2

集(Set)

一.集的基本介绍 集是不重复元素的集合。集不保留顺序，默认是以哈希集实现 二.回顾：Java中Set Java中，Hash是实现Set<E>接口的一个实现类，数据是以哈希表的顺序存放的，里面不能包含重复数据。Set接口是一个不包含重复数据的collection，HashSet中的数据也是没有顺序的 三.Scala中的Set说明 1.默认情况下，Scala使用的是不可变的集合，如果想使用可变的集合，需要引入scala.collection.mutable.Set包。 2.set(1) 可以判断元素 1 在集合中是否存在，存在返回true，不存在返回false

四.集Set的创建 1.创建不可变的集 val set = Set(1,2,3) //不需要引包，默认就是不可变的 2.可变集合的创建 import scala.collection.mutable.Set val mutable = mutable.Set(1,2,3)

五.可变集合元素的添加 set.add(4) //只有可变集才能添加元素，如果添加的元素重复也不会报错，但是不会添加 set += 8

六.可变集合元素的删除 set.remove(4) //集Set中可以根据值来删除，因为Set中的元素不重复 set -= 8 //如果删除的元素不存在，则不会报错。

七.Set的遍历 for(x <- set){ print(x) } 八.集合的其他操作 val set1 = Set(1,2,3,4) val set2 = Set(3,4,5,6) 1.求两个集合的并集（两个集合相加） val res1 = set1 ++ set2 2.求两个集合的交集（返回两个集合中都存在的元素） val res2 = set1.&(set2) //方法1 val res3 = set1.intersect(set2) //方法2

常用高阶函数

map映射操作

先看一个实际需求 要求：请将List(3,5,7) 中的所有元素都 * 2 ，将其结果放到一个新的集合中返回，即返回一个新的List(6,10,14), 请编写程序实现 传统方法 val list1 = List(3, 5, 7) var list2 = List[Int]() for (item <- list1) { //遍历 list2 = list2 :+ item * 2 } println(list2) 上面提出的问题，其实就是一个关于集合元素映射操作的问题。在Scala中可以通过map映射操作来解决：将集合中每一个元素通过指定功能（函数）映射（转换）成新的结果集合，这里其实就是所谓的将函数作为参数传递给另外一个函数，这就是函数式编程的特点 使用map完成上述操作：list2 = list1.map(_*2) 高阶函数：一个可以接受函数的函数 //创建一个高阶函数，即可以接收函数的函数 //f:Double => Double表示一个可以接收Double类型并返回Double类型的函数 //n1 代表test的形参 //= 表示返回的类型使用类型推导 //f(n1) 表示执行传入的函数 def test(f:Double => Double,n1 :Double)={ f(n1)

flatmap扁平化操作

flatmap映射：flat 即压扁 flatmap：就是集合中每个元素的子元素映射到某个函数并返回新的集合 val names = ListBuffer("Python","Scala","Java") def upper(s:String):String={ //接收一个字符串，将字符串字母全部变成大写后返回 s.toUpperCase } println(names.flatMap(upper)) //flatMap操作就是将集合中元素继续扁平化操作，即遍历所有元素

filter过滤

filter：将符合要求的数据（筛选）放置到新的集合中 应用案例： /* 将 val names = List("Alice", "Bob", "Nick") 集合中首字母为'A'的筛选到新的集合 */ val names = List("Alice", "Aob", "Nick") val res = names.filter(filter) println(res) def filter(s:String):Boolean={ s.startsWith("A") }

reduce化简

需求：val list = List(1,20,30,4,5) 求出list中元素之和 化简：将二元函数（接收两个参数的函数）引用于集合中的函数， 一.左化简reduceLeft 等价于 reduce val list = List(1, 20, 30, 4, 5) def sum(n1: Int, n2: Int): Int = { n1 + n2 } val res = list.reduceLeft(sum) println("res=" + res) 左化简说明： 1.reduceLeft(f) 接收的函数需要的形式为 op: (B, A) => B): B 2.reduceLeft(f) 的运行规则是从左边开始执行将得到的结果返回给第一个参数，然后和下一个元素运行，以此类推 3.化简流程(((1+20)+30)+4)+5 = 60 二.右化简reduceRight val list = List(1,2,3,4,5) def product(n1:Int,n2:Int): Int ={ println(n1-n2) n1-n2 } val res = list.reduceLeft(product) println(res) 右化简说明： 1.reduceRight(f) 的运行规则是从右边开始执行将结果返回给第二个参数，然后和下一个元素运算，以此类推 2.化简流程1-(2-(3-(4-5))) = 13

fold折叠

一.折叠的基本介绍 fold函数将上一步返回的值作为函数的第一个参数继续传递参与运算，直到list中的元素被遍历 1.可以把reduceLeft看做成简化版的foldLeft 操作代码 val list = List(2, 6, 3, 5, 9) //foldLeft()和reduceLeft()的运行机制几乎一样 //list.foldLeft(5)(function)可以理解为List(5 , 2, 6, 3, 5, 9)的reduceLeft操作 //就是将 5 放到list的第一个元素位置，再进行reduceLeft操作 //运行流程： // ((((5-2)-6)-3)-5)-9 val res1 = list.foldLeft(5)(function) //更多的时候5这个位置传的是一个函数 println(res1) //-20 折叠fold的简写 正斜杠 / 在哪边，就是哪边折叠 val list = List(2, 6) val res = (5 /: list) (function) //这种写法等价于 list.foldLeft(5)(function) println(res) //-3 val res2 =(list :\ 5) (function) //等价于 list.foldRight(5)(function) println(res2) //1 def function(n1: Int, n2: Int): Int = { n1 - n2 }

scan扫描

一.扫描的基本方式 扫描，即对某个集合中所有的元素做fold操作，但是会把产生的的所有中间结果放置于一个集合中保存 操作代码 val list = 1 to 5 //scan 扫描就是将集合中的每一个元素进行折叠操作，并将每个操作的结果放置再一个集合中 val res = list.scanLeft(8)(minux) println(res) //8,7,5,2,-2,-7 //scanRight跟折叠fold操作基本相同，只是返回的结果不一样 val res2 = list.scanRight(6)(minux) println(res2) //-3,4,-2,5,-1,6 def minux(n1:Int,n2:Int): Int ={ n1-n2 }

groupBy分组

一.基本介绍 groupBy会按照列表中的某个元素中某个字段进行分组。会返回一个Map映射，分组字段做为key，包含该字段的元素做为value 二.代码演示1 //将列表进行分组按照元素是否为 2 的倍数分组 val list = List(12,3,4,4,5,65,6,6,7,87,23) val res = list.groupBy(x => if(x%2==0) "2的倍数" else "不是2的倍数" ) println(res) 三.代码演示2 //将列表按照每个元素中的城市字段进行分组 val list = List[String]("70999,1371001,广东,广州,中国移动,020,510000", "71000,1371002,广东,广州,中国移动,020,510000", "71348,1371350,广东,深圳,中国移动,0755,518000", "71349,1371351,广东,深圳,中国移动,0755,518000") //将匿名函数传入到groupBy中 val res = list.groupBy(s => s.split(",")(3)) //当匿名函数的参数在 => 符号右边只出现一次时，可以将参数用下划线 _ 代替。如下： val res1 = list.groupBy(_.split(",")(3)) println(res1) //也可以将自己写的函数传入到groupBy中 val res2 = list.groupBy(MygroupBy) println(res2) def MygroupBy(string: String)={ //被分组的列表中有多少个元素，这个函数就会被调用多少次 //将列表中每个元素按 , 号分割成数组，然后取出该数组中下标为 3 的元素 string.split(",")(3) }

zip拉链

一.zip拉链的基本介绍 在开发中，当我们需要将两个集合进行对偶元组合并，可以使用拉链 val list1 = List(1,2,3) val list2 = List(4,5,6) val res = list1.zip(list2) //(1,4), (2,5), (3,6) println(res) 二.拉链的注意事项 1.拉链的本质就是两个集合的合并操作，合并后每一个元素是一个对偶元组 2.拉链操作就是将两个集合中的元素一一对应，再进行合并 3.如果两个集合元素的个数不对应，会造成数据丢失 4.集合不限于list，也可以是Array等 5.如果要取出合并后的各个对偶元组，可以进行遍历

集合基本操作

iterator迭代器

一.基本说明 通过iterator方法从集合获取一个迭代器，通过while或者for循环遍历 val array = Array(1,2,3,4,5).iterator println("=============while================") while (array.hasNext){ println(array.next()) } println("=============for================") for (item <- array){ println(item) }

stream流

一.基本说明 stream是一个集合。它可以存放无穷多个元素，但是这无穷多个元素并不会一次性生产出来，而是需要多大的区间，就会动态的产生，末尾元素遵循lazy规则（即：需要是，才计算） //创建一个流 def numForm(n:BigInt):Stream[BigInt]={n #:: numForm(n+1)} val stream = numForm(1) println(stream) //取出第一个元素 println(stream.head) println(stream.tail) 说明： 1.stream集合中存放的数据类型是BigInt 2.numForm是一个函数名，由程序员指定 3.创建的集合的第一个元素是n，后续生成的规则是n+1 4.后续元素生成的规则可以自行指定 5.使用tail方法就可以产生一个新的元素

view视图

一.基本介绍 stream的懒加载特性，也可以对其他集合应用view方法来得到类似的效果，具有如下特点： 1.view方法产生出一个总是被懒加载执行的集合 2.view不会缓存数据，每次都要重新计算，比如遍历view时。 val view = 1 to 100 val res = view.filter(eq) println(res) def eq(n:Int):Boolean={ n.toString.equals(n.toString.reverse) }

线程安全

一.所有线程安全的集合都是以synchronized开头的集合 SynchronizedBuffer SynchronizedMap SynchronizedPriorityQueue SynchronizedQueue SynchronizeSet SynchronizeStack 二.并行集合 1.Scala为了充分使用多核CPU，提供了并行集合（有别于前面的串行集合），用于多核环境的并行计算 2.主要用到的算法有：Divied and conquer(分治算法)，Scala通过splitters，combiners等抽象层来实现，主要原理是将计算工作分解成很多任务，分发给一些处理器去完成，并将它们处理的结果合并返回 3.Work stealin算法【学数学】，主要用于任务调度负载均衡（load-balancing），通俗点完成自己的所有任务之后，发现其他人还有活没干完，主动（或被安排）帮他人一起干，这样达到尽早干完的目的

三.使用并行模块 Scala 2.13之后，并行模块变成了外部库，和XML、Swing、parser-combinators等一样需要在maven项目的pom.xml中手动导入： <dependency> <groupId>org.scala-lang.modules</groupId> <artifactId>scala-parallel-collections_2.13</artifactId> <version>0.2.0</version> </dependency> 然后在代码文件中导入如下的包就行了： import scala.collection.parallel.CollectionConverters._ 参考链接：https://stackoverflow.com/questions/57287607/answer/submit[code=html] 四.基本案例 1.输出1-5 (1 to 5).foreach(println(_)) //单行操作 println() (1 to 5).par.foreach(println(_)) //并行操作 2.查看并行集合中元素访问的线程 val result1 = (0 to 100).map{case _ => Thread.currentThread.getName} val result2 = (0 to 100).par.map{case _ => Thread.currentThread.getName} println(result1) println(result2)

操作符

一.操作符扩展 1.如果想在变量名，类名等定义中使用语法关键字（保留字），可以配合反引号`` val`val`=42 2.中置操作符：A操作符B (等同于) A.操作符(B)

Scala模式匹配（重要）

模式匹配初体验

Scala中的模式匹配类似于Java中的switch语法，但是更加强大

模式匹配语法中，采用match关键字声明，每个分支采用case关键字进行声明， 当需要匹配时，会从第一个case分支开始，如果执行成功，就会执行相应的逻辑代码，同时终止； 如果不匹配，则继续执行下一个分支case。 如果所有的case都不匹配，那么会执行case_分支，类似于Java中default

二.代码案例 val oper = '#' val n1 = 20 val n2 = 10 var res = 0 oper match { /* 1.match类似于Java的switch， 2.如果匹配成功，则会执行=> 后面的代码块 3.匹配顺序是从上往下 4.=>后面的代码块不需要写break，因为match会自动退出 5.如果所有的case都不匹配，则会执行case_后的代码块 6.如果所有的case都不匹配，并且没有case_，则会抛出异常MatchError 4.可以再match中使用其他类型，不仅仅是Char */ case '+' => res = n1 + n2 case '-' => res = n1 - n2 case '*' => res = n1 * n2 case '/' => res = n1 / n2 case _ => println("oper error") } println("res=" + res)

模式匹配扩展

条件守卫

一.基本介绍 如果想要表达匹配某个范围的数据，就需要再模式匹配中增加条件守卫 for (ch <- "+-3!") { var sign = 0 var digit = 0 ch match { case '+' => sign = 1 case '-' => sign = -1 // 说明case _ if表示条件守卫，这里的下划线 _ 表示不接收ch case _ if ch.toString.equals("3") => digit = 3 case _ => sign = 2 } println(ch + " " + sign + " " + digit) }

模式匹配中的变量

二.模式中的变量 如果在case关键字后跟变量名，那么match前表达式的值会赋给那个变量 val ch = 'V' ch match { case '+' => println("ok~") case mychar => println("ok~" + mychar) case _ => println ("ok~~") }

声明变量中的匹配

一.基本介绍 match中每一个case都可以被单独提取出来，意思和case中的一样 二.应用案例 val (x,y) = (1,2) val (q,r) = BigInt(10) /% 3 //将BigInt(10) / 3 赋值给 q ，将BigInt(10) % 3 赋值给r val arr = Array(1,2,34,4,5) val Array(first,second,_*) = arr //表示取出arr中的前两个元素，并且赋值给first，second

for循环中的模式匹配

一.基本介绍 for循环中也可以进行模式匹配 val map = Map("A" -> 1,"B" -> 2,"C" -> 3) for ((k,v) <- map){ //for表达式中也可以使用模式匹配 println(k,v) } for ((k,2) <- map){ //这里表示遍历出value为 2 的键值对，其他的过滤 println(k,2) } for ((k,v) <- map if v==3){ //这里使用的for循环守卫 println(k,v) }

匹配数组

一.基本介绍 1.Array(0) 匹配只有一个元素且为0 的数组 2.Array(x,y) 匹配数组有两个元素，并将两个元素赋值给x y。当然可以以此类推，赋值给三个值x y z 3.Array(0._*) 匹配数组从0开始到最后一个元素 val arrs = Array(Array(0),Array(1,2),Array(0,2,3),Array(2,3,4,5,6)) for (item <- arrs){ val res = item match{ case Array(0) => '0' case Array(x,y) => x+"+"+y case Array(0,_*) => "一零开头的数组" case _ => "什么都不是" } // 0 // 1+2 // "一零开头的数组" // "什么都不是" println(res)

匹配列表

匹配列表和匹配数组基本类似  val lists = Array(List(1),List(1,2),List(1,2,3,4,3,34),List(0,2,3)) for (item <- lists){ val res = item match{ case 1::Nil => "1" case x::y::Nil => x+"+"+y case 1::tail => "1....." case _ => "asdasdasd" } println(res)

匹配元组

val tuple = Array((0,1),(1,0),(1,1),(1,0,2)) for (item <- tuple){ val res = item match{ case (0,_) => "0...." case (x,0) => x case _ => "asdasdsa" } println(res )

样例类

一.基本介绍 1.样例类仍然是类 2.样例类用case关键字进行声明 3.样例类是为模式匹配而优化的类 4.构造器中的每一参数都成为了val，除非显示的声明var (不推荐) 5.在样例类对应的伴生对象中存在apply方法，可以是在实例化时不使用new关键字，就可以直接构造出对象 6.也提供unapply方法，让模式匹配可以正常的工作 7.将自动生成toString，equal，hashCode和copy方法（有点类似模板类，直接生成使用） 8.除了上述外，样例类和其他类完全一样，可以添加字段和方法

二.样例类的基本写法 abstract class Amount case class Dollar(n:Int) extends Amount //这里的形参会在底层被声明成val case class Currency(n:Int,s:Stirng) extends Amount case Object NoAmount extends Amount ①样例类的使用案例一 val arr =Array(Dollar(1000),Currency(5000,"RMB"),noAmcount) for (item <- arr){ val res = item match { //样例类会自动创建unapply方法，会将创建对象传入的参数提取出来 case Dollar(n) => "$"+n case Currency(k,v) => k+" "+v case _ => "sdfasdf" } println(res) } ②样例类的使用案例二 val amt = Currency(1500,"RMB") val amt2 = amt.copy() //利用amt对象copy一个新的对象 println(amt.n,amt2.s) //样例类会将形参创建成一个可读不可写的属性，所以可以访问读取 val amt3 = amt.copy(n=1800) //copy时也可以指定参数 println(amt3) //这里可以直接数据对象的属性，因为底层有toString方法

匹配样例类

一.基本介绍 1.case中对象的unapply方法（提取器）返回Some集合则为匹配成功 2.返回None则为匹配失败

二.基本案例 object Square{ //对象提取器，它会提取出创建对象时传入的参数 //简单来说，unapply就是逆向拆解对象 def unapply(z:Double): Option[Double] = { println("unapply方法被调用，z= "+z) Some(math.sqrt(z)) } def apply(z: Double): Double = z*z val number:Double=36 number match { /* Square(n)运行机制 1.当匹配到case Square(n)时， 2.会先调用Objeck Square中unapply(z:Double)方法，传入的 z 值就是number 3.如果对象提取器返回的值时Some(6)则表示提取成功，同时将 6 赋值给 n ,最后将 n 输出 */ case Square(n) => println("匹配成功 "+n) case _ => println("asdadsa") }

三.小结 1.构建对象时，apply方法方法会被调用，比如 val n = Square(6) 2.当Square(n)写再case后面时，即【case Square(n) => xxx】，会默认调用unapply方法（对象提取器） 3.number会被传递给def unapply(z:Double) 的形参 z 4.如果返回unapply方法返回的时Some，则会将结果传递给Square(n)中的 n 5.case中对象的unapply方法（提取器）返回的时Some则匹配成功，为None则匹配失败

匹配嵌套结构

一.基本介绍 操作原理类似于正则表达式 三.最佳实践案例-商品捆绑打折出售 现在有一些商品，请使用Scala设计相关的样例类，完成商品捆绑打折出售。要求商品捆绑可以是单个商品，也可以是多个商品。打折时按照折扣x元进行设计.能够统计出所有捆绑商品打折后的最终价格

① //设计样例类 abstract class Item case class Book(desc:String,price:Double) extends Item //discount表示优惠的金额 case class Bundle(desc:String,discount:Double,item: Item*) extends Item ②三个知识点 val sale = Bundle("书籍",10,Book("漫画",40),Bundle("文学书籍",20,Book("阳关",80),Book("围城",30))) //知识点一：取出漫画二字 val res = sale match { case Bundle(_,_,Book(desc,_),_*) => desc } println(res) //知识点二(@表示法)：取出漫画二字，和后面所以的内容，并存放到元组中。_*表示匹配多个Bundle val res2 = sale match { case Bundle(_,_,Book(desc,_),b @ _*) => (desc,b) } println(res2) //知识点三：取出漫画二字，和后面的Bundle对象。 //说明因为没有使用 _* 即明确说明没有多个Bundle,所以返回的rest，就不是ArraySeq了。 val res3 = sale match { case Bundle(_,_,Book(desc,_),rest) => (desc,rest) } println(res3) ③实现项目 def price(it: Item): Double ={ it match { case Book(_,p) => p case Bundle(_,disc,its @ _*) => its.map(price).sum - disc } println(price(sale))

密封类

一.基本介绍 1.如果想让case类的所有子类都必须在申明该类的相同源文件中定义，可以将样例类通过超类声明为sealed，这个超类就成为了密封类 2.密封类就是不能在其他文件中定义子类

Scala函数式编程高级

偏函数

偏函数的引出

一.先看一个需求 给你一个集合val list = List(1, 2, 3, 4, "abc") ，请完成如下要求: 将集合list中的所有数字+1，并返回一个新的集合 要求忽略掉非数字的元素，即返回的新的集合形式为 (2, 3, 4, 5) 解决方案 //思路一：使用filter-map val list = List(1, 2, 3, 4, "12123") val res = list.filter(fun1).map(fun3).map(fun2) println(res) //思路二：模式匹配 val res2 = list.map(fun4) println(res2) def fun1(n:Any): Boolean ={ n.isInstanceOf[Int] } def fun2(n:Int):Int={ n+1 } def fun3(n:Any): Int ={ n.asInstanceOf[Int] } def fun4(n:Any):Any={ n match { case n:Int => n+1 case _ => }

偏函数介绍

一.基本介绍 1.在对某个集合进行处理时，其中有些元素不符合处理条件，这时就可以使用偏函数 2.将函数中封装了一组case语句的函数，叫做偏函数。它只会对作用于指定类型的参数或者指定范围的参数实施计算，超出范围的值会另外处理 3.偏函数在Scala中是一个特质PartialFunction

二.代码演示 val list = List(1, 2, 3, 4, "12123") //创建一个偏函数 //1.PartialFunction[Any,Int]表示偏函数接收一个Any类型的值，返回一个Int类型的值 //2.isDefinedAt(x: Any)这个方法如果返回true，则会调用apply方法，否则不会调用apply方法 //3.apply方法相当于创建一个对象，对传入的值+1，然后返回 val unit = new PartialFunction[Any, Int] { override def isDefinedAt(x: Any): Boolean = x.isInstanceOf[Int] override def apply(x: Any): Int = x.asInstanceOf[Int] + 1 } val res = list.collect(unit) println(res)

三.偏函数小结 1.偏函数是使用构建特质的实现类（使用方式是PartialFunction的匿名子类） 2.PartialFunction是个特质 3.构建偏函数时，参数形式[Any,Int]是泛型，第一个表示输入参数的类型，第二个是返回参数的类型 4.当使用偏函数时，会遍历集合中的所有元素，编译器执行流程会先执行isDefinedAt()，如果返回true，则会调用apply方法，构建一个新的Int对象返回 5.执行isDefinedAt() 为false，则会过滤这个元素，即不会构建新的Int对象 6.map函数不支持偏函数，因为map底层的机制就是所有元素循环遍历，无法过滤原来集合的元素 7.collect函数支持偏函数，多用于偏函数的使用

偏函数的化简形式

偏函数的简化形式一 声明偏函数，需要重写特质中的方法，有时候会很麻烦，而Scala提供了简单的方法 implicit def dataCon(n:Double):Int={ //创建一个隐式转换函数 n.toInt } //偏函数的简化形式 def parFun:PartialFunction[Any,Int]={ case n:Int => n+1 //利用模式匹配 case n:Double => n*2 //这里运用了隐式转换将Double转成了Int } val list = List(1,2,3,4,2,2,3,4,"hello") val res = list.collect(parFun) println(res) }

偏函数的简化形式二 这种方式不能指定传入值的类型和返回值的类型，只能使用默认的 //偏函数的简化形式二 val res2 = list.collect{ case n:Int => n+1 case n:Double => n*2 } println(res2)

做为参数的函数

一.基本介绍 函数作为一个变量传入到了另一个函数中，那么这个作为参数的函数的类型是function1，即：（参数类型） => 返回类型 二.代码演示 def plus(n:Int): Int ={ n+3 } val list = List(1,2,3,4) val res = list.map(plus(_)) println(res.mkString(",") 三.小结 1.map(plus(_))中的plus(_)就是将plus这个函数当做一个参数传给map，_代表从集合中遍历出来的每一个元素 2.plus(_)这里也可以写成plus表示对List(1,2,3,4)的遍历，将每次遍历的元素传给puls的n 3.进行n+3的运算后，返回新的Int，并加入到新的集合中result1中 4.def map[B,That](f:A=>B) 的声明中的f:A=>B是一个函数

匿名函数

基本介绍

一.基本介绍 没有名字的函数就是匿名函数，可以通过函数表达式来设置匿名函数 二.代码演示 val res = (n:Int) => n+3 println(res(2)) 三.小结 1.不需要写def函数名 2.不需要写返回值类型，因为默认使用类型推导 3.如果代码块有多行，就使用{}

匿名函数的简写（参数类型推断）

一.基本介绍 参数推断省去类型信息（在某些情况下【需要有应用场景】），参数类型可以推断出来，如list=(1,2,3) list.map() map中函数参数类型是可以推断出来的，同时也可以进行参数的简写 二参数类型推断的写法说明 1.参数类型是可以推断出来的，可以省略参数类型 2.当传入的函数，只有单个参数时，可以省去括号 3.如果变量只在 => 右边只出现一次，可以用 _ 代替

三.匿名函数的简化写法一（map） val list = List(1,2,3,4) //原始写法，将list列表中每个元素加 1 之后返回到一个新列表中 val res1 = list.map((n:Int)=>n+1) //传入一个匿名函数到map函数中 println(res1) //简化1 ：因为list列表中的元素都是Int,使用匿名函数的形参的类型就可以使用类型推断 //这时就可以省略Int val res2 = list.map(n=>n+1) println(res2) //简化2 ：如果变量在 => 右边只出现了一次，这时可以将变量写成下划线 _ val res3 = list.map(_+1) println(res3)

四.匿名函数的简化写法二（reduce） //原始写法，将list列表中的每个元素相加，并返回结果 val reduceRes1 = list.reduce((x:Int,y:Int)=>x+y) println(reduceRes1) //简化1 ：因为形参的类型可以根据list元素的类型进行推断，所以Int可以省略 val reduceRes2 = list.reduce((x,y)=>x+y) println(reduceRes2) //简化2 ：因为变量在 => 的右边只出现一次，所以变量x y可以用下划线 _ 表示 val reduceRes3 = list.reduce(_+_) println(reduceRes3) }

高级函数

一.基本介绍 可以传入函数的函数就作高阶函数，在某些情况下也可以返回一个函数

二.代码演示 //定义一个高阶函数 def test(f:Double => Double,n:Double): Double ={ f(n) } val res = test((n:Double) => n+n,6) println(res)

三.高阶函数返回函数类型 //创建一个高阶函数，它可以返回一个匿名函数 def test(n:Int) ={ (m:Int) => n-m } //调用这个高阶函数 //分步骤操作 val f1 = test(2) //这里会将2传递给 n ，即返回的结果是 (m:Int) =>2-m 是一个匿名函数 println(f1(4)) //这里会将4 传递给 m ,即会返回 2-4 = -2 //可以将上面的分步操作一次性完成 val res = test(3)(7) println(res) }

闭包

一.基本介绍 闭包（closure）就是一个函数和与其相关的引用环境组合的一个整体（实体）。

二.代码演示 def test(n:Int) ={ (m:Int) => n-m } //调用这个高阶函数 //分步骤操作 val f1 = test(2) //这里会将2传递给 n ，即返回的结果是 (m:Int) =>2-m 是一个匿名函数 println(f1(4)) //这里会将4 传递给 m ,即会返回 2-4 = -2 //可以将上面的分步操作一次性完成 val res = test(3)(7) println(res)

三.代码小结 1.test函数返回的是 (m:Int) => n-m 匿名函数，因为该函数引用到了函数外的变量 n ，那么该函数和 n 整体形成了一个闭包。val f1 = test(2)这里的f1就是一个闭包 2.可以这样理解，返回函数是一个对象，而n就是该对象的一个字段，它们共同形成了一个闭包 3.当多次调用f1时（可以理解多次调用闭包），发现使用的是同一个n ，所以 n 不变 4.当使用闭包时，主要搞清楚返回函数引用了函数外的哪些变量，因为它们组合成了一个整体（实体），形成了一个闭包

四.添加后缀名的案例 object clusureDemon { def main(args: Array[String]): Unit = { val f = makeSuffix(".jpg") println(f("scala")) //scala.jpg println(f("python.jpg")) //python.jpg } /* 传入一个文件名，如果这个文件名带有后缀名，那么直接返回； 如果这个文件名没有后缀名，则为它添加一个后缀名并返回 */ def makeSuffix(suffix:String) ={ (fileName:String) => { if (fileName.endsWith(suffix)) fileName else fileName+suffix } } } 五.闭包的好处 1.返回的匿名函数和 test(n:Int) 的 n 变量组合成了一个闭包，因为返回的函数要引用 n 这个变量 2.可以反复引用上一次传入的值

函数柯里化

一.基本介绍（curry） 1.函数编程中，接收多个参数的函数都可转换成接收一个参数的函数，这个转换过程就是函数柯里化 2.柯里化就是证明了函数只需要一个参数而已。在前面的学习中也用到了函数柯里化 3.柯里化是面向函数思想的必要产生结果

二.代码演示 编写一个函数，接收两个整数，可以返回两个数的乘积，要求: 1.使用常规的方式完成 2.使用闭包的方式完成 3.使用函数柯里化完成 //常规方式 def fun1(x:Int,y:Int): Int ={ x*y } //闭包方式（使用匿名函数） def fun2(x:Int) ={ (y:Int) => x*y } //函数柯里化方式 def fun3(x:Int)(y:Int): Int ={ x*y println(fun1(2,3)) //调用普通函数 println(fun2(2)(5)) //调用闭包函数 println(fun3(2)(7)) //调用柯里化函数

三.案例 /* 比较两个字符串在忽略大小写的情况下是否相等，注意，这里是两个任务： 全部转大写（或小写） 比较是否相等 针对这两个操作，我们用一个函数去处理的思想，其实也变成了两个函数处理的思想（柯里化） */ def eq(s1:String,s2:String): Boolean ={ s1.equals(s2) } //创建一个隐式类，用来增加集合的操作方法 implicit class TestEq(s:String){ def checkEq(ss:String)(f:(String,String) => Boolean): Boolean ={ //函数柯里化的方式 f(s.toLowerCase(),ss.toLowerCase()) } } val str = "hello" val res = str.checkEq("HELLO")(eq) println(res) //方式二，直接传入一个匿名函数，并利用类型推断简写这个匿名函数 val res2 = str.checkEq("Hello")(_.equals(_)) println(res2)

控制抽象

一.基本介绍 控制抽象是这样的函数 1.参数是函数 2.函数参数没有输入值也没有返回值

二.代码演示 //像这样，参数是函数，函数没有输入值也没有返回值的函数，就是控制抽象 def myRun(f:()=>Unit): Unit ={ new Thread{ override def run(): Unit = { f() } }.start() } myRun { //这里就是调用myRun这个函数 () => //这里表示没有传入参数也没有返回值 println("开始干活！") Thread.sleep(5000) println("干完了") } 三.案例 /* 利用控制抽象写出until函数，实现一下代码 var n = 10 while (n > 0){ n -= 1 println(n) } */ var x = 10 until(x > 0){ x -= 1 println(x) } //创建一个控制抽象函数，这里也用到了函数柯里化 def until(f1: => Boolean)(f2: => Unit): Unit = { if (f1){ f2 until(f1)(f2) }

泛型、泛型上下界、视图界定、上下文界定、逆变|协变|不可变（重要）

泛型

一.基本介绍 1.如果我们要求函数的参数可以接受任意泛型。可以使用泛型，这个类型可以代表任意的数据类型。 2.例如List，在创建List时，可以传入整型，字符串，浮点数等等任意类型。那是因为List在类定义时引用了泛型。

代码示例

//Scala的泛型和java类似, 但是功能远比Java的泛型强大 object GenericDemo01 {   def main(args: Array[String]): Unit = {     val msg1 = new StringMessage[String]("10")     val msg2 = new IntMessage[Int](2)     println(msg1.get)     println(msg2.get)   } } /* 要求: 编写一个Message类 可以构建Int类型的Message和String类型的Message. 要求使用泛型来完成设计,(说明：不能使用Any) scala的泛型就是中括号 */ abstract class Message[T](value: T) {   def get = value } class StringMessage[String](msg: String) extends Message(msg) class IntMessage[Int](msg: Int) extends Message(msg)

泛型上界

Java上界

在Java泛型里表示某个类型是A类型的子类型，使用extend关键字，这种形式叫upper bounds（上线或上界）语法如下： <T extend A> //使用通配符的形式 <? extends A>

Scala上界 在Scala里表示某个类型是A类型的子类型，也称上限或者上界。使用<:关键字。语法如下 [T <: A] //使用通配符 [_ <: A]

代码示例

//java中上界 //在 Java 泛型里表示某个类型是 A 类型的子类型，使用 extends 关键字，这种形式叫 upper bounds(上限或上界)，语法如下: <T extends A> //或用通配符的形式: <? extends A> object UpperBoundsDemo01 {   def main(args: Array[String]): Unit = {     //1. 第一种方法     println("传统方法: " + new CompareInt(1, 2).greater)     //2. 第二种方法     //这里必须要使用Java的Integer。因为Integer实现了Comparable接口     println("通用方法: " + new CommonCompare[Integer](Integer.valueOf(1), Integer.valueOf(2)).greater)     //这里使用了隐式转换     //3. 第三种方法     //implicit def float2double(x: Float): Double = x.toDouble     val commonCompare3 = new CommonCompare[java.lang.Float](10.1f, 10.2f)     println(commonCompare3.greater)   } } /* scala中上界应用案例-要求 编写一个通用的类，可以进行Int之间、Float之间、等实现了Comparable接口的值直接的比较.//java.lang.Integer 分别使用传统方法和上界的方式来完成，体会上界使用的好处. */ //传统方法 class CompareInt(n1: Int, n2: Int) {   def greater = if (n1 > n2) n1 else n2 } //scala的泛型上界 //说明 //1. [T <: Comparable[T]] 表示T是Comparable的子类 //2. T必须要实现Comparable接口 //3. T可以使用compareTo方法 //4. 这样写通用性更好 //5. 通配符的形式: [_ <: Comparable[_]] class CommonCompare[T <: Comparable[T]](n1: T, n2: T) {   def greater = if (n1.compareTo(n2) > 0) n1 else n2 }

泛型下界

Java下界

在Java中泛型里表示某个类型是A类型的父类型，使用super关键字 <T super A> //使用通配符 <? super A>

Scala下界 在Scala中下界，使用 >: 关键字 [T >: A] //表示T的下界是A //使用通配符 [_ >: A]

代码示例

//Java中下界 //在 Java 泛型里表示某个类型是 A类型的父类型，使用 super 关键字。<T super A> //或用通配符的形式： <? super A> //scala中下界 //在 scala 的下界或下限，使用 >: 关键字，语法如下：[T >: A] //或用通配符:[_ >: A] //scala使用下界小结 //对于下界，可以传入任意类型 //传入和Animal直系的，是Animal父类的还是父类处理，是Animal子类的按照Animal处理 //和Animal无关的，一律按照Object处理 //也就是下界，可以随便传，只是处理是方式不一样, 编译器也不会报错, 是可以执行的, 只是丢失了泛型信息 //不能使用上界的思路来类推下界的含义 object LowerBoundsDemo1 {   def main(args: Array[String]): Unit = {     biophony(Seq(new Earth, new Earth)).foreach(_.sound())     biophony(Seq(new Animal, new Animal)).foreach(_.sound())     biophony(Seq(new Bird, new Bird)).foreach(_.sound())     val res = biophony(Seq(new Bird))     val res2 = biophony(Seq(new Object))     val res3 = biophony(Seq(new Moon))     println("res = " + res)     println("res2 = " + res2)     println("res3 = " + res3)   }   def biophony[T >: Animal](things: Seq[T]) = things } class Earth { //Earth 类   def sound(){ //方法     println("hello !")   } } class Animal extends Earth{   //重写了Earth的方法sound()   override def sound() ={     println("animal sound")   } } class Bird extends Animal{   //将Animal的方法重写   override def sound()={     println("bird sounds")   } } class Moon

Scala下界使用小结 ①对于下界，可以传入任意类型 ②传入和A直系的，是A父类就按照A父类处理，如果是A的子类，则按照A处理 ③如果传入的对象与A无关，一律按照Object处理 ④也就是说下界可以随便传，只是处理方式不一样 ⑤不能使用上界的思路来类推下界的含义

逆变、协变和不可变

一.基本介绍 1.Scala的协变(+)，逆变(-)，协变covariant、逆变contravariant、不可变invariant 2.对于一个带类型参数的类型，比如 List[T]，如果对A及其子类型B，满足 List[B]也符合List[A]的子类型，那么就称为covariance(协变) ，如果 List[A]是 List[B]的子类型，即与原来的父子关系正相反，则称为contravariance(逆变)。如果一个类型支持协变或逆变，则称这个类型为variance(翻译为可变的或变型)，否则称为invariance(不可变的) 3在Java里，泛型类型都是invariant，比如 List<String> 并不是 List<Object> 的子类型。而Scala支持，可以在定义类型时声明(用加号表示为协变，减号表示逆变)，如: trait List[+T] // 在类型定义时声明为协变这样会把List[String]作为List[Any]的子类型。

二.应用实例 在这里引入关于这个符号的说明，在声明Scala的泛型类型时，“+”表示协变，而“-”表示逆变  C[+T]：如果A是B的子类，那么C[A]是C[B]的子类，称为协变  C[-T]：如果A是B的子类，那么C[B]是C[A]的子类，称为逆变  C[T]：无论A和B是什么关系，C[A]和C[B]没有从属关系。称为不变. val t: Temp[Super] = new Temp[Sub]("hello world1") class Temp3[A](title: String) { //Temp3[+A] //Temp[-A] override def toString: String = { title }} //支持协变 class Super class Sub extends Super

代码示例

//协变、逆变、不变 //Scala的协变(+)，逆变(-)，协变covariant、逆变contravariant、不可变invariant //对于一个带类型参数的类型，比如 List[T]，如果对A及其子类型B，满足 List[B]也符合List[A]的子类型，那么就称为covariance(协变)，如果 List[A]是 List[B]的子类型，即与原来的父子关系正相反，则称为contravariance(逆变)。如果一个类型支持协变或逆变，则称这个类型为variance(翻译为可变的或变型)，否则称为invariance(不可变的) //在Java里，泛型类型都是invariant，比如 List<String> 并不是 List<Object> 的子类型。而scala支持，可以在定义类型时声明(用加号表示为协变，减号表示逆变)，如:traitList[+T]//在类型定义时声明为协变这样会把List[String]作为List[Any]的子类型。 //在这里引入关于这个符号的说明，在声明Scala的泛型类型时，“+”表示协变，而“-”表示逆变 //C[+T]：如果A是B的子类，那么C[A]是C[B]的子类，称为协变 //C[-T]：如果A是B的子类，那么C[B]是C[A]的子类，称为逆变 //C[T]：无论A和B是什么关系，C[A]和C[B]没有从属关系。称为不变. object Demo01 {   def main(args: Array[String]): Unit = {     //不变     val t1: Temp3[Sub] = new Temp3[Sub]("abc") //ok     //    val t2: Temp3[Sub] = new Temp3[Super]("abc") //error //    val t3: Temp3[Super] = new Temp3[Sub]("abc") //error     val t4: Temp3[Sub] = new Temp3[Sub]("abc") //ok     //协变     val t5: Temp4[Super] = new Temp4[Sub]("abc") //ok     val t6: Temp4[Sub] = new Temp4[Sub]("abc") //ok     //逆变     val t7: Temp5[Sub] = new Temp5[Sub]("abc") //ok     val t8: Temp5[Sub] = new Temp5[Super]("abc") //ok //    val t9: Temp5[Super] = new Temp5[Sub]("abc") //error   } } //协变 class Temp4[+A](title: String) {   override def toString = title } //逆变 class Temp5[-A](title: String) {   override def toString = title } //不变 class Temp3[A](title: String) {   override def toString = title } class Super class Sub extends Super

视图界定

视图界定(View Bounds) <% 的意思是“view bounds”(视界)，它比<:适用的范围更广，除了所有的子类型，还允许隐式转换类型。 def method[A <% B](argList): R = ... 等价于: def method[A](argList)(implicit viewAB: A => B): R = ... 并且在调用的地方必须存在相应的隐式转换 A => B 或等价于: implicit def conver(a:A): B = … <% 除了方法使用之外，class 声明类型参数时也可使用： class A[T <% Int]

代码示例

object ViewBoundsDemo01 {   def main(args: Array[String]): Unit = {     val value = new CompareComm11(10, 20)     println(value.greater)   } } /**  * 视图界定已经过期了, 推荐使用隐式参数的方式, 科里化的方式写隐式参数  */ class CompareComm11[T <% Comparable[T]](obj1: T, obj2: T) { //等价于下面的写法。其中(implicit ev$1: T => Comparable[T])是柯里化的写法。 //ev$1 可以任意写, 是函数名 //class CompareComm11[T](obj1: T, obj2: T)(implicit ev$1: T => Comparable[T]) {   def greater = if (obj1.compareTo(obj2) > 0) obj1 else obj2 }

高版本的Scala已经废弃

上下文界定

与view bounds一样, context bounds(上下文界定)也是隐式参数的语法糖 为语法上的方便，引入了"上下文界定"这个概念

代码示例

object ContextBoundsDemo01 {   implicit val personComparetor = new Ordering[Person] {     override def compare(p1: Person, p2: Person): Int =       p1.age - p2.age   }   def main(args: Array[String]): Unit = {     val p1 = new Person("mary", 30)     val p2 = new Person("smith", 35)     val compareComm4 = new CompareComm4(p1,p2)     println(compareComm4.geatter)     val compareComm5 = new CompareComm5(p1,p2)     println(compareComm5.geatter)     val compareComm6 = new CompareComm6(p1,p2)     println(compareComm6.geatter)   } } //这里需要对[T: Ordering]进行说明。 //1. 和之前的泛型上下界、视图界定不同。这里的泛型T和Ordering之间没有T必须是Ordering的子类或者是父类 //2. 会自动添加一个隐式转换参数。(implicit comparetor: Ordering[T]), 存在着需要将T => Ordering[T]的隐式转换 //3. 并且调用CompareComm6方法时必须有一个可用的隐式值Ordering[T]存在 //方式1。 class CompareComm4[T: Ordering](obj1: T, obj2: T)(implicit comparetor: Ordering[T]) {   def geatter = if (comparetor.compare(obj1, obj2) > 0) obj1 else obj2 } //方式2,将隐式参数放到方法内 class CompareComm5[T: Ordering](o1: T, o2: T) {   def geatter = {     def f1(implicit cmptor: Ordering[T]) = cmptor.compare(o1, o2)     if (f1 > 0) o1 else o2   } } //方式3,使用implicitly语法糖，最简单(推荐使用) class CompareComm6[T: Ordering](o1: T, o2: T) {   def geatter = {     //这句话就是会发生隐式转换，获取到隐式值 personComparetor     //在隐式转换的作用域中必须存在Ordering[T]这样的隐式值     //从上线文中获取对应的隐式参数     val comparetor = implicitly[Ordering[T]]     println("CompareComm6 comparetor" + comparetor.hashCode())     if (comparetor.compare(o1, o2) > 0) o1 else o2   } } //一个普通的Person类 class Person(val name: String, val age: Int) {   override def toString = this.name + "\t" + this.age }

Scala中常用特殊符号（重要）