使用分析器(JProfiler, Netbeans profiler, Visual VM, Eclipse profiler等)。您将得到最准确的结果，并且是最少的干扰。它们使用内置的JVM机制进行概要分析，还可以为您提供额外的信息，如堆栈跟踪、执行路径以及必要时更全面的结果。

当使用完全集成的分析器时，对方法进行分析是非常简单的。右击，分析器->添加到根方法。然后像运行测试运行或调试器一样运行剖析器。

如果您不使用工具，并且希望对执行时间较短的方法进行计时，那么只需执行多次，每次将执行次数增加一倍，直到达到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编译器完成它的工作，然后重复此测试多次，并使用最短的执行时间。

如果java有更好的功能支持就好了，这样需要测量的动作就可以被包装到一个块中:

measure {
   // your operation here
}

在java中，这可以通过匿名函数来完成，看起来太冗长了

public interface Timer {
    void wrap();
}


public class Logger {

    public static void logTime(Timer timer) {
        long start = System.currentTimeMillis();
        timer.wrap();
        System.out.println("" + (System.currentTimeMillis() - start) + "ms");
    }

    public static void main(String a[]) {
        Logger.logTime(new Timer() {
            public void wrap() {
                // Your method here
                timeConsumingOperation();
            }
        });

    }

    public static void timeConsumingOperation() {
        for (int i = 0; i<=10000; i++) {
           System.out.println("i=" +i);
        }
    }
}

如果你只是想知道时间，可以试试这种方法。

long startTime = System.currentTimeMillis();
//@ Method call
System.out.println("Total time [ms]: " + (System.currentTimeMillis() - startTime));    

我的答案很简单。对我有用。

long startTime = System.currentTimeMillis();

doReallyLongThing();

long endTime = System.currentTimeMillis();

System.out.println("That took " + (endTime - startTime) + " milliseconds");

它运行得很好。分辨率显然只有毫秒级，使用System.nanoTime()可以做得更好。这两种方法都有一些限制(操作系统调度切片等)，但效果很好。

平均几次运行(越多越好)，你就会得到一个不错的想法。

纯Java SE代码，不需要添加依赖项，使用TimeTracedExecuter:

public static void main(String[] args) {

    Integer square = new TimeTracedExecutor<>(Main::calculateSquare)
                .executeWithInput("calculate square of num",5,logger);

}
public static int calculateSquare(int num){
    return num*num;
}

会产生这样的结果:

信息:计算num的平方需要3毫秒

自定义可重用类:TimeTracedExecutor

import java.text.NumberFormat;
import java.time.Duration;
import java.time.Instant;
import java.util.function.Function;
import java.util.logging.Logger;

public class TimeTracedExecutor<T,R> {
    Function<T,R> methodToExecute;

    public TimeTracedExecutor(Function<T, R> methodToExecute) {
        this.methodToExecute = methodToExecute;
    }

    public R executeWithInput(String taskDescription, T t, Logger logger){
        Instant start = Instant.now();
        R r= methodToExecute.apply(t);
        Instant finish = Instant.now();
        String format = "It took %s milliseconds to "+taskDescription;
        String elapsedTime = NumberFormat.getNumberInstance().format(Duration.between(start, finish).toMillis());
        logger.info(String.format(format, elapsedTime));
        return r;
    }
}