概念分析

惰性计算：尽可能地延迟表达式求值，这是许多函数式编程语言的特点
优点：

  • 可以将耗时的计算推迟到绝对需要时执行
  • 可以创建无限个集合，只要他们收到请求，就会继续提供元素

区别：Java 没有为惰性提供原生支持，Scala 提供了原生支持

实例代码

Java

Scala 中惰性函数的概念在 Java 中称之为懒加载（延迟加载）

  1. // 单例模式：懒汉式
  2. class Singleton {
  3.     private Singleton() {}
  4.     private static Singleton single = null;
  5.     public static Singleton getInstance() {
  6.         if (single == null) {
  7.             synchronized (LazyFunction.class) {
  8.                 if (single == null) {
  9.                     single = new Singleton();
  10.                 }
  11.             }
  12.         }
  13.         return single;
  14.     }
  15. }

Scala

惰性函数：有一个函数，当它的返回值被声明为 lazy 时，函数的执行将被推迟，只有在首次取值时，该函数才会执行

  1. object LazyFunction {
  2.   def main(args: Array[String]): Unit = {
  3.     lazy val res = getSum(2, 3)
  4.     println("-----")
  5.     println(s"res=${res}")
  6.   }
  8.   def getSum(n1: Int, n2: Int): Int = {
  9.     println("getSum函数执行了...")
  10.     return n1 + n2
  11.   }
  12. }

📡 执行结果

  1. -----
  2. getSum函数执行了...
  3. res=5

📝 注意事项

  • 如果一个变量被声明为 lazy 时，变量值的分配会被推迟，如：lazy val age = 10
  • lazy 不能修饰 var 修饰的变量