计算Java中任意一个方法的执行时间的工具类

如何获取一个方法的执行时间，不论是静态方法还是静态方法，不论是私有方法还是共有方法，如果该对象不能

被实例化，使用该对象的class对象也可以，例如Arrays.class也可以作为bean传入方法中

只有当方法是static，使用bean和bean.class都可以，但如果不是static，你使用bean.class 会报错

该方法主要用来计算一个方法的执行时间和是否打印方法的执行时间和输出结果，我制作这个方法主要用来比较排序算法的时间复杂度

下面是工具类的代码：

package algorithm.study.utils;

import java.lang.reflect.Method;

/**
 * This class is getting a method execute time and provide some other functions.
 * 
 * @author ygh 2017年2月24日
 */
public class MethodExecuteTimeUtils {

    /**
     * Get a method execute time using millisecond and cancel method's print return result and
     * execute time.
     * 
     * @param bean The method is in this bean
     * @param params The parameter the method execute need
     * @param methodName The name of the method
     * @param types The parameter type of the method
     * @return The execute time of this method
     * @throws Exception If <code>getMethod</code> or <code>invoke</code> fail.
     */
    public static long getMethodExecuteTime(Object bean, Object[] params, String methodName, Class<?>[] types)
            throws Exception {
        return getMethodExecuteTime(bean, params, methodName, types, false, false);
    }

    /**
     * Get a method execute time using millisecond and cancel print method's return result.
     * 
     * @param bean The method is in this bean
     * @param params The parameter the method execute need
     * @param methodName The name of the method
     * @param types The parameter type of the method
     * @param isPrintExecutetime Whether print the execute time in console, true is print false not
     * @param isViewMehtodResult Whether print the return result in console, true is print false not
     * @return The execute time of this method
     * @throws Exception If <code>getMethod</code> or <code>invoke</code> fail.
     */
    public static long getMethodExecuteTime(Object bean, Object[] params, String methodName,
            Class<?>[] types, boolean isPrintExecutetime) throws Exception {
        return getMethodExecuteTime(bean, params, methodName, types, isPrintExecutetime, false);
    }

    /**
     * Get a method execute time using millisecond and add some other service.
     * 
     * @param bean The method is in this bean
     * @param params The parameter the method execute need
     * @param methodName The name of the method
     * @param types The parameter type of the method
     * @param isPrintExecutetime Whether print the execute time in console, true is print false not
     * @param isViewMehtodResult Whether print the return result in console, true is print false not
     * @return The execute time of this method
     * @throws Exception If <code>getMethod</code> or <code>invoke</code> fail.
     */
    public static long getMethodExecuteTime(Object bean, Object[] params, String methodName,
            Class<?>[] types, boolean isPrintExecutetime, boolean isViewMehtodResult) throws Exception {
        Class<?> clazz;
        long executeTime = -1L;
        boolean isAccessiable = false;
        Method method = null;
        if (bean instanceof Class<?>) {
            clazz = (Class<?>) bean;
        } else {
            clazz = bean.getClass();
        }
        try {
            if (types == null) {
                method = clazz.getDeclaredMethod(methodName);
            } else {
                method = clazz.getDeclaredMethod(methodName, types);
            }
            isAccessiable = method.isAccessible();
            if (!isAccessiable) {
                method.setAccessible(true);
            }

            if (isViewMehtodResult) {
                executeTime = getReturnMethodExecuteTime(bean, params, method);
            } else {
                executeTime = getMethodExecuteTime(bean, params, method);
            }
            method.setAccessible(isAccessiable);
            if (isPrintExecutetime) {
                printExecute(clazz, methodName, executeTime);
            }
        } catch (Exception e) {
            throw new Exception("excute method fail");
        }
        return executeTime;
    }

    /**
     * Get a method execute time, use millisecond. We don't think the method whether has a return
     * result
     * 
     * @param bean The method is in this bean
     * @param params The parameters the method execute need
     * @param method The Method entity
     * @return The millisecond the method execute spend
     * @throws Exception If the method invoke fail
     */
    private static long getMethodExecuteTime(Object bean, Object[] params, Method method) throws Exception {
        long startTime = System.currentTimeMillis();
        method.invoke(bean, params);
        long endTime = System.currentTimeMillis();
        return endTime - startTime;
    }

