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