方法引用

# 何为方法引用？

特殊的Lambda表达式，如果方法体中只有一个方法的调用的话（包括构造方法）,可以用方法引用进一步简化代码；

格式：类名::方法名；

# 引用类的静态方法

案例：

List<Author> authors = getAuthors();

Stream<Author> authorStream = authors.stream();

//类型转换
authorStream.map(author -> author.getAge())
        .map(age->String.valueOf(age));

1
2
3
4
5
6
7

方法引用优化：

authorStream.map(author -> author.getAge())
        .map(String::valueOf);

1
2

在重写方法的时候，方法体中只有一行代码，并且这行代码是调用了某个类的静态方法，并且把要重写的抽象方法中所有的参数都按照顺序传入了这个静态方法中，这个时候就可以引用类的静态方法；
public static String valueOf(Object obj) {
    return (obj == null) ? "null" : obj.toString();
}
1
2
3

# 引用对象的实例方法

案例：

List<Author> authors = getAuthors();
Stream<Author> authorStream = authors.stream();
StringBuilder sb = new StringBuilder();
authorStream.map(author -> author.getName())
        .forEach(name->sb.append(name));

1
2
3
4
5

方法引用优化：

authorStream.map(author -> author.getName())
        .forEach(sb::append);

1
2

在重写方法的时候，方法体中只有一行代码，并且这行代码是调用了某个对象的成员方法，并且把要重写的抽象方法中所有的参数都按照顺序传入了这个成员方法中，这个时候就可以引用对象的实例方法；
@Override
public StringBuilder append(String str) {
    super.append(str);
    return this;
}
1
2
3
4
5

# 引用类的实例方法

案例：

interface UseString{
    String use(String str,int start,int length);
}

public static String subAuthorName(String str, UseString useString){
    int start = 0;
    int length = 1;
    return useString.use(str,start,length);
}
public static void main(String[] args) {

    subAuthorName("rui", new UseString() {
        @Override
        public String use(String str, int start, int length) {
            return str.substring(start,length);
        }
    });

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

方法引用优化：

public static void main(String[] args) {
    subAuthorName("rui", String::substring);
}

1
2
3

在重写方法的时候，方法体中只有一行代码，并且这行代码是调用了第一个参数的成员方法，并且把要重写的抽象方法中剩余的所有的参数都按照顺序传入了这个成员方法中，这个时候就可以引用类的实例方法；

# 构造器引用

案例：

List<Author> authors = getAuthors();
authors.stream()
        .map(author -> author.getName())
        .map(name->new StringBuilder(name))
        .map(sb->sb.append("rui").toString())
        .forEach(str-> System.out.println(str));

1
2
3
4
5
6

方法引用优化：

List<Author> authors = getAuthors();
authors.stream()
        .map(author -> author.getName())
        .map(StringBuilder::new)
        .map(sb->sb.append("rui").toString())
        .forEach(str-> System.out.println(str));

1
2
3
4
5
6

在重写方法的时候，方法体中只有一行代码，并且这行代码是调用了某个类的构造方法，并且把要重写的抽象方法中的所有的参数都按照顺序传入了这个构造方法中，这个时候就可以引用构造器；

← 函数式接口 Stream流→