scala函式

fan_rockrock發表於2016-03-14
函式
  1. //函式基本定義  
  2. /* 
  3. object Test{ 
  4.     def main(args: Array[String]) 
  5.     { 
  6.         println("Return Value: "+addInt(3,8)); 
  7.     } 
  8.     def addInt(a:Int,b:Int):Int={ 
  9.         return a+b; 
  10.     } 
  11. }*/  
  12.   
  13.   
  14.   
  15. //函式按名稱呼叫  
  16. /*object Test{ 
  17.     def main(args:Array[String]){ 
  18.         delayed(time()); 
  19.     } 
  20.     def time()={ 
  21.         println("Geting time in nano second"); 
  22.         System.nanoTime; 
  23.     } 
  24.     def delayed(t: => Long)={ 
  25.         //println("In delayed mathod"); 
  26.         println(t); 
  27.         //t; 
  28.     } 
  29. }*/  
  30.   
  31.   
  32.   
  33. //使用命名引數  
  34. /*object Test{ 
  35.     def main(args: Array[String]){ 
  36.         printInt(b=5,a=7); 
  37.     } 
  38.     def printInt(a:Int,b:Int)={ 
  39.         println("Value of a: "+a); 
  40.         println("Value of b: "+b); 
  41.     } 
  42. }*/  
  43.   
  44.   
  45.   
  46. //遞迴函式  
  47. /*object Test{ 
  48.     def main(args: Array[String])={ 
  49.         for(i<- 1 to 10) 
  50.             println("Factorial of "+ i+":= "+fac(i)); 
  51.     } 
  52.  
  53.     def fac(n:Int):BigInt={ 
  54.         if(n<=1) 
  55.             return 1; 
  56.         else 
  57.             return n*fac(n-1); 
  58.     } 
  59. }*/  
  60.   
  61.   
  62.   
  63. //可變引數  
  64. /*object Test{ 
  65.     def main(args: Array[String]){ 
  66.         printStrings("AAA","BBB","CCC"); 
  67.     } 
  68.  
  69.     def printStrings(args: String*)={ 
  70.         var i=0; 
  71.         for(arg<-args){ 
  72.             println("Arg value[" + i + "]=" + arg); 
  73.             i+=1; 
  74.         } 
  75.     } 
  76. }*/  
  77.   
  78.   
  79.   
  80. //預設引數函式  
  81. /*object Test{ 
  82.     def main(args: Array[String]){ 
  83.         println("Return Value: " + addInt(9)); 
  84.     } 
  85.     def addInt(a:Int=5,b:Int=7):Int={ 
  86.         return a+b; 
  87.     } 
  88. }*/  
  89.   
  90.   
  91.   
  92. //函式賦值給變數  
  93. /*object Test{ 
  94.     def main(args:Array[String]){ 
  95.         var f1=func1 _//_將func1轉化為函式變數賦值給f1 
  96.         f1("spark") 
  97.     } 
  98.     def func1(name:String)={ 
  99.         println(name) 
  100.     } 
  101. }*/  
  102.   
  103.   
  104.   
  105. /*高階函式 
  106. *1.函式的引數是函式 
  107. *2.函式返回值是函式 
  108. */  
  109.   
  110. //函式的引數是函式  
  111. /*object Test{ 
  112.     def main(args:Array[String]){ 
  113.         println(func1(scala.math.ceil _)) 
  114.         println(func1(f11)) 
  115.     } 
  116.     def func1(f1:(Double)=>Double)=f1(100.55)//f1是函式引數，傳入Double，返回Double 
  117.     def f11(x:Double):Double={ 
  118.         if(x>10.0) 
  119.            1.1 
  120.         else 
  121.            0.0 
  122.     } 
  123. }*/  
  124.   
  125. //返回一個函式的函式  
  126. /*object Test{ 
  127.     def main(args:Array[String]){ 
  128.         val quintuple=mulBy(5) 
  129.         var value=quintuple(20) 
  130.         println(value) 
  131.     } 
  132.     def mulBy(factor:Double)=(x:Double)=>factor*x 
  133. }*/  
  134.   
  135.   
  136.   
  137. //匿名函式  
  138. /*object Test{ 
  139.     def main(args:Array[String]){ 
  140.         var inc=(x:Int)=>x+1 
  141.         println(inc(7)) 
  142.  
  143.         var mul=(x:Int,y:Int)=>x*y 
  144.         println(mul(3,4)) 
  145.  
  146.         var userDir=()=>{System.getProperty("user.dir")} 
  147.         println(userDir) 
  148.     } 
  149. }*/  
  150.   
  151.   
  152.   
  153. //柯里化函式:原來接收兩個引數的函式變成接收一個引數的函式的過程，新的函式返回一個以原有第二個引數  
  154.              //作為引數的函式(即柯里化函式接收多個引數構成一條鏈，每次取一個引數)  
  155. /*object Test{ 
  156.     def main(args:Array[String]){ 
  157.         println(mulBy(3,4)); 
  158.         println(mulBy1(4)(6)); 
  159.         println(mulBy2(7)(8)); 
  160.  
  161.         //var r=f1(3,4)(bigger(_,_)) 
  162.         var r=f1(3)(4)(bigger(_,_)) 
  163.         println(r) 
  164.     } 
  165.     //普通定義兩個引數 
  166.     def mulBy(x:Int,y:Int)=x*y 
  167.     //柯里化函式 
  168.     def mulBy1(x:Int)=(y:Int)=>x*y 
  169.     //更簡潔的柯里化 
  170.     def mulBy2(x:Int)(y:Int)=x*y 
  171.  
  172.     //柯里化例項1 
  173.     /*def f1(x:Int,y:Int)(bigger:(Int,Int)=>Boolean)={ 
  174.         if(bigger(x,y)) x else y 
  175.     }*/  
  176.     def f1(x:Int)(y:Int)(bigger:(Int,Int)=>Boolean)={  
  177.         if(bigger(x,y)) x else y  
  178.     }  
  179.     def bigger(x:Int,y:Int)={  
  180.         if(x>y) true else false  
  181.     }   
  182. }  
  183. */  
  184.   
  185.   
  186.   
  187. //巢狀函式:scala允許在一個函式內部定義其他函式，在內部可被呼叫  
  188. /*object Test{ 
  189.     def main(args:Array[String]){ 
  190.         println(factorial(3)) 
  191.         println(factorial(4)) 
  192.         println(factorial(5)) 
  193.     } 
  194.     def factorial(i:Int):Int={ 
  195.         def fact(i:Int,accumulator:Int):Int={ 
  196.             if(i<=1) 
  197.                 accumulator 
  198.             else 
  199.                 fact(i-1,i*accumulator) 
  200.         } 
  201.         fact(i,1) 
  202.     } 
  203. }*/  
  204.   
  205.   
  206.   
  207. //部分應用函式:呼叫函式時，不指定函式所需的所有引數，這樣 建立了一個新的函式，這個新的函式被稱為原始函式的部分應用函式  
  208. /*import java.util.Date 
  209. object Test{ 
  210.     def main(args:Array[String]){ 
  211.         val logWithDateBound=log(_:Date,"time") 
  212.         logWithDateBound(new Date) 
  213.         Thread.sleep(1000) 
  214.         logWithDateBound(new Date) 
  215.         Thread.sleep(1000) 
  216.         logWithDateBound(new Date) 
  217.     } 
  218.     def log(date:Date,message:String)={ 
  219.         println(date+"----"+message); 
  220.     } 
  221. }*/  
  222.   
  223.   
  224.   
  225. //閉包:變數不在函式作用域範圍之內還可以被呼叫  
  226. /*object Test{ 
  227.     def main(args:Array[String]){ 
  228.         var more=1; 
  229.         //函式變數addMore是一個"閉包" 
  230.         val addMore=(x:Int)=>x+more 
  231.         println(addMore(100)) 
  232.          
  233.         //當這個自由變數變化時，閉包能夠捕獲到這個變化，因此閉包捕獲的是這個變數本身 
  234.         more=999; 
  235.         println(addMore(1)) 
  236.          
  237.         // 如果閉包在變化，也會反映到閉包外面的值 
  238.         val someNumbers=List(-11,-10,-5,0,5,10) 
  239.         var sum=0 
  240.         someNumbers.foreach(sum+=_) //_代表引數列表 
  241.         println(sum) //可以看到在閉包中修改sum的值，結果傳遞到了閉包的外面 
  242.     } 

  1. }*/  
          //引數的位置標記法
如果某個引數在函式裡使用了一次，就可以用下劃線來表示。每次在函式裡用下劃線，都表示隨後的引數
        例子:
  val arr=Array(1,2,3)
println((0 /: arr){(sum,elem)=>sum+elem})//   /:函式是循壞取值
         //(sum,elem)=>sum+elem可以改寫成 _ + _，第一個_表示函式呼叫過程中持續存在的值，第二個_表示陣列元素
 
var max=(Integer.MIN_VALUE /: arr){(large,elem)=>max(large,elem)}
         //(large,elem)=>max(large,elem)可改寫為max(_,_)

        //_不止可以表示一個引數，也可以表示整個引數列表，因此可以這樣改：max _

相關文章