Java 8 新特性 Ⅰ

## lambda 表达式

匿名函数, 可以理解为一段可以传递的代码

转换的规则: 删去能够确定(or可以通过推断得出)的东西（例: 只有一个函数, 那么不需要写函数名）

实质:

-   一方面, lambda 表达式作为接口的实现类的对象

-   一方面, lambda 表达式为匿名函数

    (万物皆对象)

```java
/**
 * lambda 表达式的使用
 * (x, x) -> xx
 * -> : lambda操作数 or 箭头操作符
 * ->的左边是lambda的形参列表, 对应要重写接口仲的抽象方法的形参列表
 * ->的右边是lambda体, 对应接口实现类要重写的方法的方法体 
 */
// 当只有一个方法时, 才不需要写方法名. 不然分不清使用哪一个方法
```

1.  无参, 无返回值

```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(); // 调用线程
}
```

运行结果:


2.  1个形参, 没有返回值

```java
@Test
public void test2(){
   Comparator com1 = new Comparator() { // 匿名实现类
       @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 com2 = (o1, o2) -> Integer.compare(o1, o2); // lambda 表达式
   int compare2 = com2.compare(5,3); // 比较对象大小
   System.out.println(compare2); // 后一个数小 -> 1
}
```

运行效果:


3.  数据类型可以省略, 由编译器推断得出, 称为"类型判断"

```java
@Test
public void test03(){
    Consumer con1 = new Consumer() {
        @Override
        public void accept(String s) {
            System.out.println("hey man nice to meet you "+s);
        }
    };
    con1.accept("none"); // 调用方法
    Consumer con2 = (String s) -> {
        System.out.println(s);
   };
   con2.accept("nice to meet you, bro");
   Consumer con3 = (s) -> { // 类型可以被推断（泛型, 数组..） 所以可以不用写
       // 当然这里可以运用方法引用 System.out::println;
       System.out.println(s);
   };
   con3.accept("nice to meet you");
}
```

运行效果:


4.  若函数需要一个参数时, 其小括号可以省略
5.  lambda需要≥2个参数, 执行多条语句, 并且可以有返回值

```java
@Test
public void test5(){
    Comparator com1 = new Comparator() {
        @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 com2 = (o1, o2)-> {         // {} 为lambda体
        System.out.println(o1);
        System.out.println(o2);
        return o1.compareTo(o2);
    };
    System.out.println(com2.compare(22,11)); // 方法调用, 后面小, 会输出 1
}
```

运行效果:


6.  lambda体只有一条语句时, return 与 {} 若有, 可以省略

```java
@Test
public void test6(){
    Comparator com1 = (o1, o2) ->{
        return o1.compareTo(o2);
    };
    System.out.println(com1.compare(12,4));
    System.out.println("=====================");
    Comparator com2 = (o1, o2) -> o1.compareTo(o2); // 可以使用方法引用 Integer :: compareTo
    System.out.println(com2.compare(4,21));
}
```

运行效果:


## JUnit单元测试的使用

1.  需要导入的jar包 [下载地址](https://jar-download.com/artifacts/junit/junit)

    

2.  导入 (IDEA的话就通过 File -> Project Structure -> Libraries-> 按下`+` Java, 选择对应的文件夹, 需包含上面两个 jar 包) 然后·在Modules里对应的地方打勾即可

    

3.  创建单元测试类, 进行测试 (可以不使用main函数的情况下 测试某一部分代码的功能) 测试的注解一般是 @Test

    

4.  编写单元测试方法