我们首先看一个java实现多线程的lambda表达式的例子
常规
Runnable runnable = new Runnable(){
@Override
public void run() {
System.out.println("多线程");
}};
lambda形式
Runnable runnable = () -> {
System.out.println("多线程");
};
简洁
此方法使用的场景只能是实现的方法中只有一行语句。
Runnable runnable = () -> System.out.println("多线程");
Lambda在Collections中的用法
public class StreamExample {
public static void main(String[] args) {
List<Integer> myList = new ArrayList<>();
for(int i=0; i<100; i++) myList.add(i);
//有序流
Stream<Integer> sequentialStream = myList.stream();
//并行流
Stream<Integer> parallelStream = myList.parallelStream();
//使用lambda表达式，过滤大于90的数字
Stream<Integer> highNums = parallelStream.filter(p -> p > 90);
//lambdag表达式 forEach循环
highNums.forEach(p -> System.out.println("最大数 并行="+p));
Stream<Integer> highNumsSeq = sequentialStream.filter(p -> p > 90);
highNumsSeq.forEach(p -> System.out.println("最大数 有序="+p));
}
}
输出结果
最大数 并行=91
最大数 并行=96
最大数 并行=93
最大数 并行=98
最大数 并行=94
最大数 并行=95
最大数 并行=97
最大数 并行=92
最大数 并行=99
最大数 有序=91
最大数 有序=92
最大数 有序=93
最大数 有序=94
最大数 有序=95
最大数 有序=96
最大数 有序=97
最大数 有序=98
最大数 有序=99
为什么要使用Lambda表达式
1.简化代码行数
2.顺序执行或并行执行
以下为例子之间的对照
//传统形式
private static boolean isPrime(int number) {
if(number < 2) return false;
for(int i=2; i<number; i++){
if(number % i == 0) return false;
}
return true;
}
//使用表达式的
private static boolean isPrime(int number) {
return number > 1
&& IntStream.range(2, number).noneMatch(
index -> number % index == 0);
}
为了更好的可读性，我们还可以这么写
private static boolean isPrime(int number) {
IntPredicate isDivisible = index -> number % index == 0;
return number > 1
&& IntStream.range(2, number).noneMatch(
isDivisible);
}
我们来看一个计算数字集合总合的例子，它有一个参数将用来传递表达式后处理得到最终的结果。
public static int sumWithCondition(List<Integer> numbers, Predicate<Integer> predicate) {
return numbers.parallelStream()
.filter(predicate)
.mapToInt(i -> i)
.sum();
}
比如我们将传递这样的如下条件
//统计所有数字总合
sumWithCondition(numbers, n -> true)
//统计所有偶数总合
sumWithCondition(numbers, i -> i%2==0)
//统计所有大于5的总合
sumWithCondition(numbers, i -> i>5)
接下来我再来看一个更加偷懒的Lambda表达式
//找出3-11之间最大的奇数，并求它的平方
private static int findSquareOfMaxOdd(List<Integer> numbers) {
int max = 0;
for (int i : numbers) {
if (i % 2 != 0 && i > 3 && i < 11 && i > max) {
max = i;
}
}
return max * max;
}
我们使用Lambada重写它
class NumberTest{
public static int findSquareOfMaxOdd(List<Integer> numbers) {
return numbers.stream()
.filter(NumberTest::isOdd)
.filter(NumberTest::isGreaterThan3)
.filter(NumberTest::isLessThan11)
.max(Comparator.naturalOrder())
.map(i -> i * i)
.get();
}
public static boolean isOdd(int i) {
return i % 2 != 0;
}
public static boolean isGreaterThan3(int i){
return i > 3;
}
public static boolean isLessThan11(int i){
return i < 11;
}
}
Lambada表达式例子
() -> {} // 没有参数，没有返回值
() -> 42 // 没有参数，方法体有表达式
() -> null // 没有参数，方法体有表达式
() -> { return 42; } // 没有参数，方法体有返回值
() -> { System.gc(); } // 没有参数，有方法体
// 有多种返回值
() -> {
if (true) return 10;
else {
int result = 15;
for (int i = 1; i < 10; i++)
result *= i;
return result;
}
}
(int x) -> x+1 // 单个参数
(int x) -> { return x+1; } // 单个参数，跟上面一样
(x) -> x+1 // 单个参数，跟下面一样
x -> x+1
(String s) -> s.length()
(Thread t) -> { t.start(); }
s -> s.length()
t -> { t.start(); }
(int x, int y) -> x+y // 多个参数，有返回值
(x,y) -> x+y // 跟上面一样
(x, final y) -> x+y // 多个参数，有不能修改的参数
(x, int y) -> x+y // 这个是非法的，不能混合写
方法跟构造函数可以用下面这种方式
System::getProperty
System.out::println
"abc"::length
ArrayList::new
int[]::new
