Java函数式编程&四种方法引用总结、Stream流高级用法-java8新特性（四）

一、方法引用

       方法引用是一个语法糖，可以进一步简化Lambda表达式， 我们在使用lambda时，如果方法体中只有一个方法的调用的话，我们可以用方法引用进一步简化代码。

        推荐用法：我们在使用lambda时不需要考虑什么时候用方法引用，方法引用的格式是什么。我们只需要在写完lambda方法发现方法体只有一行代码，并且在方法的调用时使用快捷键尝试是否能转换成方法引用即可。

1.引用类的静态方法：

                                        类名::方法名

 使用前提：
        如果我们在重写方法的时候，方法体中只有一行代码，并且这行代码是调用了某个类的静态方法，并且我们把要重写的抽象方法中所有的参数都按照顺序传入了这个静态方法中，这个时候我们就可以引用类的静态方法。

  private static void test22(){
        List<Author> authors = getAuthors();
        authors.stream()
                .map(author -> author.getAge())
                .map(new Function<Integer, String>() {
                    public String apply(Integer age){
                        return String.valueOf(age);
                    }
                });
    }

ALT+ENTER：

                

优化后：   类名::方法名

  private static void test22(){
        List<Author> authors = getAuthors();
        authors.stream()
                .map(author -> author.getAge())
                .map(String::valueOf);
    }

2.1 引用对象的实例方法：

                                           对象::方法名

使用前提：
        如果我们在重写方法的时候，方法体中只有一行代码，并且这行代码是调用了某个对象的成员方法，并且我们把要重写的抽象方法中所有的参数都按照顺序传入了这个成员方法中，这个时候我们就可以引用对象的实例方法。 

    private static void test23(){
       StringBuilder sb = new StringBuilder();
       List<Author> authors = getAuthors();
       authors.stream()
               .map(author -> author.getName())
               .forEach(new Consumer<String>() {
                   @Override
                   public void accept(String name) {
                       sb.append(name);
                   }
               });
    }

 简化后： 对象::方法名

    private static void test23(){
       StringBuilder sb = new StringBuilder();
       List<Author> authors = getAuthors();
       authors.stream()
               .map(author -> author.getName())
               .forEach(sb::append);
    }

 2.2 关于System.out::println的解读：

        

  private static void test211(){
        Optional<Author> author = getAuthor();
        author.map(author1 -> author1.getAge()+10)
                .ifPresent(System.out::println);
    }

                 

                        ​​​​​​​        ​​​​​​​        

 

这样就不能用：System.out::println了 :

---

 

3.引用类的实例方法：

                        ​​​​​​​        ​​​​​​​        ​​​​​​​         类名::方法名

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

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

    private  static String subAuthorName(String str,UseString useString){
        int length = 1;
        int start = 0;
        return useString.use(str,start,length);
    }
    public static void main(String[] args){
        subAuthorName("三更草堂",new UseString(){
            public String use(String str, int start, int length){
                return str.substring(start,length);
            }
        });
    }
}

 简化后：  类名::方法名 

    public static void main(String[] args){
        //方法引用是一个语法糖，可以进一步简化Lambda表达式:
        subAuthorName("三更草堂", String::substring);
    }

​​​​​​​ 

4.构造器引用

                                              类名::new 

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

 

  private static void test24(){
        List<Author> authors = getAuthors();
        authors.stream()
                .map(author -> author.getName())
                .map(new Function<String,StringBuilder>(){
                    public StringBuilder apply(String name){
                        return new StringBuilder(name);
                    }
                })
                .map(sb -> sb.append("-三更").toString())
                .forEach(str -> System.out.println(str));
        
        authors.stream()
                .map(author -> author.getName())
                .map(StringBuilder::new)
                .map(sb -> sb.append("-三更").toString())
                .forEach(str -> System.out.println(str));
    }