0

我有一些代码可以在数组中生成 1000 个数字，然后对它们进行排序：

import java.util.Arrays;
import java.util.Random;


public class OppgA {
    public static void main(String[] args) {
        int[] anArray;
        anArray = new int[1000];
        Random generator = new Random();
        for(int i=0; i<1000; i++){
            anArray[i] = (generator.nextInt(1000)+1);
        }
        Arrays.sort(anArray);
        System.out.println(Arrays.toString(anArray));

    }

}

现在我被要求计算并打印对数组进行排序所花费的时间。任何线索我怎么能做到这一点？通过搜索可以帮助我解决我的问题，我真的找不到太多。

谢谢！

4

9 回答 9

8

System.nanoTime()您可以在调用之前和之后调用（并存储结果）Arrays.sort()- 不同之处在于花费的时间（以纳秒为单位）。该方法优于System.currentTimeMillis计算持续时间。

long start = System.nanoTime();
Arrays.sort(anArray);
long end = System.nanoTime();
long timeInMillis = TimeUnit.MILLISECONDS.convert(end - start, TimeUnit.NANOSECONDS);
System.out.println("Time spend in ms: " + timeInMillis);

但请注意，如果您多次运行该程序，您的测量结果可能会有很大差异。要获得更精确的计算将涉及更多 - 例如，请参阅：如何在 Java 中编写正确的微基准？.

于 2013-08-22T10:13:42.440 回答
4

在排序之前，声明一个 long 对应于开始排序之前的时间：

long timeStarted = System.currentTimeMillis();
//your sorting here.

//after sorting
System.out.println("Sorting last for:" + (System.currentTimeMillis() - timeStarted));

结果将返回您排序的毫秒数。

System.nanoTime()正如 assylias 评论的那样，如果您更喜欢精确测量经过的时间，您也可以使用。

于 2013-08-22T10:10:56.243 回答
4

为此目的，使用现成的工具（如 Google Caliper 或 Oracle jmh）完成适当的微基准测试。但是，如果您想要穷人版，请至少遵循以下几点：

  1. 测量System.nanoTime()（如其他地方所述）。不要相信小数字：如果你得到的时间是 10 微秒，那么你测量的时间跨度太短了。扩大数组以至少进入毫秒；
  2. 多次重复排序过程（可能 10、100 次）并显示每次尝试的时间。在最初的几次运行之后，您应该会看到时间明显下降，但在那之后时间应该会稳定下来。如果您仍然观察到剧烈的变化，那么您就知道有些不对劲；
  3. 为避免垃圾收集问题，请重复使用相同的数组，但每次都用新的随机数据重新填充它。
于 2013-08-22T10:17:00.990 回答
1 
long beforeTime = System.currentTimeMillis();

// Your Code

long afterTime = System.currentTimeMillis();

long diffInMilliSeconds = afterTime- beforeTime;
于 2013-08-22T10:11:19.727 回答
0

在开始计算之前或恰好在生成数组之后，您可以使用System#currentTimeMillis()来获取确切的时间，并在完成排序后完全执行相同的操作，然后找出差异。

于 2013-08-22T10:11:52.480 回答
0

简而言之，您可以将我们的代码提取到一个方法中，然后计算该方法的开始和结束时间戳之间的差异，或者您可以在分析器或 IDE 中运行它，它会打印执行时间

理想情况下，您不应该将您的业务逻辑（在这种情况下为数组排序）与“指标”的东西混合在一起。如果您确实需要测量应用程序中的执行时间，您可以尝试使用 AOP

请参考这篇文章，它非常详细地描述了可能的解决方案

于 2013-08-22T10:21:53.397 回答
0

这样做：

long start = System.currentTimeMillis(); ... your sorting code ... long end = System.currentTimeMillis(); long timeInMillis = end - start;

希望有帮助。

于 2013-08-22T10:13:21.093 回答
0 
import java.util.Arrays;
import java.util.Random;


public class OppgA {
    public static void main(String[] args) {
        int[] anArray;
        anArray = new int[1000];
        Random generator = new Random();
        for(int i=0; i<1000; i++){
            anArray[i] = (generator.nextInt(1000)+1);
        }
        Date before = new Date();
        Date after;
        Arrays.sort(anArray);
        after = new Date();
        System.out.println(after.getTime()-before.getTime());

        System.out.println(Arrays.toString(anArray));

    }

}
于 2013-08-22T10:13:47.187 回答
0

这不是一个理想的方式。但这会起作用

    long startingTime=System.currentTimeMillis();
    Arrays.sort(anArray);
    long endTime=System.currentTimeMillis();
    System.out.println("Sorting time: "+(endTime-startingTime)+"ms");

跟随可能是最好的方法

    long startingTime=System.nanoTime();
    Arrays.sort(anArray);
    long endTime=System.nanoTime();
    System.out.println("Sorting time: "+(endTime-startingTime)+"ns");
于 2013-08-22T10:19:35.987 回答