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!

---------------------?
作者：AhoBric?
來源：CSDN?
原文：https://blog.csdn.net/qq_31215163/article/details/54910515?
版權聲明：本文為博主原創文章，轉載請附上博文鏈接！

總結

以上是生活随笔為你收集整理的Scala学习之特殊符号，及函数的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。