高阶函数和Java的Lambda

2017年的第一天,我坐在独墅湖边,写下这篇文章。

独墅湖.jpeg

在数学和计算机科学中,高阶函数是至少满足下列一个条件的函数:

  • 接受一个或多个函数作为输入
  • 输出一个函数

java世界迎来新的一等公民——函数

java 8引入了函数式编程。函数式编程重点在函数,函数变成了Java世界里的一等公民,函数和其他值一样,可以到处被定义,可以作为参数传入另一个函数,也可以作为函数的返回值,返回给调用者。利用这些特性,可以灵活组合已有函数形成新的函数,可以在更高层次上对问题进行抽象。

使用高阶函数之前的求和、求平方和、求立方和的写法:

public class TestHighOrderFunction {
 
   public static int identity(int x) {
      return x;
   }

   public static int sum_integers(int a, int b) {
     int sum = 0;
     for (int i = a; i <= b; i++) {
       sum += identity(i);
     }
    return sum;
   }

   public static int square(int x) {
      return x * x;
   }

  public static int sum_square(int a, int b) {
     int sum = 0;
     for (int i = a; i <= b; i++) {
        sum += square(i);
     }
     return sum;
   }

   public static double cube(int x) {
      return x * x * x;
   }

   public static int sum_cubes(int a, int b) {
      int sum = 0;
      for (int i = a; i <= b; i++) {
         sum += cube(i);
      }
      return sum;
   }

    public static void main(String[] a) {

        System.out.println(sum_integers(1, 10)); // return 55
        System.out.println(sum_square(1, 10));  // return 385
        System.out.println(sum_cubes(1, 10));  // return 3025
    }
}

我们发现sum_开头的方法里,代码很类似,三者唯一区别在于

   sum += identity(i);
   sum += square(i);
   sum += cube(i);