    /**
     * Get a method execute time, use millisecond. The method must has a return result will input
     * the return result in console ,If the method has not return result, please call
     * <code>getMethodExecuteTime</code> method.
     * 
     * @param bean The method is in this bean
     * @param params The parameters the method execute need
     * @param method The Method entity
     * @return The millisecond the method execute spend
     * @throws Exception If the method invoke fail
     */
    private static long getReturnMethodExecuteTime(Object bean, Object[] params, Method method)
            throws Exception {
        long startTime = System.currentTimeMillis();
        Object result = (Object) method.invoke(bean, params);
        long endTime = System.currentTimeMillis();
        if (result != null) {
            System.out.println("result input：" + result.toString());
        } else {
            System.out.println("Warning:" + bean.getClass().getName() + "." + method.getName()
                    + "has not return " + "result,please setting the isViewMehtodResult as false");
        }
        return endTime - startTime;
    }

    /**
     * Print the execute time of method
     * 
     * @param methodName The name of the method
     * @param time The execute of the method
     */
    public static void printExecute(Class<?> clazz, String methodName, long time) {
        System.out.println(clazz.getName() + "." + methodName + " execute time: " + time);
    }
}

Person类，用于测试：

package javareflect.demo;
/**
 * This a person domain used test java.reflect
 * @author ygh 
 * 2017年2月26日
 */
public class Person {

    private String name;
    
    private Integer age;
    
    private static String gender;
    
    public static String getGender(){
        return gender;
    } 
    
    public static void setGender(String gender){
        System.out.println("性别："+gender);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
    
    public static void fun1(){
        System.out.println("this is fun1");
    }
    
    private void fun2(){
        System.out.println("this is private method");
    }
    
    
}

下面是测试代码：测试执行Person类里面的各种Method，静态的，私有的，共有的

public class ReflectTest {
    @Test
    public void fun1() throws Exception {
        Person person = new Person();
        Object[] params = null;
        Class<?>[] types = null;
        MethodExecuteTimeUtils.getMethodExecuteTime(person, params, "fun2", types, true, true);
    }
    @Test
    public void fun2() throws Exception {
        Person person = new Person();
        Object[] params = null;
        Class<?>[] types = null;
        MethodExecuteTimeUtils.getMethodExecuteTime(person, params, "fun1", types, true, true);
    }
    @Test
    public void fun3() throws Exception {
        Person person = new Person();
        Object[] params = {12};
        Class<?>[] types = {Integer.class};
        MethodExecuteTimeUtils.getMethodExecuteTime(person, params, "setAge", types, true, true);
        System.out.println(person.getAge());
    }
}

下面是测试代码，比较Java自带的排序方法和归并排序哪个时间复杂度更高。

package algorithm.study.demo2;


import java.util.Arrays;

import org.junit.Test;

import algorithm.study.utils.MethodExecuteTimeUtils;

/**
 * This class implement MergeSort
 * @author ygh
 * 2017年2月23日
 */
public class MergeSort {

    /**
     * Arithmetic thoughts:
     * If we want to sort a array elements,we can sort their left,then
     * sort their right. In the left array, we can use same thought
     * separate the left array to halt then sort them.....
     * At last,it will change into tow number compare,then merge
     * 
     * @param arr The array need to sort
     * @param A temporary array to store elements that have sorted,its length is right-left
     * 
     * @param left The left index of elements you want to sort in this array
     * @param right The right index of elements you want to sort in this array
     */
    public void mergeSort(int[] sortedArr,int[] tmpArr,int left,int right){
        if(left<right){
            int mid = (left+right) / 2;
            mergeSort(sortedArr,tmpArr, left, mid);
            mergeSort(sortedArr,tmpArr, mid+1, right);
            merge(sortedArr, tmpArr,left,mid,right);
            copy(sortedArr, tmpArr,left,right);
        }
    }

