9.2 scala函数 list map 元组

基础语法TestFunc.scala：

package com.scala

object TestFunc {

//默认值函数

  def sayMyName(name : String = "Jack"){

  println(name)

 }

//多个int类型参数，相加

 def sumMoreParameters( elem : Int* ) = {

   var sum = 0

  for( e <- elem ){

   println(e)

   sum += e

  }

   sum

 }

//含参函数

 def add(a:Int,b:Int) = a+b

//一个自定义数值，和一个固定数值

 def add2 = add(_:Int,2)

 

 

// 递归函数

// 必须自行定义函数返回类型

// f(n)=f(n)*f(n-1)

 def fac(n:Int):Int = if( n <= 0) 1 else n*fac(n-1)

 

 

// 函数柯里化

 // 柯里化,柯里化比较有意思,就是说定义

 // 把这个参数一个个独立开来写,这就是柯里化,它可以达到什么效果呢

 def mulitply(x:Int)(y:Int) = x*y

 //一个固定值和一个传参

 def m2 = mulitply(2)_

 // 同学们可能会说，这个看起来没有什么用处啊，但是我们说柯里化在递归，和控制抽象方面比较有用

// 在目前我们不去深究这个使用场景，现在就是让大家知道有这么个形式，大家掌握到这就可以了

// 柯里化就是把参数可以分开来，把部分函数参数可以用下划线来代替

// => 匿名函数声明方式

    val t = ()=>{333;"xururyun"}//声明了一个函数对象付给了t

   

// :后面是数据类型,c代表传进来的参数

    def testfunc02(c : ()=>String )={

      c()

    }

// 匿名函数

  val d1 = (a:Int)=> a+100

 

// 匿名函数作为参数,其实就是参数名,后面跟上参数类型,然后是表达式

    def testf1(callback : (Int,Int)=>Int )={

     println(callback(123,123))

    }

    

    

// 嵌套函数 ,其实就是def里面套一个def

 def add3(x:Int, y:Int ,z:Int) = {

  def add2(x:Int, y:Int) = {

   x + y

  }

  add2(add2(x,y),z)

 }

// 能否看懂？？？

    def sum(f : Int => Int) : (Int , Int) => Int = {

      def sumF(a : Int , b : Int) : Int = 

        if (a >b ) 0 else f(a) + sumF( a + 1 , b)

      sumF

    }

    

// def sum(f : Int => Int) : (Int , Int) => Int = {

// def sumF(a : Int , b : Int) : Int ={

// if (a >b ) 0 else f(a) + sumF( a + 1 , b)

// } 

// return sumF

// }

 def main(args: Array[String]) {

   

    val sumF = sum(x=>x*2) 

    println(sumF(2,3))

   

// sayMyName()

   

// println(sumMoreParameters(1,2,3,4,5,6,7,8,9,10))

// println(add(2,3))

// println(add2(3))

  

// println(fac(5))

// println(d1(4))

  

// println(t)

// println(t())

   

// println(testf1((x:Int, y:Int)=>{x*y}))

   

// println( mulitply(123)(123))

// println( m2(123))

// println(testfunc02( t ))

// println(testf1( (a:Int,b:Int)=> a+b))

   

// testf1(add)

// println(add3(1,2,3))

// def sum(f :Int => Int) : (Int , Int) => Int = {

// def sumF(a : Int , b : Int) : Int ={

// if (a >b ) 0 else f(a) + sumF( a + 1 , b)

// }

// return sumF

// }

   

// val tttt = (a:Int,b:Int)=>a*b;

// testf1(tttt);

// testf1((a:Int,b:Int)=>a*b)

   

   

 }

}

=======================================================================

---

基本用法2TestFunc02.scala 遍历to until

package com.scala

object TestFunc02 {

 

  def test() : Unit = {

   for(i <- 1.to(100)){

    println(i)

   }

// for(i <- 1 to 100 ){

// println(i)

// }

 }

 

 def test2() = {

   for(i <- 1 until 100 ){

    println(i)

   } 

 }

 

 def test3() = {

  for(i <- 0 to 100 if (i % 2) == 1 ; if (i % 5) > 3 ){

    println("I: "+i)

  }

 }

   

// switch

  def testmatch(n:Any)={

    n match {

      case x:Int => {println("111") ;n}

// break;

     case s:String => println("2222") ;n

     case _ => {println("other"); "test"}//default

    }

  }

 

  def sum(elem : Int*) = {

    var temp = 0

    for(e <- elem){

      temp += e

    }

    temp

  }

 def main(args: Array[String]) {

// test()

// test2()

// test3()

// println(testmatch(100.0))

   

// println(sum(1,2,3,4,5))

// println(sum(1 to 5))

   println(sum(1 to 5 :_*))

 }

}

========================================================================

---

基本用法3TestCollection.scala list map foreach distinct sortBy 元组

package com.scala

object TestCollection {

 def main(args: Array[String]) {

  var t = List (1,2,3,5,5)

// println("---001--"+t(2))

// map 个位置相加 函数编程

// 对集合里面的每个元素进行操作,有返回值,这里返回一个新的List

// println(t. map ( x => {x+2}))

// println(t.map(_ + 2))

   

  var t2 = t.+:("test") //添加元素

// println(t2)

// println(t)

// println(t.::("test"))

// println("test"::t)

// println(6::t2)

// println(t2.::(6))

// println(List(6).:::(t2))

// println((t2):::List(6))

// println(t2)

// t2 = t:::6::Nil //组成新的List t作为一个元素

// println(t2)

//遍历

// t2. foreach (a=>print("---+++"+a))

//去重复

// println("/--***---"+t. distinct )

//排序

// println(t. sortBy { x => -x })

//切割 

// println("---+++++********************Slice"+t. slice (0, 2))

  

// println("-*--*--*--*--*--*--*--*--*-")

// for(temp<-t2){

// print(temp)

// }

// println("-*--*--*--*--*--*--*--*--*-")

// for(i <- 0 until t2.length){

// println(i)

// println(t2(i))

// }

// println("-*--*--*--*--*--*--*--*--*-")

// println(t./:(0)({

// (sum,num)=>sum-num

// }))

  

  // 1,2,3,5,5

  // reduce 就是对集合里面的每个元素依次进行操作

// println(t. reduce ( (a,b) => a+b ))

// println(t.reduce( _ - _))

// // filter 是把匿名函数返回为True保留下来

// println(t. filter ( _ > 3 ))

// println(t. take (3)) //取前三个元素

// println("-*--*--*--*--*--*--*--*--*-")

// println(t. foldLeft (0)((sum,num)=>{ //带初始值的reduce

// print(sum+"--"+num+" ");

// sum-num;

// }))

// println("-*--*--*--*--*--*--*--*--*-")

// println(t.map(v =>v+2))

// println("-*--*--*--*--*--*--*--*--*-")

// 元组

// var tuple01 = (1,2,3,5)

// println(tuple01._1)

// println(tuple01._4)

  var list = List(("yasaka",100),("xuruyun",100),("liangyongqi",50))

  val temp = list.sortBy(x => (-x._2,x._1))

  println(temp)

 }

}

---