＜Zhuuu_ZZ＞Scala(三)函数

Lambda表达式

• 函数式接口
• 一种只含有一个抽象方法声明的接口
• 可以使用匿名内部类来实例化函数式接口的对象
• 通过Lambda表达式可以进一步简化代码

先定义一个接口：

public interface TestInterface {
    public Integer panduan(String a,Integer b);
}

然后直接调用

public class Test {
    public static void main(String[] args) {
      TestInterface t=(String a,Integer b)->{
          if(a.contains("初中") && b>=18){
              return 2000;
          }else  if(a.equals("高中") && b>=20){
              return 2200;
          }else if (a.indexOf("大学")!=-1 && b>=22) return 4000;
          else return 8000;
      };
        System.out.println(t.panduan("大学",25));
    }}

实例：

public interface OperationInterface {
    public Integer operation(Integer a,Integer b);
}

public class Impl implements OperationInterface {
    @Override
    public Integer operation(Integer a, Integer b) {
        return a+b;
    }}

public class TestDemo {
    public static void main(String[] args) {
            OperationInterface add=(Integer a,Integer b) ->a+b;
            OperationInterface jian=(Integer a,Integer b) ->a-b;
            OperationInterface ji=(Integer a,Integer b) ->a*b;
            TestDemo demo=new TestDemo();
            Integer result=demo.getResult(20,10,ji);
            System.out.println(result);
//          Integer sum2=add.operation(10,20);
//          System.out.println(sum2);

//        OperationInterface operationInterface = new Impl();
//        Integer sum = operationInterface.operation(10, 10);
//        System.out.println(sum);
    }
    public Integer getResult(Integer a,Integer b,OperationInterface operationInterface){
        return operationInterface.operation(a,b);
    }}

Scala元组

object demo1 {
  def main(args: Array[String]): Unit = {
    //元组声明方式一
    var tupleDemo=("hello",2.4,12,"world",'a')
    println(tupleDemo)
    println(tupleDemo._1)
    println(tupleDemo._2)
    var tupleDemo2=(1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,11,11) //里面元素最多支持22个
    println(tupleDemo2._1)
    //迭代元组
    tupleDemo.productIterator.foreach(x=>println("value:"+x))   //foreach遍历迭代器里内容
    //元组声明方式二
    var tupleDemo3=new Tuple5("ab",1,2,3,'f');
    //元组声明方式三(只能生成二元组)
    def mike="mike"->5->6->7
    println(mike)
    println(mike.getClass())
    //元组赋值方式
    val tp1=("zhangsan","andemen",19)
    val(name,address,age)=tp1
    println(name)
    println(address)
    println(age)
  }
}

Scala函数

wordcount

 val stringList=List("hello world hello gree","hello java hello scala","hello wenwen hello kb09")
stringList.flatMap(x=>x.split(" ")).map(x=>(x,1)).groupBy(x=>x._1).map(x=>(x._1,x._2.size))
val s=List("helloluoluonihao");
 s.flatMap(x=>x.split("")).map(x=>(x,1)).groupBy(x=>x._1).map(x=>(x._1,x._2.size))

函数定义

def square(x: Int): Int = { 
    println(x)
    x * x    //return
}

def sayHello(x:String):Unit={
    println("Hello ! "+x)
}

object FunctionDemo {
  def main(args: Array[String]): Unit = {
    //函数的定义和使用
    def minValue(a: Int, b: Int): Int = {
      if (a > b) b else a
    }
    def minValue1(a: Int, b: Int) = if (a > b) b else a  //minValue和minValue1方法等价
    println(minValue1(10, 20))
  }
}

递归调用：

object Test2 {
  def main(args: Array[String]): Unit = {
    def jiecheng(a:Int):Int={
      var x=a;
      for(i<-(a-1) to 1 by -1){
        x=x*i
      }
      return x
    }
    //真正的递归调用,递归不能使用类型推断，必须指定返回的数据类型。
    def ji(n:Double):Double=if(n==0) 1 else n*ji(n-1)
    println(ji(1))
    println(jiecheng(1))
  }
}

传递参数

object demo2 {
  def main(args: Array[String]): Unit = {
    def showMsg(name: String, age: Int):Unit={
      println("Hello:"+name+",age:"+age)
    }
    //按方法参数列表顺序传参
    showMsg("kb09",3)
    //指定参数名字传参
    showMsg(age=18,name="zhangsan")   
    //参数的长度未知，通过*表示，可以传入多个参数
    def showMsg2(name:String,s:String*):Unit={ 
      println(name)
      for(str<-s){
        println(str)
      }
    }
    showMsg2("kb09","你好","are you ok","i am ok and you")
  }
}

匿名函数

• 需要注意的是，匿名函数的返回值的数据类型依赖于函数体的最后一行表达式的值，这个由程序自己判断，匿名函数的返回值类型不能手工指定！

object demo3 {
  def main(args: Array[String]): Unit = {
    def sum(a:Int,b:Int):Int = a+b
    val aa = (a:Int,b:Int) => a+b    //匿名函数，通过一个常量去使用它
    val bb=aa
    println(sum(1,2))
    println(aa(5,2))
    println(bb(sum(1,2),aa(5,2)))
  }
}

• 有的时候，当数组已存在，即数据类型已确定时，甚至连输入参数类型都可以省略。

val a=Array(1,2,3,4,5)
a.sortWith((x:Int,y:Int)=>x>y)
a.sortWith((x,y)=>x>y)   //上下等价，当参数类型已确定时，可省略。

传递函数

匿名函数传递

object demo4 {
  def main(args: Array[String]): Unit = {
    val aa = (a:Int,b:Int) => a+b
    val a     :   Int          = 10
    val sum   :(Int,Int)=>Int  =(a:Int,b:Int)=>a+b
    val sum1:(Int,Int)=>Int =aa
    println(sum(1,3))
    println(sum1(2,4))
  }
}

函数作为参数进行传递

def fun(a:Int,b:Int):Int = a+b
    def fun1(a:Int,b:Int):Int = a-b
    def fun2(a:Int,b:Int):Int = a*b

    def funTest(f:(Int,Int)=>Int,s:String):String={
     val resultValue= f(1000,2000)
      s+resultValue
    }

    println(funTest(fun, "你的薪水："))
    println(funTest((a: Int, b: Int) => 2 * a + 3 * b, "abc"))

方法返回参数是函数

  def funTest2(s:String):(String,String)=>String ={
      def fun2(str1:String,str2:String):String={
        str1+"##"+str2+"&&"+s
      }
      fun2
    }
    println(funTest2("hah")("aa","bb"))