Scala学习之特殊符号，及函数

http://www.runoob.com/scala/scala-functions.html scala函数的定义，注意一些特殊函数的书写

1. =>符号

var equalRight = (x:Int) => x + 1  //--equalRight is <function1>   匿名函数

类似于转化符号，=>指明这个函数把左边的东西（任何整数x）转变成右边的东西（x + 1）。所以，这是一个把任何整数x映射为x + 1的函数。也可以进行类型的强转．

－－－该解释尚不清晰，需要进一步发现。

2.<- 循环遍历（递归）＋参数的可变性×

def printStrings(args: String*) = {
  var i: Int = 0
  for (arg <- args) {
    println("Arg value[" + i + "] = " + arg)
    i = i + 1
  }
}

函数调用：

printStrings("ahoBs", "abo", "alBo")

结果：

Arg value[0] = ahoBs
Arg value[1] = abo

Arg value[2] = alBo

3.字符串拼接 ++=

/**
  *  String 对象是不可变的，如果你需要创建一个可以修改的字符串，可以使用 String Builder 类
  */
  def StringTest(): Unit ={
    val hello:String = "hello world!" //String 对象不可变
    var len = hello.length
    val buf = new StringBuilder
    buf += 'a'
    buf ++= "bcdef"                  //++=
    println("hello say :" + hello)
    println("hello's len is "+ len)
    println("buf is " + buf.toString())
  }

函数：

1.高阶函数 http://www.runoob.com/scala/higher-order-functions.html

高阶函数（Higher-Order Function）就是操作其他函数的函数。
Scala 中允许使用高阶函数, 高阶函数可以使用其他函数作为参数，或者使用函数作为输出结果。
以下实例中，apply() 函数使用了另外一个函数 f 和 值 v 作为参数，而函数 f 又调用了参数 v：

// 函数 f 和 值 v 作为参数，而函数 f 又调用了参数 v
def apply(f:Int => String,v:Int) = f(v)
def layout[A](x:A) = "[" + x.toString() + "]"

函数调用：

println( apply( layout, 10) )

结果：

［10］

2.匿名函数 http://www.runoob.com/scala/anonymous-functions.html

Scala 中定义匿名函数的语法很简单，箭头左边是参数列表，右边是函数体。
使用匿名函数后，我们的代码变得更简洁了。
下面的表达式就定义了一个接受一个Int类型输入参数的匿名函数:
var inc = (x:Int) => x+1
上述定义的匿名函数，其实是下面这种写法的简写：
def add2 = new Function1[Int,Int]{
def apply(x:Int):Int = x+1;
}
以上实例的 inc 现在可作为一个函数，使用方式如下：
var x = inc(7)-1
同样我们可以在匿名函数中定义多个参数：
var mul = (x: Int, y: Int) => x*y
mul 现在可作为一个函数，使用方式如下：
println(mul(3, 4))
我们也可以不给匿名函数设置参数，如下所示：
var userDir = () => { System.getProperty("user.dir") }
userDir 现在可作为一个函数，使用方式如下：
println( userDir() )
实例
object Demo {
def main(args: Array[String]) {
println( "multiplier(1) value = " + multiplier(1) )
println( "multiplier(2) value = " + multiplier(2) )
}
var factor = 3
val multiplier = (i:Int) => i * factor
}
将以上代码保持到 Demo.scala 文件中，执行以下命令：
$ scalac Demo.scala
$ scala Demo
输出结果为：
multiplier(1) value = 3
multiplier(2) value = 6

3.函数柯里化(Currying)  http://www.runoob.com/scala/currying-functions.html

柯里化(Currying)指的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数。.

实例

首先我们定义一个函数:

def add(x:Int,y:Int)=x+y

那么我们应用的时候，应该是这样用：add(1,2)

现在我们把这个函数变一下形：

def add(x:Int)(y:Int) = x + y

那么我们应用的时候，应该是这样用：add(1)(2),最后结果都一样是3，这种方式（过程）就叫柯里化。

实现过程

add(1)(2) 实际上是依次调用两个普通函数（非柯里化函数），第一次调用使用一个参数 x，返回一个函数类型的值，第二次使用参数y调用这个函数类型的值。

实质上最先演变成这样一个方法：

def add(x:Int)=(y:Int)=>x+y

那么这个函数是什么意思呢？ 接收一个x为参数，返回一个匿名函数，该匿名函数的定义是：接收一个Int型参数y，函数体为x+y。现在我们来对这个方法进行调用。

val result = add(1) 

返回一个result，那result的值应该是一个匿名函数：(y:Int)=>1+y

所以为了得到结果，我们继续调用result。

val sum = result(2)

最后打印出来的结果就是3。

完整实例

下面是一个完整实例：

object Test {
   def main(args: Array[String]) {
      val str1:String = "Hello, "
      val str2:String = "Scala!"
      println( "str1 + str2 = " +  strcat(str1)(str2) )
   }

   def strcat(s1: String)(s2: String) = {
      s1 + s2
   }
}

执行以上代码，输出结果为：

$ scalac Test.scala
$ scala Test
str1 + str2 = Hello, Scala!