从零学scala(六)操作符、高级函数

一:操作符

这一章几乎是Java操作符的简单介绍,大佬们可以直接跳过,看第二章。

标识符

        val ** = "as" //**也可以是变量名称
        println(**)

        val `【】四川省` = "abcd" //``内可以写任意的字符串
        println(`【】四川省`)

中置操作符

        for(i <- 1 to 10){ println(i)} //其实就是调用的1.to(10)方法

一元操作符

         //只有一个参数的操作符称为一元操作符

         //1.toString()

赋值操作符  

         val data = "abcd" //赋值操作符,很常见的

优先级

         //这一章节建议大家多使用()来确定优先级,只需要记住*/高于+-,<> 高于&^|。这两种就可以了

结合性

         //这一章的意思是,操作符相关是按照从左到右的顺序的。例子:1+2+3计算方法是第一个加号操作的是1和2,第二个加号操作的是2和3。

         //基本上和数学是一样的

apply和update方法

         val data = scala.collection.mutable.Map("a"->1,"b"->2,"c"->3,"d"->4)
         data("a") = 11 //其实调用的是data.update("a",11)
         val a = data("a") //其实调用的是 data.apply("a")

         //apply方法常用到new对象中

         val data = Array.apply("abcd")   //其实调用的是方法new Array
         println(data.mkString("|"))

提取器

         //提取器是apply的反向操作名称为unapply,参数为一个对象,将构造对象的参数提取出来

         //例子:上一节中通过abcd构造了一个Array对象,而unapply方法就是传递进去data,返回abcd字符串。其实Array是没有这个方法的

单个参数或无参数的提取器

         //该提取器的方法是将字符串提取成数字

         object Number {
                  def unapply(inputString:String):Option[Int]={
                           try{
                                    Some(Integer.parseInt(inputString.trim()))
                           }catch{
                                    case ex:NumberFormatException => None
                           }
                  }
         }

unapplySeq方法

         //上述的方法只能提取一个数字,但是真正在提取过程中提取一般是提取一个Seq

         object Number {
                  def unapply(inputString:String):Option[Array[String]]={
                           try{
                                    Some(inputString.trim().split("\\|").toArray)
                           }catch{
                                    case ex:NumberFormatException => None
                           }
                  }
         }

         object FastLearnScala{
                  def main(args: Array[String]): Unit = {
                           println(Number.unapply("1 9 7 8"))
                  }
         }

二:高阶函数

作为值的函数

         val num = 3.1415926
         val fun = scala.math.max _ //_说明的是用fun指向这个函数
         println(fun(1,3))

匿名函数

         val num = (num:String)=>{num + "abcd"} //这种方法就是一个匿名函数
         println(num("1234"))

         val array = num("1234|").split("\\|")          //其实使用最多的还是map方法,如下也是一个匿名函数
         array.map { x => println(x) }

带函数参数的函数

         object FastLearnScala{
                  //传递的是一个函数,输入是Double,输出也是Double。最终调用的是函数,传递的参数是0.25
                  def valueAtOneQuatter(f:(Double)=>Double) = { f(0.25) }

                  def main(args: Array[String]): Unit = {
                           println(valueAtOneQuatter(scala.math.ceil _))
                  }
         }

         //一般情况下不这样使用。直接调用函数就行了

参数类型推断

         //scala会将一些自动推断出来,你需要的类型

         val data = 3 * 1//scala会自动推断出来data是Int类型的,在函数中也是一样的

一些有用的高阶函数

         val data = Array(1,2,3,4,5)

         //map函数 针对数组每一个元素都进行+10的操作
         data.map { x => x+10 }
         //过滤出来>5的元素
         data.filter(_ > 5)
         //reduceLeft接受一个二元函数,并将它应用到所有元素
         data.reduceLeft(_*_) //其实是(((1*2)*3)*4)*5
         //sortWith排序函数
         data.sortWith((x,y)=>x>y).mkString("|")

闭包

         //函数可以在变量不在处于作用域时被调用,简单说就是函数可以帮你暂存你的数据,因为你的数据指向函数导致了函数不会被回收

         object FastLearnScala{

                  def mulby(x:Int) = (y:Int) => x*y //该函数将x作为一个参数,x作为第二个参数,计算x*y的值
                  def main(args: Array[String]): Unit = {
                           val a = mulby(10)
                           val b = a(3)
                           println(b)
                  }
         }

SAM转换

         //其实是单个抽象方法,就是只有一个抽象方法。

         //如下是一个计数的方法

         import javax.swing.JButton
         import java.awt.event.{ActionListener,ActionEvent}

         object FastLearnScala{

                  def main(args: Array[String]): Unit = {
                           var counter = 0

                           val button = new JButton("increate")
                           button.addActionListener(new ActionListener{
                                    override def actionPerformed(event:ActionEvent){
                                             counter += 1
                                    }
                           })
                  }
         }

         //其实在真正的使用过程中,更多的是需要一个new ActionListener的封装,只需要调用即可,那我们可以进行改造

         var counter = 0
         implicit def makeAction():ActionListener = {
                  new ActionListener{
                           override def actionPerformed(event:ActionEvent){
                                    counter += 1
                           }
                  }
         }

         val button = new JButton("increate")//调用使用
         button.addActionListener(makeAction)

柯里化

         //上一个章节的闭包就是柯里化

         object FastLearnScala{

                  def mulby(x:Int) = (y:Int) => x*y //该函数将x作为一个参数,x作为第二个参数,计算x*y的值 
                  def main(args: Array[String]): Unit = {
                           val a = mulby(10)
                           val b = a(3)
                           println(b)
                  }
         }

         //上面的过程可以分解为:传入x的时候返回一个函数(y:Int)=>x*y

控制抽象

         //没有看懂,后面再补充吧

return表达式

         //scala写法支持return,但是不建议使用。默认是将最后一个变量返回

         def mm():Int = {
                  var data = 0
                  if(1 > 3) data = 0 else data = 0
                  data
         }

猜你喜欢

转载自www.cnblogs.com/wuxiaolong4/p/11832174.html