关于jdk8的改变大体有对lambda表达式(紧跟函数式编程方式潮流,其实也是对设计模式的一种简化,比如函数式接口的使用你能够感受到和策略模式很相似,并且写法更加优雅)简化很多啰嗦的代码,还有就是流的操作,类似把集合当做数据库,java的流操作当做写SQL,这样方便对集合的数据进行操作,当然对JDK的升级还有很多,这里只是小结一些常用的.
Gitee https://gitee.com/zhang-xiao-xiang/all-demo-parent.git 里面的javabase包下jdk8
语法格式如下:
语法阐述:
->左边:lambda形参列表的参数类型可以省略(类型推断);如果lambda形参列表只有一个参数,其一对()也可以省略
->右边:lambda体应该使用一对{}包裹;如果lambda体只有一条执行语句(可能是return语句),省略这一对{}和return关键字
Lambda表达式的本质:作为函数式接口的实例
如果一个接口中,只声明了一个抽象方法,则此接口就称为函数式接口。我们可以在一个接口上使用 @FunctionalInterface 注解,
这样做可以检查它是否是一个函数式接口。
所以以前用匿名实现类表示的现在都可以用Lambda表达式来写
1:简单lambda表达式试用
package com.zhang.zxx.jdk8.lambda;
import org.junit.Test;
import java.util.Comparator;
/**
* LambdaTest:Lambda表达式的使用举例
*
* @author zhangxiaoxiang
* @date 2020/10/8
*/
public class LambdaTest {
/**
* 例子1 没有入参,没有返回值的一个例子=>Runnable线程的类为例子
*/
@Test
public void test1() {
/**
* 没有使用lambda表达式的写法(其实idea会提示使用)线程的匿名实现类的写法
*/
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("我执行常规写法,匿名实现的写法!");
}
};
r1.run();
Runnable r2 = () -> System.out.println("我执行jdk8提供的lambda写法");
r2.run();
}
/**
* 例子2 有入参有返回值的一个例子=>Comparator用于比较的类为例子
*/
@Test
public void test2() {
Comparator<Integer> com1 = new Comparator<Integer>() {
/**
* compare方法比较2这个
* @param o1 待比较的数o1
* @param o2 待比较的数o2
* @return o1比o2大返回1小则返回-1,相等返回0
*/
@Override
public int compare(Integer o1, Integer o2) {
return Integer.compare(o1, o2);
}
};
int compare1 = com1.compare(12, 21);
System.out.println("原始写法***********************");
System.out.println("常规写法的返回(12比21小,所以这里返回 -1): " + compare1);
//Lambda表达式的写法(还可以改.idea会提示你)
Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1, o2);
int compare2 = com2.compare(32, 21);
System.out.println("Lambda表达式的写法(常规一点的)***********************");
System.out.println("常规一点的的返回(32比21大返回 1): " + compare2);
Comparator<Integer> com3 = Integer::compare;
int compare3 = com3.compare(32, 32);
System.out.println("Lambda表达式的写法(方法引用的方式)***********************");
System.out.println("Lambda表达式方法引用返回(32和32相等返回 0): " + compare3);
}
}
2:多种lambda表达式详细写法小结
package com.zhang.zxx.jdk8.lambda;
import org.junit.Test;
import java.util.Comparator;
import java.util.function.Consumer;
/**
* Lambda1Test:多钟Lambda写法举例
*
* @author zhangxiaoxiang
* @date 2020/10/8
*/
public class Lambda1Test {
/**
* 语法格式一:(最简洁性)无参,无返回值
*/
@Test
public void test1() {
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("语法格式一:无参,无返回值");
}
};
r1.run();
System.out.println("***********************");
Runnable r2 = () -> {
System.out.println("语法格式一:无参,无返回值");
};
r2.run();
}
/**
* 语法格式二:(消费型)需要一个参数,但是没有返回值。
*/
@Test
public void test2() {
Consumer<String> con = new Consumer<String>() {
/**
*
* @param s 待消费的参数,注意没有返回值
*/
@Override
public void accept(String s) {
System.out.println(s);
}
};
con.accept("我是普通写法的入参");
System.out.println("*******************");
//如果只有一段简单的实现代码,{}也可以不要 Consumer<String> con1 = (String s) -> {System.out.println(s);};
// 这里idea会提示Lambda can be replaced with method reference ,可以使用方法写法引用替代,在后面会有示例,这里就保持这种写法
Consumer<String> con1 = (String s) -> System.out.println(s);
con1.accept("我是Lambda写法的入参,左边是形参 ->右边是实现,将参数消费");
}
/**
* 语法格式三:(类型推断型)数据类型可以省略,因为可由编译器推断得出,称为“类型推断”,双冒号::写法
*/
@Test
public void test3() {
//idea会建议Lambda can be replaced with method reference
Consumer<String> con1 = (String s) -> {
System.out.println(s);
};
con1.accept("数据类型可以省略,类型推断的入参");
System.out.println("*******************");
//这就是idea建议的Lambda的方法引用method reference 写法
Consumer<String> con2 = System.out::println;
con2.accept("::就是方法引用的方式,称为“类型推断”的入参");
}
/**
* 语法格式四:(单参数不要括号)Lambda 若只需要一个参数时,参数的小括号可以省略
*/
@Test
public void test4() {
Consumer<String> con1 = (s) -> {
System.out.println(s);
};
con1.accept("Lambda还可以进一步简化的入参");
System.out.println("*******************");
Consumer<String> con2 = System.out::println;
con2.accept("Lambda 若只需要一个参数时,参数的小括号可以省略的入参");
}
/**
* 语法格式五:(多参数并带返回值)Lambda 需要两个或以上的参数,多条执行语句,并且可以有返回值
*/
@Test
public void test5() {
Comparator<Integer> com1 = new Comparator<Integer>() {
/**
* compare方法比较2这个
* @param o1 待比较的数o1
* @param o2 待比较的数o2
* @return o1比o2大返回1小则返回-1,相等返回0
*/
@Override
public int compare(Integer o1, Integer o2) {
System.out.println("两个入参分别是:" + o1 + " " + o2);
return o1.compareTo(o2);
}
};
System.out.println("常规写法比较结果(12比21小返回-1): " + com1.compare(12, 21));
System.out.println("*****************************");
Comparator<Integer> com2 = (o1, o2) -> {
System.out.println("两个入参分别是:" + o1 + " " + o2);
return o1.compareTo(o2);
};
System.out.println("Lambda写法比较结果(12比21小返回-1): " + com2.compare(12, 21));
}
/**
* 语法格式六:当 Lambda 体只有一条语句时,return 与大括号若有,都可以省略
*/
@Test
public void test6() {
Comparator<Integer> com1 = (o1, o2) -> {
return o1.compareTo(o2);
};
System.out.println(com1.compare(12, 21));
System.out.println("*****************************");
//Lambda 体只有一条语句时,return 与大括号若有,都可以省略
Comparator<Integer> com2 = (o1, o2) -> o1.compareTo(o2);
System.out.println(com2.compare(12, 21));
//在进一步使用方法引用(推荐)
Comparator<Integer> com3 = Integer::compareTo;
System.out.println(com3.compare(12, 21));
}
}
3:java内置函数式接口(Consumer和Predicate为例子)
package com.zhang.zxx.jdk8.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;
/**
* LambdaTest2 :内置函数式接口(Consumer和Predicate为例子)
* <p>
* 消费型接口 Consumer<T> void accept(T t)
* 供给型接口 Supplier<T> T get()
* 函数型接口 Function<T,R> R apply(T t)
* 断定型接口 Predicate<T> boolean test(T t)
*
* @author zhangxiaoxiang
* @date 2020/10/8
*/
public class Lambda2Test {
/**
* 消费型接口 输入参数有因无果,被消费了你说气了不气人
*
* @param money 金额
* @param con 消费业务
*/
public void happyTime(double money, Consumer<Double> con) {
con.accept(money);
}
/**
* 测试消费型
*/
@Test
public void test1() {
happyTime(500, new Consumer<Double>() {
@Override
public void accept(Double aDouble) {
System.out.println("消费输出:您老消费的价格是" + aDouble);
}
});
System.out.println("********************");
happyTime(400, money -> System.out.println("消费输出:您老消费的价格是:" + money));
}
/**
* 断定型接口
* 根据给定的规则,过滤集合中的字符串。此规则由Predicate的方法决定
*
* @param list 给定基础数据数据
* @param pre 断定规则
* @return
*/
public List<String> filterString(List<String> list, Predicate<String> pre) {
ArrayList<String> filterList = new ArrayList<>();
for (String s : list) {
//这个test()方法是判断是否包含:根据给定参数评估该谓词
if (pre.test(s)) {
filterList.add(s);
}
}
return filterList;
}
/**
* 测试断定型接口
*/
@Test
public void test2() {
List<String> list = Arrays.asList("北京", "南京", "天津", "东京", "西京", "普京");
List<String> filterStrS = filterString(list, new Predicate<String>() {
@Override
public boolean test(String s) {
return s.contains("京");
}
});
System.out.println("将含有京的筛选出来:"+filterStrS);
List<String> filterStrS1 = filterString(list, s -> s.contains("京"));
System.out.println("将含有京的筛选出来:"+filterStrS1);
}
}
4:自定义函数式接口
package java1;
/**
* MyInterface:自定义函数式接口
*
* @author zhangxiaoxiang
* @date 2019/9/8
*/
@FunctionalInterface
public interface MyInterface {
void method1();
// void method2();
}