Scala函数

Lambda表达式Scala元组Scala函数wordcount函数定义递归调用：传递参数匿名函数传递函数匿名函数传递函数作为参数进行传递方法返回参数是函数

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"))