如果您不使用工具，并且希望对执行时间较短的方法进行计时，那么只需执行多次，每次将执行次数增加一倍，直到达到1秒左右。因此，系统调用的时间。纳米时间等，也没有系统的准确性。nanoTime确实对结果有很大影响。

    int runs = 0, runsPerRound = 10;
    long begin = System.nanoTime(), end;
    do {
        for (int i=0; i<runsPerRound; ++i) timedMethod();
        end = System.nanoTime();
        runs += runsPerRound;
        runsPerRound *= 2;
    } while (runs < Integer.MAX_VALUE / 2 && 1000000000L > end - begin);
    System.out.println("Time for timedMethod() is " + 
        0.000000001 * (end-begin) / runs + " seconds");

当然，使用挂钟也有一些注意事项:jit编译、多线程/进程等的影响。因此，您需要首先执行该方法很多次，以便JIT编译器完成它的工作，然后重复此测试多次，并使用最短的执行时间。

这可能不是您想让我说的，但是这是AOP的一个很好的用法。在您的方法周围使用代理拦截器，并在其中进行计时。

遗憾的是，AOP的什么、为什么和如何超出了这个答案的范围，但这就是我可能会做的事情。

编辑:如果你有兴趣的话，这里有一个Spring AOP的链接可以帮助你入门。这是Iive在java中遇到的最容易访问的AOP实现。

另外，考虑到其他人的简单建议，我应该补充一点:AOP适用于不希望时间之类的东西侵入代码的情况。但在很多情况下，这种简单易行的方法是可以的。

我基本上做的是这种方法的变体，但是考虑到热点编译的工作方式，如果您想要获得准确的结果，您需要抛弃前几个度量，并确保您在真实世界(阅读特定于应用程序的)应用程序中使用该方法。

如果JIT决定编译它，您的数字将会有很大的变化。所以要注意

如果您不使用工具，并且希望对执行时间较短的方法进行计时，那么只需执行多次，每次将执行次数增加一倍，直到达到1秒左右。因此，系统调用的时间。纳米时间等，也没有系统的准确性。nanoTime确实对结果有很大影响。

    int runs = 0, runsPerRound = 10;
    long begin = System.nanoTime(), end;
    do {
        for (int i=0; i<runsPerRound; ++i) timedMethod();
        end = System.nanoTime();
        runs += runsPerRound;
        runsPerRound *= 2;
    } while (runs < Integer.MAX_VALUE / 2 && 1000000000L > end - begin);
    System.out.println("Time for timedMethod() is " + 
        0.000000001 * (end-begin) / runs + " seconds");

当然，使用挂钟也有一些注意事项:jit编译、多线程/进程等的影响。因此，您需要首先执行该方法很多次，以便JIT编译器完成它的工作，然后重复此测试多次，并使用最短的执行时间。

我已经编写了一个方法，以易于阅读的形式打印方法执行时间。 例如，要计算100万的阶乘，大约需要9分钟。因此，执行时间打印为:

Execution Time: 9 Minutes, 36 Seconds, 237 MicroSeconds, 806193 NanoSeconds

代码在这里:

public class series
{
    public static void main(String[] args)
    {
        long startTime = System.nanoTime();

        long n = 10_00_000;
        printFactorial(n);

        long endTime = System.nanoTime();
        printExecutionTime(startTime, endTime);

    }

    public static void printExecutionTime(long startTime, long endTime)
    {
        long time_ns = endTime - startTime;
        long time_ms = TimeUnit.NANOSECONDS.toMillis(time_ns);
        long time_sec = TimeUnit.NANOSECONDS.toSeconds(time_ns);
        long time_min = TimeUnit.NANOSECONDS.toMinutes(time_ns);
        long time_hour = TimeUnit.NANOSECONDS.toHours(time_ns);

        System.out.print("\nExecution Time: ");
        if(time_hour > 0)
            System.out.print(time_hour + " Hours, ");
        if(time_min > 0)
            System.out.print(time_min % 60 + " Minutes, ");
        if(time_sec > 0)
            System.out.print(time_sec % 60 + " Seconds, ");
        if(time_ms > 0)
            System.out.print(time_ms % 1E+3 + " MicroSeconds, ");
        if(time_ns > 0)
            System.out.print(time_ns % 1E+6 + " NanoSeconds");
    }
}

总有一些过时的方法:

long startTime = System.nanoTime();
methodToTime();
long endTime = System.nanoTime();

long duration = (endTime - startTime);  //divide by 1000000 to get milliseconds.