Lambda表达式
普通函数—匿名函数—lambda函数（箭头函数）—比较：
<!DOCTYPE html>
<html>
<head>
<title> my page </title>
<style type="text/css">
</style>
</head>
<body>
<script type="text/javascript">
/*
//普通函数
function add(n1,n2){
return n1+n2
}
var res=add(1,2)
alert(res);
*/
//匿名函数
/*var f=function(n1,n2){
return n1+n2
}
alert(f(1,2))*/
//lambda函数,箭头函数
//函数体只有一个语句，并且需要返回数据
var x=(a1,a2)=>a1+a2;
//alert(x(1,2))
//函数体只有一个语句，不需要返回值
/*var y=()=>alert("你好");
y();*/
//传入多个参数，方法体有多个语句，并且有返回值
var z = (a,b,c)=>{
alert(a);
alert(b);
alert(c);
return a+b+c;
}
res = z(1,2,3)
alert(res);
</script>
</body>
</html>
lambda函数（箭头函数）—代码：
MyRunnable ：
package com.test1;
public class MyRunnable implements Runnable{
@Override
public void run() {
System.out.println("这是我的MyRunnable方法");
}
}
Test ：
package com.test1;
public class Test {
public static void main(String[] args) {
//创建自定义的多线程任务对象
//MyRunnable myRunnable = new MyRunnable();
//new Thread(myRunnable).start();
//匿名类方式实现多线程任务
/*
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("匿名类的多线程任务....");
}
};
new Thread(runnable).start();
*/
//java lambda表达式实现多线程任务接口
// Runnable runnable = ()->{
// System.out.println("这是lambda实现的多线程任务接口");
// };
Runnable runnable = ()-> System.out.println("这是lambda实现的多线程任务接口");
new Thread(runnable).start();
}
}
布局&运行结果：
带参数的lambda表达式—代码：
Test2 ：
package com.test1;
import java.util.Comparator;
import java.util.TreeSet;
public class Test2 {
public static void main(String[] args) {
//lambda:简化类实现的函数写法
//定义TreeSet实现排序的set接口:存储字符串数据，按照字符串长度排序
// Comparator<String> comparator = new Comparator<String>() {
// @Override
// public int compare(String o1, String o2) {
// //用字符串的长度比交大小
// return o1.length()-o2.length();
// }
// };
//带参数的lambda表达式
Comparator<String> c = (s1,s2)-> s1.length()-s2.length();
TreeSet<String> tset = new TreeSet<String>(c);
tset.add("aaa");
tset.add("bbbbbb");
tset.add("cccc");
tset.add("ddddd");
tset.add("eeeeeee");
System.out.println(tset);
}
}
布局&运行结果：
函数式接口可以和lambda结合使用
IUsb ：
package com.test2;
/**
* 接口中只有一个方法的接口，称为函数式接口，函数式接口可以和lambda结合使用
*/
public interface IUsb {
void work();
}
Test ：
package com.test2;
public class Test {
public static void main(String[] args) {
//内部类实现接口
// IUsb usb1 = new IUsb() {
// @Override
// public void work() {
// System.out.println("使用鼠标选择文件...");
// }
// };
//lambda实现功能
IUsb usb1 = ()-> System.out.println("使用鼠标选择文件...");
use(usb1);
use(()-> System.out.println("使用键盘写文档...."));
}
//使用usb设备干活
public static void use(IUsb usb){
usb.work();
}
}
布局&运行结果：
常见函数式接口
Consumer < T >消费型接口—代码:
Test1 ：
package com.test3;
import com.oracle.xmlns.internal.webservices.jaxws_databinding.XmlOneway;
import java.util.Comparator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
public class Test1 {
public static void main(String[] args) {
//系统已经定义好的函数式接口:
//消费型接口:用于接收数据进行处理，但没有返回值的场景
//Consumer<T>: void accept(T t);
//供给型接口:用于自己内部进行数据处理，不需要接收参数，但会返回结果的场景
//Supplier<T>: T get();
//函数式接口:针对传入数据进行处理，并返回结果
//Function<T,R>: R apply(T t);
//断言型接口:针对传入数据，进行条件判定，返回ture/false
//Predicate<T>: boolean test(T t);
//消费型接口:
Consumer<Double> cs1 = money -> System.out.println("去唱歌花费:"+money);
play(cs1,1000.0);
Consumer<Double> cs2 = money -> System.out.println("去跳舞花费:"+money);
play(cs2,2000.0);
}
//去玩
public static void play(Consumer<Double> cs,Double qian){
//调用接口方法
cs.accept(qian);
}
}
布局&运行结果：
Supplier < T > 供给型接口—代码：
Test2 :
package com.test3;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;
public class Test2 {
public static void main(String[] args) {
//供给型接口:生成随机数
Supplier<Integer> supplier = ()-> new Random().nextInt(100);
//int n1 = supplier.get();
//System.out.println(n1);
//请生成若干随机数，并返回
List<Integer> nums= getRandomNum(supplier,5);
System.out.println(nums);
}
//生成若干随机数，并返回
public static List<Integer> getRandomNum(Supplier<Integer> supplier,int count){
List<Integer> nums = new ArrayList<>();
for (int i=1;i<=count;i++){
nums.add(supplier.get());
}
return nums;
}
}
布局&运行结果：
Function<T,R>函数式接口—代码：
Test3 ：
package com.test3;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.function.Function;
public class Test3 {
public static void main(String[] args) {
//函数式接口：针对传入数据进行处理，并返回结果
//实现将字符串转大写的功能
Function<String,String> function = s->s.toUpperCase();
//String res = function.apply("abc");
//System.out.println(res);
List<String> stringList = new ArrayList<>();
stringList.add("aaa");
stringList.add("bbb");
stringList.add("ccc");
stringList.add("ddd");
System.out.println(covert(function,stringList));
}
//将传入的字符列表中的内容，转大写之后返回
public static List<String> covert(Function<String,String> function, List<String> stringList){
List<String> newList = new ArrayList<>();
for(int i=0;i<stringList.size();i++){
String oldStr = stringList.get(i);
String newStr = function.apply(oldStr);
newList.add(newStr);
}
return newList;
}
}
布局&运行结果：
Predicate< T >断言型接口—代码：
Test4 :
package com.test3;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
public class Test4 {
public static void main(String[] args) {
//断言型接口:针对传入的数据进行处理，返回true/false。用于判断数据是否满足条件
//传入的字符串长度是否大于3
Predicate<String> predicate = s -> s.length()>3;
List<String> stringList = new ArrayList<>();
stringList.add("aa");
stringList.add("bbbb");
stringList.add("ccccc");
stringList.add("d");
//将列表中，长度大于3的字符串返回
System.out.println(tx(predicate,stringList));
}
//使用断言型接口过滤长度大于3的字符串，并返回
public static List<String> tx(Predicate<String> predicate,List<String> stringList){
List<String> list = new ArrayList<>();
for (int i=0;i<stringList.size();i++){
String str = stringList.get(i);
//使用断言型接口判断数据是否满足条件
if(predicate.test(str)){
list.add(str);
}
}
return list;
}
}
布局&运行结果：
559
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
