2020-11-05-Scala-复习-6(面对对象 & 语法补
2020-11-08 本文已影响0人
冰菓_
1.回顾(如果要采用foldLeft 和map接收,首先map的key要重新定义)
import scala.collection.mutable
///1、使用Scala实现一个方法，使得返回数组中，分别等于num，大于num，小于num的元素的个数。
// 例：getNum（Array（1,2,3,4,5,6），2）结果为（2,2,3）
object Test1 {
//重写一遍理解第一个参数的意义
//方法一
def main(args: Array[String]): Unit = {
var array = Array(1, 2, 3, 4, 5, 6)
var a = 0
var b = 0
var c = 0
var result = array.aggregate(a, b, c)((x, y) => {
(if (y > 2) {
x._1 + 1
} else x._1,
if (y == 2) {
x._2 + 1
} else x._2,
if (y < 2) {
x._3 + 1
} else x._3)
}, null)
//此处的null 为combop: (B, B) => B 对于局部的聚合适用于嵌套
println((result._1, result._2, result._3))
//方法二分组模式匹配
array.groupBy(data => {
data match {
//case是分组的标准作为key值, 匹配返回的一个key标准
case x if x > 2 => "x>2"
case y if y == 2 => "y==2"
case z if z < 2 => "z<2"
}
}).map(_._2.toList).foreach(println)
//简化
array.groupBy {
//case是分组的标准作为key值,
case x if x > 2 => "x>2"
case y if y == 2 => "y==2"
case z if z < 2 => "z<2"
}.map(_._2.toList.size).foreach(println)
//方法三使用过滤
println((array.count(_ > 2), array.count(_ < 2), array.count(_ == 2)))
}
}
2.map与模式匹配
object Test2 {
def main(args: Array[String]): Unit = {
var st = "SShhirsshhgdkdsh"
//使用一个map来接收
val map = mutable.Map[Char, mutable.SortedSet[Int]]()
//count计数次数
var i = 0
st.foreach {
data =>
map.get(data) match {
case Some(value) => map(data) = value + i
case None => map += (data -> mutable.SortedSet[Int] {
i
})
}
i += 1
}
println(map)
st.foreach { data =>
map.get(data) match {
case Some(value) => map(data) = value + i
case None => map += (data -> mutable.SortedSet[Int] {
i
})
}
i += 1
}
// println(map)
}
}
3.foreach() foreach{} --这个省略了() 相当于({})
object Test4 {
def main(args: Array[String]): Unit = {
var list = List(1, 2, 3, 4, 5, 6, 7, 8)
var i = 0
var a = list.foreach(
data => println(data)
)
var b = list.foreach({
data => println(data)
})
println(a)
println(b)
}
}
4.简单理解函数风格的编程
函数式的两大指导思想:
- 函数的头等值,可作为值传递
- 程序的操作应该把输入值映射为输出值,而不是修改数据,例如scala中定义了众多的不可变集合是scala函数式编程的基石
- 第二个指导思想的另一种理解.方法不应该带来副作用
(指令式编程和函数式编程)
例如:
//理解foreach方法的扩展形式
list.foreach(f)
}
val f = (s:Int) => println(s)
5.动态混入
-
有父类时,一定到先继承父类
image.png
trait Test11{
def max()
}
trait Test111 extends Test11 {
def max(): Unit = {println("Test111")}
}
trait Test1111 extends Test111{
// override 为什么必须要加override 假设不加 new 一个对象 执行哪一个max? 所以必须要加override
override def max(): Unit = {println("Test1111")}
}
object Test1 {
def main(args: Array[String]): Unit = {
val mysql = new Mysql with D with E
mysql.max()
}
}
//实践构建和执行的顺序
trait A {
def max()
}
trait B extends A{
println("构建B")
def max(): Unit = println("我是B")
}
trait C extends B{
println("构建C")
override def max(): Unit = {
println("我是C")
super.max()}
}
trait D extends C {
println("构建D")
override def max(): Unit = {
println("我是D")
super.max()
}
}
trait E extends C{
println("构建E")
override def max(): Unit = {
println("我是E")
super.max()}
}
class Mysql{
println("我是mysql")
}
//我是mysql
//构建B
//构建C
//构建D
//构建E
//我是E
//我是D
//我是C
//我是B
6.数组的update方法的自动调用
image.png
7.listbuffer中的添加方法(注意:+ 是复制原来一个集合)
def main(args: Array[String]): Unit = {
val list = List(1,2,3,4)
val listbuffer = ListBuffer[Int](1,2,3,4,5)
val value = listbuffer :+ 2
println(value)//ListBuffer(1, 2, 3, 4, 5, 2)
println(listbuffer)//ListBuffer(1, 2, 3, 4, 5)
value += 2 //改变到原来集合
value.append(22) //改变到原来集合
println(value)
8.set/map中的 + +=方法(注意不可变集合的+=并非真正意义上的+=)
object Test7 {
def main(args: Array[String]): Unit = {
var set = mutable.Set[Int](1,2,3,4)
var set1 = Set[Int](1,2,3,4)
set + 5
set1 + 5
set1 += 51 //HashSet(1, 2, 3, 4)
set1 += 51
println(set)
println(set1)
}
}
