# Java8之方法引用

**Repository Path**: fpfgitmy_admin/java8-method-reference

## Basic Information

- **Project Name**: Java8之方法引用
- **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表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖
+ 使用要求：实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法方法参数列表和返回值类型保持一致（针对情况1、情况2）
+ 格式：使用操作符“::”将类（或对象）与方法名分隔开来
+ 如下三种主要使用情况：
    1. 对象::非静态方法（需要创建实例）
    2. 类::静态方法名
    3. 类::非静态方法（需要创建实例）

#### 对象::非静态方法情况
+ 注意：调用者的被调用者的返回类型，参数类型，参数列表都相同
+ 提供的model

```
public class Goods implements Comparable {

    private String name;
    private Double price;

    public Goods(String name, Double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Goods{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }

    @Override
    public int compareTo(Object o) {
        if (o instanceof Goods) {
            Goods goods = (Goods) o;
            return Double.compare(this.price, goods.price);
        }
        return 0;
    }

    @Override
    public int hashCode() {
        return super.hashCode();
    }
}
```
##### 没有返回值
```
    // Consumer 中的void accept(T t)
    // PrintStream中的void println(T t)
    @Test
    public void test1() {
        Consumer<String> c1 = str -> System.out.println(str);
        c1.accept("没有使用方法引用的情况");
        System.out.println("----------------------------");
        PrintStream out = System.out; // 由于println是非静态方法，所以 :: 左边需要实例化
        // 由于入参和方法使用参数类型一致，且只有一个参数，需要省略掉
        Consumer<String> c2 = out::println;
        c2.accept("使用了方法引用的情况");
    }
```

##### 有返回值
```
    // Supplier中的T get()
    // Goods中的String getName()
    @Test
    public void test2() {

        Goods goods = new Goods("小米11", 3999.0);
        Supplier<String> s1 = () -> goods.getName();
        String s = s1.get();
        System.out.println("没有使用方法引用的情况获取到的返回值=" + s);
        System.out.println("----------------------------");
        Supplier<String> s2 = goods::getName;
        String str = s2.get();
        System.out.println("使用方法引用的情况获取到的返回值=" + str);
    }
```

#### 类::静态方法
```

    // Comparator中的int compare(T t1,T t2)
    // Integer 中的 int compare(T t1,T t2)
    @Test
    public void test3() {
        Comparator<Integer> c1 = (t1, t2) -> Integer.compare(t1, t2);
        System.out.println("没有使用方法引用的情况" + c1.compare(12, 33));
        System.out.println("----------------------------");
        // 参数类型和参数列表一致，省略
        Comparator<Integer> c2 = Integer::compare;
        System.out.println("使用方法引用的情况" + c2.compare(12, 33));
    }
```

```
    // Function中的 R apply(T t)
    // Math 中的Long round(Double d)
    @Test
    public void test4() {
        // 传入一个Double类型的数据，计算之后返回一个Long类型的数据
        System.out.println("原来的写法");
        Function<Double, Long> f1 = new Function<Double, Long>() {
            @Override
            public Long apply(Double d) {
                return Math.round(d);
            }
        };
        Long a1 = f1.apply(12.3);
        System.out.println("获取到的值=" + a1);
        System.out.println("使用Lambda后的写法");
        Function<Double, Long> f2 = d -> Math.round(d);
        Long a2 = f2.apply(12.5);
        System.out.println("获取到的值=" + a2);

        System.out.println("使用了方法引用的情况");
        Function<Double, Long> f3 = Math::round;
        Long a3 = f3.apply(12.6);
        System.out.println("获取到的值=" + a3);
    }
```

#### 类::非静态方法
+ 注意：如果只有两个参数的情况下，o1默认为调用者,o2默认为被调用者

##### 调用者有两个参数，被调用者使用了这两个参数
```
    // BiPredicate中的boolean test(T t1,T t2)
    // String中的boolean t1.equals(t2;
    @Test
    public void test7() {
        BiPredicate<String, String> b = (t1, t2) -> t1.equals(t2);
        boolean test = b.test("abc", "abc");
        System.out.println("使用了Lambda情况下" + test);
        BiPredicate<String, String> b1 = String::equals;
        boolean test1 = b1.test("abc", "abc");
        System.out.println("使用了Lambda情况下" + test1);
    }
```

##### 调用者有一个参数，被调用了使用了一个参数
```
    // Function中的 R apply(T t)
    // Goods中的String getName
    @Test
    public void test8() {
        Goods goods = new Goods("小米", 1999.0);

        Function<Goods, String> f1 = g -> g.getName();
        String r1 = f1.apply(goods);
        System.out.println("使用了Lambda的情况" + r1);
        // 参数用作调用者
        Function<Goods, String> f2 = Goods::getName;
        String r2 = f2.apply(goods);
        System.out.println("使用了方法引用的情况" + r2);
    }
```