1:lambda表达式入门
提供的接口有四种:
->Function<T,R>接受一个参数T,返回一个参数R
->Consumer<T>接受一个参数T,无返回值
->Supplier<T>不接受参数,返回一个参数T
->Predicate<T>接受一个参数T,返回boolean值
代码如下:
/***
* ---------------初级入门---------------
*/
// 01:Function<T,R>函数接口:接受一个参数T,返回一个参数R
Function<Integer,Integer> function = p -> p * 10;
System.out.println(function.apply(2));
// 02:Consumer<T>函数接口:接受一个参数T,没有返回
Consumer<String> consumer = p -> System.out.println(p);
consumer.accept("你好啊,我是lambda表达式");
// 03:Predicate<T>函数接口:接受一个参数T,返回一个boolean值
Predicate<Integer> predicate = (a) -> a > 10;
System.out.println(predicate.test(1));
// 04:Supplier<T>函数接口:不接受参数,返回一个参数T
Supplier<Integer> supplier = () -> 100;
System.out.println(supplier.get());
运行结果:
当然,你还可以自定义函数接口
1:自定义的函数接口需要用@FunctionalInterface注解
2:然后自定义一个抽象方法
例:自定义了一个函数接口MyLambda <T,E,R>接受两个参数T,E,返回一个参数R
自定义的函数接口:
@FunctionalInterface
public interface MyLambda<T,E,R> {
// 自定义一个函数接口,接受两个参数T,E,返回参数R
R num(T t,E e);
}
代码:
// 05:自定义函数接口:需要自定义一个接口,用上@FunctionalInterface注解
MyLambda<Integer,Integer,Integer> myLambda = (a,b) -> a + b;
System.out.println(myLambda.num(1,2));
运行结果:
以上,就是Lambda的简单入门。Lambda的表达式不用我多说了(箭头左边是参数,箭头右边是方法体)
结合集合一起用:
在网上复制了一个字符数组,让我们来看看怎么用Lambda表达式循环变量字符数组,然后在和增强for比一下效率
代码如下:
String[] players = {"Rafael Nadal", "Novak Djokovic",
"Stanislas Wawrinka", "David Ferrer",
"Roger Federer", "Andy Murray",
"Tomas Berdych", "Juan Martin Del Potro",
"Richard Gasquet", "John Isner"};
long currtenTime = System.currentTimeMillis();
// 01:给这个数组排序
Arrays.sort(players,(p1,p2) -> p1.compareTo(p2));
// Arrays.asList(players).forEach((p) -> System.out.println(p));
for(String s : players){
System.out.println(s);
}
long oldTime = System.currentTimeMillis();
System.out.println("相差时间:" + (oldTime - currtenTime));
查看结果:
这是使用增强for的遍历
这是使用lambda表达式的遍历
发现效率差不多,就问你们lambda表达式骚不骚,三行增强for的代码变成了一句代码。爽不爽!匿名内部类的自定义排序也在使用lambda表达式的情况下,变成了一句代码,感觉如何?
打上注释的是lambda表达式
lambda也可以用来代替匿名内部类
代码如下:
// 定义一个字符数组
String[] players = {"Rafael Nadal", "Novak Djokovic",
"Stanislas Wawrinka", "David Ferrer",
"Roger Federer", "Andy Murray",
"Tomas Berdych", "Juan Martin Del Potro",
"Richard Gasquet", "John Isner"};
// 01:给这个数组排序,然后遍历输出(根据字符串的大小)
Arrays.sort(players,(p1,p2) -> p1.compareTo(p2));
Arrays.asList(players).forEach((p) -> System.out.println(p));
System.out.println("-------------------------");
// 02:根据字符串的长度排序\
Arrays.sort(players,(p1,p2) -> p1.length() - p2.length());
Arrays.asList(players).forEach((p) -> System.out.println(p));
System.out.println("-------------------------");
// 03:根据字符串最后一个字符
Arrays.sort(players,(p1,p2) -> p1.charAt(p1.length() - 1) - p2.charAt(p2.length() - 1));
Arrays.asList(players).forEach((p) -> System.out.println(p));
是不是感觉简单明了,还略带有点骚气。(唯一就是有点不好,可读性不是很好)
lambda表达式整合集合一起使用:
Person类:
public class Person {
private String firstName, lastName, job, gender;
private int age;
private double salary;
public Person(String firstName, String lastName, String job,
String gender, int age, int salary) {
this.firstName = firstName;
this.lastName = lastName;
this.gender = gender;
this.age = age;
this.job = job;
this.salary = salary;
}
代码如下:
给每个人涨薪资20%,用lambda表达式:
/**
* 给每个人的薪资涨20%
* 1:很容易的我们就想到了用Consumer函数接口来接受增长后的薪资(传入一个参数,没有返回值)
* 2:获取到增长后的薪资后,forEach设置
* 3:最后forEach获取
*/
long currentTime = System.currentTimeMillis();
Consumer<Person> consumer = p -> p.setSalary(p.getSalary() + (p.getSalary() / 100 * 20));
javaProgrammers.forEach(consumer);
javaProgrammers.forEach(p -> System.out.println(p.getFirstName() + " " + p.getSalary()));
long nowTime = System.currentTimeMillis();
System.out.println("相差时间:" + (nowTime - currentTime));
运行结果:
1.8之前的用法:
long currentTime = System.currentTimeMillis();
// Consumer<Person> consumer = p -> p.setSalary(p.getSalary() + (p.getSalary() / 100 * 20));
// javaProgrammers.forEach(consumer);
// javaProgrammers.forEach(p -> System.out.println(p.getFirstName() + " " + p.getSalary()));
for(int i=0; i< javaProgrammers.size(); i++){
Person person = javaProgrammers.get(i);
person.setSalary(person.getSalary() + (person.getSalary() / 100 * 20));
System.out.println(person.getFirstName() + " " + person.getSalary());
}
long nowTime = System.currentTimeMillis();
System.out.println("相差时间:" + (nowTime - currentTime));
运行结果:
配合Stream一起使用:
/**
* 获取所有的女人
* 1:很容易的我们就想到了Predicate函数接口来获取所有的女程序员(传入一个参数,返回boolean值)
*/
System.out.println("所有的女人:");
Predicate<Person> female = p -> p.getGender().equals("female");
javaProgrammers.stream().filter(female).forEach(p -> System.out.println(p.getFirstName() + " " + p.getGender()));
System.out.println();
/**
* 获取月薪超过1400的人
* 1:很容易的我们就想到了Predicate函数接口来获取所有的女程序员(传入一个参数,返回boolean值)
*/
System.out.println("所有月薪超过1400的人:");
Predicate<Person> personPredicate = p -> (p.getSalary() > 1400);
javaProgrammers.stream().filter(personPredicate).forEach(p -> System.out.println(p.getFirstName() + " " + p.getSalary()));
System.out.println();
/**
* 获取月薪超过1400的女人
*/
System.out.println("月薪超过1400的女人:");
javaProgrammers.stream().filter(female).filter(personPredicate).forEach(p -> System.out.println(p.getFirstName() + " " + p.getSalary()));
System.out.println();
/**
* 按着年龄来排序
*/
System.out.println("按着年龄来排序 ");
javaProgrammers.stream().sorted((p1,p2) -> (p1.getAge() - p2.getAge())).forEach(p -> System.out.println(p.getFirstName() + " " +p.getAge()));
System.out.println();
/**
* 获取年龄最小的三个人
*/
System.out.println("获取年龄最小的三个人:");
javaProgrammers.stream().sorted((p1,p2) -> p1.getAge() - p2.getAge()).limit(3L).forEach(p -> System.out.println(p.getFirstName() + " " +p.getAge()));
System.out.println();
/**
* 获取最高的薪资
*/
System.out.println("获取最高的薪资:");
Person person = javaProgrammers.stream().max((p1, p2) -> new Double(p1.getSalary()).intValue() - new Double(p2.getSalary()).intValue()).get();
System.out.println(person.getFirstName() + " " + person.getSalary());
运行结果:
运行结果不就截图完了;
由于实习期间接触的项目用的还是1.7,所以lambda表达式先学到了这吧到时候用到了再总结吧!
毕竟贪多嚼不透。