    /**
     * Copy elements from temporary array to sorted array. The index range is from left to rigth
     * @param haltSortedArr The array need to sort
     * @param tmpArr The temporary array
     * @param left The left index
     * @param right The right index
     */
    private void copy(int[] haltSortedArr, int[] tmpArr, int left, int right) {
        for(int i=left;i<=right;i++){
            haltSortedArr[i]=tmpArr[i];
        }
    }

    /**
     * This method is to merge elements from haltSortedArr.now the haltSortedArr 
     * has became sorted half by half.The elements' index from left to mid is sorted,and the
     * elements' index from mid to right is sorted.So we just need to merge it to get all order
     * array
     * @param haltSortedArr The array has became sorted half by half
     * @param tmpArr A temporary array to store elements order.
     * @param left The left index of elements you want to sort in this array
     * @param mid The order element separator index
     * @param right The right index of elements you want to sort in this array
     */
    private void merge(int[] haltSortedArr, int[] tmpArr, int left, int mid, int right) {
        int i=left;
        int j=mid+1;
        int d = left;
        while (i <= mid && j <= right) {
            if (haltSortedArr[i] <= haltSortedArr[j]) {
                tmpArr[d++]=haltSortedArr[i++];
            }else{
                tmpArr[d++]=haltSortedArr[j++];
            }
        }
        
        if(i>mid){//If i more mid,indicate some elements have not be put in temporary array in array right
            while(j<=right){
                tmpArr[d++]=haltSortedArr[j++];
            }
        }else{//If i less mid,indicate some elements have not be put in temporary array in array left
            while(i<=mid){
                tmpArr[d++]=haltSortedArr[i++];
            }
        }
    }
    
    
    /**
     * Get a random array by size and max value
     * @param size The size the new array you want to create
     * @param maxValue The max value in the array;
     * @return A randow array
     */
    private int[] getRandomArray(int size,int maxValue){
        int []arr = new int[size];
        for(int i=0;i<size;i++){
            arr[i]=getIntRandomValue(maxValue);
        }
        return arr;
    }
    
    /**
     * Get a random that less than max value
     * @param maxValue The max value you get the random number
     * @return A random number less than max value
     */
    private int getIntRandomValue(int maxValue){
        return (int) (Math.random()*maxValue);
    }
    
    
    /**
     * This is a method to test how long time the mergeSort spend on
     * @param arr The array need to sort
     * @throws Exception
     */
    public void testMergeSort(int[] arr) throws Exception{
        MergeSort m = new MergeSort();
        Class<?>[] types = {int[].class,int[].class,int.class,int.class};
        String methodName = "mergeSort";
        int size = arr.length-1;
        int[] tmp = new int[size];
        mergeSort(arr, tmp, 0, size-1);
        Object[] params={arr,tmp,0,size-1};
        MethodExecuteTimeUtils.getMethodExecuteTime(m, params,methodName,types,true);
    }
    
    /**
     * This is a method to test how long time the javaself sort method spend on
     * @param arr The array need to sort
     * @throws Exception
     */
    public void testJavaSort(int[] arr) throws Exception{
        Class<?>[] types = {int[].class};
        String methodName = "sort";
        Object[] params = {arr};
        //although Arrays can be instance,you use Arrays.class also available,and static method also available
        MethodExecuteTimeUtils.getMethodExecuteTime(Arrays.class, params, methodName, types,true);
    }
    
    /**
     * print array into console
     * @param arr The array need to print console
     */
    public void printArray(int[] arr){
        System.out.println(Arrays.toString(arr));
    }
    
    /**
     * This is just a test method
     * @throws Exception
     */
    @Test
    public void fun3() throws Exception{
        int size = 922000;
        int maxValue = 9999999;
        //construct random array
        int[] arr1 = getRandomArray(size, maxValue);
        int[] arr2 = Arrays.copyOf(arr1, size);
        testMergeSort(arr2);
        testJavaSort(arr1);
    }
    
    
    
    
}