lambda 表达式
匿名函数, 可以理解为一段可以传递的代码
转换的规则: 删去能够确定(or可以通过推断得出)的东西（例: 只有一个函数, 那么不需要写函数名）
实质:
-
一方面, lambda 表达式作为接口的实现类的对象
-
一方面, lambda 表达式为匿名函数
(万物皆对象)
```java
/**
* lambda 表达式的使用
* (x, x) -> xx
* -> : lambda操作数 or 箭头操作符
* ->的左边是lambda的形参列表, 对应要重写接口仲的抽象方法的形参列表
* ->的右边是lambda体, 对应接口实现类要重写的方法的方法体
*/
// 当只有一个方法时, 才不需要写方法名. 不然分不清使用哪一个方法
```
- 无参, 无返回值
```java
@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(); // 调用线程
}
```
运行结果:
- 1个形参, 没有返回值
```java
@Test
public void test2(){
Comparator<Integer> com1 = new Comparator<Integer>() { // 匿名实现类
@Override
public int compare(Integer o1, Integer o2) {
return Integer.compare(o1, o2);
}
};
int compare1 = com1.compare(1,3); // 比较对象大小
System.out.println(compare1); // 前一个数小 -> -1
System.out.println("====================");
// 只有一个方法 不需要写方法名(省略确定的东西, 如 Integer, @override ...)
Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1, o2); // lambda 表达式
int compare2 = com2.compare(5,3); // 比较对象大小
System.out.println(compare2); // 后一个数小 -> 1
}
```
运行效果:
- 数据类型可以省略, 由编译器推断得出, 称为"类型判断"
```java
@Test
public void test03(){
Consumer<String> con1 = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println("hey man nice to meet you "+s);
}
};
con1.accept("none"); // 调用方法
Consumer<String> con2 = (String s) -> {
System.out.println(s);
};
con2.accept("nice to meet you, bro");
Consumer<String> con3 = (s) -> { // 类型可以被推断（泛型, 数组..） 所以可以不用写
// 当然这里可以运用方法引用 System.out::println;
System.out.println(s);
};
con3.accept("nice to meet you");
}
```
运行效果:
-
若函数需要一个参数时, 其小括号可以省略
-
lambda需要≥2个参数, 执行多条语句, 并且可以有返回值
```java
@Test
public void test5(){
Comparator<Integer> com1 = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
}
};
System.out.println(com1.compare(12,22)); // 前面小 会输出 -1
System.out.println("=========================");
Comparator<Integer> com2 = (o1, o2)-> { // {} 为lambda体
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
};
System.out.println(com2.compare(22,11)); // 方法调用, 后面小, 会输出 1
}
```
运行效果:
- lambda体只有一条语句时, return 与 {} 若有, 可以省略
```java
@Test
public void test6(){
Comparator<Integer> com1 = (o1, o2) ->{
return o1.compareTo(o2);
};
System.out.println(com1.compare(12,4));
System.out.println("=====================");
Comparator<Integer> com2 = (o1, o2) -> o1.compareTo(o2); // 可以使用方法引用 Integer :: compareTo
System.out.println(com2.compare(4,21));
}
```
运行效果:
JUnit单元测试的使用
- 需要导入的jar包 [下载地址](https://jar-download.com/artifacts/junit/junit)
- 导入 (IDEA的话就通过 File -> Project Structure -> Libraries-> 按下`+` Java, 选择对应的文件夹, 需包含👆上面两个 jar 包) 然后·在Modules里对应的地方打勾即可
- 创建单元测试类, 进行测试 (可以不使用main函数的情况下 测试某一部分代码的功能) 测试的注解一般是 @Test
- 编写单元测试方法