在软件工程里有DRY(don't repeat yourself )的准则。我们来看看使用高阶函数怎样优化刚才的这些代码:

 public interface Function {
     int opera(int a);
 }

 public static void main(String[] a) {
  
    Function identity = x->x;
    Function square = x->x*x;
    Function cube = x -> x*x*x;
    System.out.println(sum(identity, 1,10)); // return 55
    System.out.println(sum(square, 1,10)); // return 385
    System.out.println(sum(cube, 1,10));   // return 3025
 }
 
 public static int sum(Function term, int a, int b) {
  
     int sum = 0;
     for (int i = a; i <= b; i++) {
        sum += term.opera(i);
     }
     return sum;
 }

得到的结果,跟上面的TestHighOrderFunction类中运行的结果是一样的。不过,这里的sum方法中使用了

   sum += term.opera(i);

取代了原先的代码。term.opera(i)对应的是原先identity(i)、square(i)、cube(i),在这里Function函数被当做参数进行传递。这就是高阶函数的特性。

对于for循环,我们还能用更优雅的方式进行优化,下面使用了递归的方式。

 public interface Function {
     int opera(int a);
 }

 public static void main(String[] a) {
  
      Function identity = x->x;
      Function square = x->x*x;
      Function cube = x -> x*x*x;
      Function inc = x->x+1; // 定义next函数
      System.out.println(sum(identity, 1,inc,10)); // return 55
      System.out.println(sum(square, 1,inc,10)); // return 385
      System.out.println(sum(cube, 1,inc,10));   // return 3025
 }
 
 public static int sum(Function term, int a, Function next, int b) {
  
      if (a>b) {
          return 0;
      } else {
          return term.opera(a) + sum(term, next.opera(a), next, b);
      }
 }

@FunctionalInterface

在java 8之前我们使用Thread,可能是这样的

   new Thread(new Runnable() {    
        public void run() {        
              System.out.println("test");    
       }
   }).start();

由于Java 8引入了lambda表达式,我们可以这样写

   new Thread(()->System.out.println("test")).start();

lambda表达式源于lambda演算。

Lambda演算可以被称为最小的通用程序设计语言。它包括一条变换规则(变量替换)和一条函数定义方式,Lambda演算之通用在于,任何一个可计算函数都能用这种形式来表达和求值。因而,它是等价于图灵机的。尽管如此,Lambda演算强调的是变换规则的运用,而非实现它们的具体机器。可以认为这是一种更接近软件而非硬件的方式。

我们点击Runnable的源码时,发现Runnable使用了@FunctionalInterface,这在java 8之前是没有的。

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

@FunctionalInterface是Java 8为函数式接口引入的一个新的注解。表明该接口是函数式接口,它只包含唯一一个抽象方法。任何可以接受一个函数式接口实例的地方,都可以用lambda表达式。

我们再来看一个匿名函数的例子。

button.setOnClickListener(new Button.OnClickListener(){   
     public void onClick(View v) {        
         Log.i(TAG,"点击button");    
     }
});

我们将匿名函数改成lambda表达式

button.setOnClickListener((v)-> Log.i(TAG,,"点击button"));

这样改造的好处在于,lambda对象的创建是通过字节码指令invokedynamic来完成的,减少了类型和实例的创建消耗。而匿名类需要新的对象的创建。

JDK中的函数式接口举例

java.lang.Runnable, java.awt.event.ActionListener, java.util.Comparator, java.util.concurrent.Callable java.util.function包下的接口,如Consumer、Predicate、Supplier等

简化的lambda——方法引用(Method Reference)

lambda已经简化了代码的写法,然而方法引用进一步简化了lambda的写法。 方法引用的使用方式:类名::方法名

类型

使用方式

备注

引用静态方法

ContainingClass::staticMethodName

Integer::valueOf简化了i->Integer.valueOf(i)的写法

引用特定对象的实例方法

containingObject::instanceMethodName

s::toString()简化了()->s.toString()

引用特定类型的任意对象的实例方法

ContainingType::methodName

System.out::println简化了(s)->System.out.println(s),其中System.out表示的是PrintStream对象

引用构造函数

ClassName::new

String::new简化了()->new String()

我们来看一个简单的例子,对User按照name来进行排序,最初我们会这样写。

  User u1 = new User("tony");
  User u2 = new User("cafei");
  User u3 = new User("aaron");
  
  List<User> users = Arrays.asList(u1,u2,u3);
  
  Collections.sort(users, new Comparator<User>(){

   @Override
   public int compare(User u1, User u2) {
    return u1.getName().compareTo(u2.getName());
   }
   
  });

在java 8以后,Comparator增加了一个静态方法comparing(Function<? super T, ? extends U> keyExtractor),我们可以把排序的写法简化成这样:

Collections.sort(users, Comparator.comparing((User u)->u.getName()));

如果使用方法引用,还可以更加简化代码

Collections.sort(users,Comparator.comparing(User::getName));

集合中的应用

在java 8中可以使用新增的api Streams来操作集合,Streams是区别于java.io包里的InputStream 和 OutputStream的概念,是对集合功能的增强。如果你曾经了解过Scala、RxJava等函数式编程,那么看了它的语法以后一定会觉得似曾相识。我们来看两段代码,看看它是如何使用的。

List<Integer> list = Arrays.asList(1, 2, 3, 5, 7, 9, 10)
    .stream()
    .filter(i -> i >= 5)
    .collect(Collectors.toList());

System.out.println("list=" + list); // return list=[5, 7, 9, 10]
  Arrays.asList("tony", "cafei", "aaron")
           .stream()
           .map(str -> str.toUpperCase())
           .forEach(it -> System.out.println(it));

上面的代码还可以使用方法引用的方式:

  Arrays.asList("tony", "cafei", "aaron")
        .stream()
        .map(String::toUpperCase)
        .forEach(System.out::println);

使用这样的链式调用非常cool。而且,map、filter等方法都是高阶函数。

写在最后

lambda是java 8最为重要的特性,lambda表达式并非只是Java的语法糖,而是由编译器和JVM共同配合来实现的。自从使用了lambda以后我感觉再也回不去了。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏小樱的经验随笔

【Java学习笔记之二十一】抽象类在Java继承中的用法小结

一、抽象类的基本概念 普通类是一个完善的功能类,可以直接产生实例化对象,并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类...

3149
来自专栏向治洪

Kotlin之基本语法

在今年Google IO大会上Google已经明确kotlin作为为Android第一官方语言的地位。我相信Google的决意,就像当初毫不犹豫的抛弃eclip...

2258
来自专栏老九学堂

【必读】超全的C语言基础知识大全

我们用一个简单的c程序例子,介绍c语言的基本构成、格式、以及良好的书写风格,加深小伙伴们对C语言的认识。

2392
来自专栏向治洪

Kotlin之基本语法

在今年Google IO大会上Google已经明确kotlin作为为Android第一官方语言的地位。我相信Google的决意,就像当初毫不犹豫的抛弃eclip...

2527
来自专栏Android干货园

Kotlin中级(9)- - - Kotlin类之数据类、密封类、内部类.md

上面的代码我们可以看到结构出来的变脸可以直接拿来用,比如数据体Leaf中的size属性,componentN函数群会按照数据体Leaf中属性声明的顺序,从com...

972
来自专栏Android群英传

Kotlin Primer·第四章·Kotlin 的类特性(下)

852
来自专栏java一日一条

JAVA8之lambda表达式详解

Lambda 表达式 − Lambda允许把函数作为一个方法的参数(函数作为参数传递进方法中)

2554
来自专栏轮子工厂

6. 简单又复杂的“运算符”,建议你看一哈

昨天的《5. 很“迷”的字符与字符串》初稿本来很短的,但是我觉得内容太少了,就加了一些,结果好像就变得特别多〒▽〒。

873
来自专栏闻道于事

Java之面向对象概述,类,构造方法,static,主方法,对象

一、面向对象概述 面向过程 “面向过程”(Procedure Oriented)是一种以过程为中心的编程思想。这些都是以什么正在发生为主要目标进行编程,不同于...

3355
来自专栏老九学堂

【必读】C语言基础知识大全

C语言程序的结构认识 用一个简单的c程序例子,介绍c语言的基本构成、格式、以及良好的书写风格,使小伙伴对c语言有个初步认识。 例1:计算两个整数之和的c程...

5608

扫码关注云+社区

领取腾讯云代金券