从零学scala（六）操作符、高级函数

一：操作符

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

1.标识符

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

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

2.中置操作符

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

3.一元操作符

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

     //1.toString()

4.赋值操作符

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

5.优先级

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

6.结合性

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

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

7.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("|"))

8.提取器

     //提取器是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
                       }
              }
     }

9.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"))
              }
     }

二：高阶函数

1.作为值的函数

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

2.匿名函数

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

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

3.带函数参数的函数

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

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

4.参数类型推断

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

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

5.一些有用的高阶函数

     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("|")

6.闭包

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

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

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

8.柯里化

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

     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

9.控制抽象

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

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

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