# Java8之Lambda

**Repository Path**: fpfgitmy_admin/java8-lambda

## Basic Information

- **Project Name**: Java8之Lambda
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 1
- **Forks**: 0
- **Created**: 2021-04-28
- **Last Updated**: 2021-04-28

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

### Java8之Lambda
+ 简介：Lambda是一个**匿名函数**，使用之后diam简介，更加灵活
+ 格式：
    + () -> {method()};  
    + 汉字示意： (参数) 指向箭头 执行的方法;
+ 举例： (o1,o2) -> Integer.compare(o1,o2);
    + -> ：lambda操作符或者箭头操作符
    + ->左边 ：lambda形参列表（就是接口中的抽象方法的形参列表）
    + ->右边 ：labmda体（就是重写的抽象方法的方法体）
+ 本质：其他语言中是一个函数，在Java中作为[函数式接口]()的具体实现
+ 总结：
    1. 左边：lambda形参的列表参数类型可以省略；如果lambda形参列表只有一个参数，可以省略，如果有多个不能省略
    2. 右边：lambda体应该使用一堆{}包裹，如果lambda体只有一条执行语句（可能是return语句），可以省略这一对{}和return关键字


#### Lambda的6中情况的时候

##### 无参的情况（方式一）
```
    @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("lambda无参的方式");
        r2.run();
    }
```
##### 有参的情况（方式二）
```
    @Test
    public void test2() {
        Consumer<String> r1 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        r1.accept("有参的普通写法");
        System.out.println("----------------");

        Consumer<String> r2 = (String s) -> {
            System.out.println(s);
        };
        r2.accept("有参的lambda写法");
    }
```
##### 省略数据类型的情况（方式三）
```
    @Test
    public void test3() {
        Consumer<String> r2 = (String s) -> {
            System.out.println(s);
        };
        r2.accept("有参有类型的lambda写法");
        System.out.println("----------------");
        Consumer<String> r3 = (s) -> {
            System.out.println(s);
        };
        r3.accept("有参的省略参数类型的(由泛型提供)lambda写法");
    }
```

##### 只需要一个参数的情况（方式四）
```
    @Test
    public void test4() {
        Consumer<String> r2 = (s) -> {
            System.out.println(s);
        };
        r2.accept("有参的省略参数类型的(由泛型提供)lambda写法");
        System.out.println("----------------");
        Consumer<String> r3 = s -> {
            System.out.println(s);
        };
        r3.accept("有参的省略参数类型的(由泛型提供)去掉参数框号的lambda写法");
    }
```

##### 需要两个或以上参数,多条执行语句,并且可以有返回值（方式五）
```
    @Test
    public void test5() {
        Comparator<Integer> c1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println("一般写法执行的第一步=" + o1);
                System.out.println("一般写法执行的第二步=" + o2);
                return o1.compareTo(o2);
            }
        };
        int compare = c1.compare(12, 3);
        System.out.println(compare);
        System.out.println("--------通用写法--------");
        Comparator<Integer> c2 = (o1, o2) -> {
            System.out.println("使用lambda后的第一步普通写法=" + o1);
            System.out.println("使用lambda后的第二步普通写法=" + o2);
            return o1.compareTo(o2);
        };
        int compare1 = c2.compare(33, 55);
        System.out.println(compare1);
    }
```
##### 当Lambda体只有一条语句,retrun与大框号若有,都可以省略
```
    @Test
    public void test6() {
        Comparator<Integer> c1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        };
        int compare = c1.compare(12, 3);
        System.out.println(compare);
        System.out.println("--------通用写法--------");
        Comparator<Integer> c2 = (o1, o2) -> o1.compareTo(o2);
        int compare1 = c2.compare(33, 55);
        System.out.println(compare1);
    }
```