Scala 04 —— Scala Puzzle 拓展

Scala 04 —— Scala Puzzle 拓展

一、占位符

val list1:List[Int] = List(1,2,3).map(_ + 1)
val list2:List[Int] = List(1,2,3).map(r => r + 1)
1
2

在上面的例子中，两代码的返回结果其实是一样的，都是 List(2,3,4),而在第一行中的 _叫做占位符，可以让我们的代码更加简洁 但是这并不意味着使用 _ 和箭头函数是同样的结果

val list1:List[Int] = List(1,2,3).map{println("ss");_ + 1}
val list2:List[Int] = List(1,2,3).map{r => println("ss");r + 1}
1
2

在上面的代码中，看起来运行的结果还是一样的，但是事实却不是这样的，当然 list1 和 list2的返回值是一样的，但是执行的过程中打印的结果却是不一样的， 第一行代码打印了一行 ss，第二行代码打印了三行 ss

为什么会有这样的不同？

Map函数的本质是对每个集合中的元素应用一个函数，第一个语句中函数的执行体只是_+1，第二个语句中函数的执行体是println("ss");r + 1。

二、模式匹配的变量和常量模式

• 变量模式：模式匹配的标识符是小写字母，作用是赋值

  val (x,y) = (1,2)
  1

• 常量模式：模式匹配的标识符是大写字母，该常量必须是已赋值的，否则会报错，作用是判断

  val (X,Y) = (1,2)// 报错
  x match {
    case PI => "圆周率"
  }
  1
  2
  3
  4

三、继承 成员声明的位置

trait A{
  val audience:String
  println("Hello " + audience)
}
class BMember (a:String = "World") extends A{
  override val audience: String = a
  println("I repeat:Hello " + audience)
}

class BConstructor(val audience:String = "World") extends A{
  //该种方法声明的变量不会存在null的情况
  println("I repeat:Hello " + audience)
}
new BMember("reader")
new BConstructor("reader")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

结果

Hello null
I repeat:Hello reader
Hello reader
I repeat:Hello reader
1
2
3
4

初始化顺序分析

BMember 类

1. 调用构造器：当创建 BMember 的实例时，首先初始化父类 A。
2. 父类 A 的初始化：在 Scala 中，父类的构造代码块（包括字段的初始化和任何其他语句）首先被执行。在 A 中，audience 还未被 BMember 初始化，因此其值为 null（String 类型的默认值）。
3. 打印语句执行：打印 "Hello " + audience，由于 audience 还是 null，输出 Hello null。
4. 子类 BMember 的字段初始化：初始化 audience 为传入的参数 "reader"。
5. 子类中的打印语句：接着执行 BMember 中的打印语句，输出 "I repeat: Hello reader"。

BConstructor 类

1. 构造器参数：在 BConstructor 类中，audience 是通过构造器参数直接定义的。这意味着在调用父类 A 的构造器之前，audience 已经被初始化。
2. 父类 A 的初始化：由于 audience 已经初始化为 "reader"，当父类 A 中的打印语句执行时，输出 "Hello reader"。
3. 子类中的打印语句：紧接着在 BConstructor 中，再次打印 "I repeat: Hello reader"。

总结：

一般来说，子类在初始化时会先初始化父类构造器构造出父类对象，因为子类可能有依赖于父类对象的属性或方法。

作为类字段被赋值，在父类构造器执行后才初始化；作为构造参数被赋值，在父类构造器执行前初始化。

四、缺省初始值与重载

trait A {
  val foo: Int //缺省初始值，Boolean缺省初始值是false，Unit缺省初始值是()
  def bar: Int = 10 //附初值的变量后面只能用override
  println(s"In A:foo=$foo,bar=$bar") //0,0,0
}

class B extends A {
  val foo: Int = 25
  println(s"In B:foo=$foo,bar=$bar") //25,36,0

}
class C extends B {
  override val foo: Int = 46 //当一个val被重载的时候，只能初始化一次

  override def bar: Int = 100

  println(s"In C:foo=$foo,bar=$bar") //25,36,99

}

new C()

/*
In A:foo=0,bar=100
In B:foo=0,bar=100
In C:foo=46,bar=100
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

• 字段初始化顺序：像val foo:Int，字段初始化发生在构造器体执行之前，但超类的构造器（包括 println 语句）会在任何子类字段初始化之前执行。

• 方法动态绑定：像def bar:Int=5，Scala 会使用动态绑定来决定应该调用哪个版本的方法。即使在超类的构造器中，也会调用最终重写的方法版本（在 C 中为 100）。

• 字段重写：foo 在子类中被重写，但在超类和任何父类的构造器中引用这个字段时，它们看到的是其默认值（在赋值之前），直到子类自己的构造器赋予它新值。

• 当一个 val被重载，只能初始化一次

五、Scala的集合操作和集合类型保持一致性

def sumSizes(collections:Iterable[Iterable[_]]):Int = {
  //      println(s"collections:$collections")
  //      println(collections.map(_.size))
  collections.map(_.size).sum
}
1
2
3
4
5

第一部分代码解释

println(sumSizes(List(Set(1,2),List(3,4))))
1

在这里，输入是List类型的，包含两个集合：一个Set和一个List。List映射（map）操作会返回一个新的List，其中包含每个子集合的大小：

• Set(1, 2)的大小为2（因为集合中不允许重复值）
• List(3, 4)的大小为2

因此，map(_.size)返回List(2, 2)，其和为4。

第二部分代码解释

println(sumSizes(Set(List(1,2),Set(3,4))))
1

这里输入是Set类型的。由于Set在map操作后仍保持Set类型，而且不允许重复值，它会影响结果：

• List(1, 2)的大小为2
• Set(3, 4)的大小也是2

由于结果Set不能有重复值，map(_.size)产生的结果是Set(2)，其和为2，因为只有一个元素。

def sumSizes1(collections:Iterable[Iterable[_]]):Int = {
  collections.toSeq.map(_.size).sum
}
1
2
3

不管是什么集合类型，都将其转换成Seq

六、for和map的区别

val ys = for(Seq(x,y,z) <- xs) yield x+y+z
1

这里的for表达式等价于先进行withFilter过滤掉不符合模式Seq(x, y, z)的元素，然后对过滤后的元素应用map。因此，Seq("g","h")因为只有两个元素而被忽略，不参与后续的map操作。

val zs1 = xs map {case Seq(x,y,z) =>x+y+z}
1

当遇到Seq("g", "h")时，模式Seq(x, y, z)无法匹配只有两个元素的序列，因此Scala抛出了MatchError。