一、闲话
Java8已经出来很久了，今天闲来无事，将它整理一下，方便后面工作中查阅
Java8有着很多优点
- 它的速度更快
- 因为lambda表达式的出现，使得代码更少
- 便于并行
- 强大的Stream API
- Optional类可以最大程度减少空指针
二、Lambda表达式
1、组成部分
主要组成部分：
Lambda形参列表（其实就是接口中抽象方法的形参列表）->操作符Lambda方法体（其实就是重写的抽象方法的方法体）
2、Lambda表达式的语法
- 无参数，无返回值
- 有一个参数，无返回值
- Lambda表达式的参数列表的数据类型可以省略，因为JVM编译器可以推断初数据类型，即类型判断
- 只有一个参数时，左侧参数的括号可省略
- 有两个以上的参数，有返回值，并且Lambda函数体中有多条语句
- 如果方法体中只有一条执行语句，那么右侧的大括号和return都可以省略
package com.decade.java8.lambda;
import org.junit.Test;
import java.util.Comparator;
import java.util.function.Consumer;
public class Lambda1 {
@Test
public void test1() {
// 语法一：无参无返回值，可以写成
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("execute r1");
}
};
r1.run();
System.out.println("==============================");
Runnable r2 = () -> {
System.out.println("execute r2");
};
r2.run();
}
@Test
public void test2() {
// 语法二：有一个参数，无返回值，可以写成
Consumer<String> c1 = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
c1.accept("execute c1");
System.out.println("===============================");
Consumer<String> c2 = (String input) -> {
System.out.println(input);
};
c2.accept("execute c2");
}
@Test
public void test3() {
// 语法三：lambda表达式的参数列表的数据类型可以省略，因为JVM编译器可以推断出数据类型，即类型判断
Consumer<String> c3 = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
c3.accept("execute c3");
System.out.println("===============================");
Consumer<String> c4 = (input) -> {
System.out.println(input);
};
c4.accept("execute c4");
}
@Test
public void test4() {
// 语法四：只有一个参数时，左侧参数的括号可省略，可以写成
Consumer<String> c5 = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
c5.accept("execute c5");
System.out.println("===============================");
Consumer<String> c6 = input -> {
System.out.println(input);
};
c6.accept("execute c6");
}
@Test
public void test5() {
// 有两个以上的参数，有返回值，并且lambda函数体中有多条语句时，可以写成
Comparator<Integer> comparator = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1.compareTo(o2);
}
};
System.out.println(comparator.compare(8, 10));
System.out.println("================================");
Comparator<Integer> comparator2 = (o1, o2) -> {
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
};
System.out.println(comparator2.compare(8, 10));
}
@Test
public void test6() {
// 语法六：如果方法体中只有一条执行语句，那么右侧的大括号和return都可以省略
Comparator<Integer> comparator3 = (o1, o2) -> {
return o1.compareTo(o2);
};
System.out.println(comparator3.compare(10, 8));
System.out.println("===================================");
Comparator<Integer> comparator4 = (o1, o2) -> o1.compareTo(o2);
System.out.println(comparator4.compare(10, 8));
}
}
3、Lambda表达式的本质
作为函数式接口的实例，以前用匿名实现类表示的现在都可以使用Lambda表达式来写
4、函数式接口
1）定义
使用@FunctionalInterface修饰， 有且仅有一个 抽象方法的接口就称为函数式接口
可以使用@FunctionalInterface检查是否是函数式接口
假设接口中有不止一个抽象方法，那么该注解就会爆红
// 函数式接口
@FunctionalInterface
public interface Intfunction{
T apply(int a);
}
// 调用函数式接口的类：
public class Test{
public static Object test(int a, IntFunction intFunction){
return intFunction.apply(i);
}
public static void main(String args[]){
Test.test(1, (int 1)->{
return 1;
});
}
}
2）Java内置四大核心函数式接口
Consumer（消费型接口）：接受一个参数，无返回结果Supplier（供给型接口）：无参数，返回一个结果Function（函数型接口）：传一个参数，返回一个结果Pridicate（断定型接口）：接受一个参数，返回一个boolean值
package com.decade.java8.lambda;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
/**
* Java内置四大函数式接口
*
* 消费型接口 Consumer<T> void accept(T t)：传入一个类型为T的参数，不返回结果
* 供给型接口 Supplier<T> T get()：不传入参数，返回一个类型为T的结果
* 函数型接口 Function<T,R> R apply(T t)：传入一个类型为T的参数，返回一个类型为R的结果
* 断定型接口 Predicate<T> boolean test(T t)：传入一个类型为T的参数，判断其是否满足某个约束，返回boolean值
*/
public class Lambda2 {
@Test
public void test1() {
buyGoods(500, new Consumer<Double>() {
@Override
public void accept(Double aDouble) {
System.out.println("我在超市买了点东西，花了" + aDouble);
}
});
System.out.println("=====================================");
// 使用lambda表达式
buyGoods(400, r -> System.out.println("我在超市买了点东西，花了" + r));
}
public void buyGoods(double money, Consumer<Double> consumer) {
consumer.accept(money);
}
@Test
public void test2() {
List<String> stringList = Arrays.asList("北京","南京","纽约","巴黎");
final List<String> result = filterString(stringList, new Predicate<String>() {
@Override
public boolean test(String s) {
return s.contains("京");
}
});
System.out.println(result);
System.out.println("=====================================");
// 使用lambda表达式
List<String> result2 = filterString(stringList, s -> s.contains("京"));
System.out.println(result2);
}
// 根据给定约束过滤字符串，此规则由Predicate的test方法决定
public List<String> filterString(List<String> strings, Predicate<String> predicate) {
List<String> list = new ArrayList<>();
// 如果满足predicate中的test方法，那么就将当前元素加入结果集
for(String s : strings) {
if (predicate.test(s)) {
list.add(s);
}
}
return list;
}
}
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。
文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/136721.html
