2020-11-05-Scala-复习-6(面对对象 & 语法补

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方法的自动调用

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