文章目录:
1.Lambda表达式
2.方法的引用和构造器的引用
3.Stream
4.新时间日期API
5.Optional类
一、Lambda表达式基础语法
java8引入了一个新的操作符 “->” 改操作符称为箭头操作符 或 Lambda操作符。
箭头操作符将 Lambda 表达式拆分成两部分:
- 左侧:Lambda表达式的参数列表。
- 右侧:Lambda表达式中所需执行的功能,即Lambda体。
语法:
- 一个括号内用逗号分隔的形式参数,参数是函数式接口里面方法的参数。
- 一个箭头符号:->
- 方法体,可以是表达式和代码块,方法体函数式接口里面方法的实现,如果是代码块,则必须用{}来包裹起来,且需要一个return 返回值,但有个例外,若函数式接口里面方法返回值是void,则无需{}。
语法格式一:
- 无参数,无返回值:
@Test
public void test1(){
int num = 0;//jdk 1.7 前,必须是 final
Runnable r = new Runnable() {
@Override
public void run() {
System.out.println("Hello World!" + num);
}
};
r.run();
System.out.println("-------------------------------");
Runnable r1 = () -> System.out.println("Hello Lambda!");
r1.run();
}
输出结果:
Hello World!0
-------------------------------
Hello Lambda!
语法格式二:
- 有一个参数,无返回值(如果只有一个参数,小括号可以省略不写。):
@Test
public void test01(){
Consumer<String> con = (x) -> System.out.println(x);
con.accept("积极上进!");
}
输出结果:
积极上进!
语法格式三
- 有两个以上的参数,有返回值,并且Lambda体中有多条语句(必须用{}括起来)。
@Test
public void test05(){
Comparator<Integer> com = (x, y) -> {
System.out.println("函数式接口");
return Integer.compare(x, y);
};
com.compare(1,5);
}
输出结果:
函数式接口
语法格式四
- 若Lambda体中只有一条语句,return和大括号都可以省略不写。
@Test
public void test03(){
Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
int compare = com.compare(5, 100);
System.out.println(compare);
}
输出结果:
-1
语法格式五
- Lambda表达式的参数列表的数据类型可以省略不写,因为JVM编译器通过上下文推断出类型数据,即“类型推断”。
(Integer x, Integer y) -> Integer.compare(x, y)
总结:
- 左右遇一括号省
- 左侧推断类型省
二、Lambda表达式需要“函数式接口”的支持
- 函数式接口
首先是一个接口,然后就是在这个接口里面只能有一个抽象方法。
这种类型的接口也称为SAM接口,即Single Abstract Method interfaces。
可以使用注解@FunctionalInterface修饰,检查是否是函数式接口。
@FunctionalInterface
public interface MyFun {
public Integer getValue(Integer num);
}
//需求:对一个数进行运算
@Test
public void test6(){
Integer num = operation(100, (x) -> x * x);
System.out.println(num);
System.out.println(operation(200, (y) -> y + 200));
}
public Integer operation(Integer num, MyFun mf){
return mf.getValue(num);
}
输出结果:
10000
400
三、Java8 内置的四大核心函数式接口
void accept(T t);
T get();
3. Function<T, R> 函数型接口(有参,有返回值):
R apply(T t);
4. Predicate : 断言型接口(用于判断,有参,返回boolean类型):
boolean test(T t);
示例(点击上方超链接跳转到对应示例)
/**
* 1、Consumer<T> : 消费型接口(有参,无返回值)
*/
@Test
public void test01(){
happy(1000, (x) -> System.out.println("吃喝玩乐" + x +"元!"));
}
public void happy(double mon, Consumer<Double> con){
con.accept(mon);
}
运行结果:
吃喝玩乐1000.0元!
/**
* 2、Supplier<T> : 供给型接口(无参,有返回值)
* 需求:产生指定个数的整数,并放入集合中。
*/
@Test
public void test02(){
List<Integer> numList = getNumList(5, () -> (int)(Math.random() * 100));
for (Integer integer : numList) {
System.out.println(integer);
}
}
public List<Integer> getNumList(int num, Supplier<Integer> sup){
List<Integer> newList = new ArrayList<>();
for(int i = 0; i < num; i++){
Integer n = sup.get();
newList.add(n);
}
return newList;
}
运行结果:
40
40
85
82
36
/**
* 3、Function<T, R> 函数型接口(有参,有返回值):
* 需求:用于处理字符串(取字符串[2,4))
*/
@Test
public void Test03(){
String newStr = strHandler("中国山东青岛", (str) -> str.substring(2, 4));
System.out.println(newStr);
}
public String strHandler(String str, Function<String,String> fun){
return fun.apply(str);
}
运行结果:
山东
/**
* 4、Predicate<T> : 断言型接口(用于判断):
* 将满足条件的字符串(字符串长度大于3的),放入集合中
*/
@Test
public void test04(){
List<String> list = Arrays.asList("Hello", "World", "ok", "a", "true");
List<String> newList = filterStr(list, (str) -> str.length() > 3);
for (String str : newList) {
System.out.println(str);
}
}
public List<String> filterStr(List<String> list, Predicate<String> pre){
List<String> strList = new ArrayList<>();
for (String str : list) {
if(pre.test(str)){
strList.add(str);
}
}
return strList;
}
运行结果:
Hello
World
true