在 JAVA 中的以下方法中声明、实例化和初始化数组的时间复杂度有什么不同吗？

Question

我正在学习有关数据结构和算法的在线课程。 在那门课程中，讲师告诉我们以下方式的时间复杂度是不同的。

方法一：

 Declare:

                int arr[]------------>O(1)

 Instantiation:

                arr = new int[size]------>O(1)


 Initialization:
               arr[0]=0;------------>O(1)
                                     -------------->O(n)
               arr[1]=1;------------>O(1)

方法二：

 Declaration,instantiation and initialization:

               int arr[]={10,20,30}---------------->O(1)

我需要知道，通过遵循第二种方法，我们可以优化我们的程序，以及如何判断它具有O(1) ，这两种方法之间有什么区别。

我的意思是我认为虽然第二种方法的步骤较少，但它在内部遵循第一种方法中的所有步骤，所以它不可能是O(1)它也是O(n) ，我对吗？

Answer 1

Java 的数组初始值设定项语法只是分配数组和为每个元素分配值的指令的语法糖。

这可以通过以下代码轻松验证：

import java.io.IOException;
import java.nio.file.Paths;

public class ArrayInitializer {
    public void form1() {
        int arr[] = new int[3];
        arr[0] = 10;
        arr[1] = 20;
        arr[2] = 30;
    }

    public void form2() {
      int arr[] = { 10, 20, 30 };
    }

    public static void main(String[] args) throws Exception {
        decompile();
    }

    private static void decompile() throws InterruptedException, IOException
    {
      new ProcessBuilder(Paths.get(System.getProperty("java.home"))
          .getParent().resolve(Paths.get("bin", "javap")).normalize().toString(),
          "-c", "-cp", System.getProperty("java.class.path"),
          ArrayInitializer.class.getName())
      .inheritIO()
      .start().waitFor();
    }

    private ArrayInitializer() {}
}

哪个打印

Compiled from "ArrayInitializer.java"
public class ArrayInitializer {
  public void form1();
    Code:
       0: iconst_3
       1: newarray       int
       3: astore_1
       4: aload_1
       5: iconst_0
       6: bipush        10
       8: iastore
       9: aload_1
      10: iconst_1
      11: bipush        20
      13: iastore
      14: aload_1
      15: iconst_2
      16: bipush        30
      18: iastore
      19: return

  public void form2();
    Code:
       0: iconst_3
       1: newarray       int
       3: dup
       4: iconst_0
       5: bipush        10
       7: iastore
       8: dup
       9: iconst_1
      10: bipush        20
      12: iastore
      13: dup
      14: iconst_2
      15: bipush        30
      17: iastore
      18: astore_1
      19: return

  public static void main(java.lang.String[])  throws java.lang.Exception;
    Code:
       0: invokestatic  #22                 // Method decompile:()V
       3: return
}

所以，如果编译出来的代码没有差异，就不会存在源代码形式导致的性能差异。

这并不排除 JVM 进行的运行时优化，例如，当它检测到这是一个分配，然后填充其评估不会以泄漏未初始化数组的方式失败的值。 但是这些优化适用于任何一种情况，因为源代码形式无关紧要。

本文讨论了一个关于集合的toArray方法的实际示例，结果证明其性能取决于 JVM 识别数组分配的能力，然后立即执行覆盖整个创建的数组的复制操作。

Answer 2

可以在恒定时间内初始化数组 。 我不知道哪个JVM实现可以这样做，但是有可能。 由于此技术需要3倍的内存，因此很可能不会被任何JVM实现使用。

假设JVM不使用此技术，则

arr = new int[size]

和

int arr[]={10,20,30}

都将以O（n）运行（在第一种情况下，数组中的所有元素都需要清零）。

但是，如果使用此方法（或类似技术），则您的老师是正确的。

编辑

没有花哨的初始化技术，两种情况下的复杂度均为O（n） 。 但是恒定因素可能有所不同。 因此，我使用jmh和100个大小的数组进行了基准测试 （抱歉，我懒于编写更长的数组）。 结果如下：

# Run complete. Total time: 00:20:13

Benchmark                                  Mode  Cnt         Score       Error  Units
ArrayInitBenchmark.initialize_and_set     thrpt  200  32341391,483 ± 46429,821  ops/s
ArrayInitBenchmark.initialize_only        thrpt  200  32523162,079 ± 34682,391  ops/s
ArrayInitBenchmark.initialize_with_zeros  thrpt  200  36267571,539 ± 34839,701  ops/s

• initialize_and_set是OP的第一种方法。
• initialize_only是OP的第二种方法。
• initialize_with_zeros仅仅是一个new int[size] 。

如您所见，第二种方法要快一些，但比第一种要快1％（32.3 M ops / s与32.5 M ops / s）。 也就是说，在我的机器上使用oracle JDK 1.8.0_201。 （使用Java 13进行测试将需要我设置一个新的jmh项目，而我已经为Java 8设置了所有功能）。