如何测试字符串数组搜索的速度？

Question

我为一个 Java 类编写了一个程序，用于在字符串数组中搜索特定目标。程序从数组的开头到数组的末尾搜索目标，然后从数组的末尾到数组的开头搜索。我应该测试两种搜索的速度，看看哪个更快。我该如何测试呢？

这是程序：

public class LinearStringSearch {

    // Array filled with random Strings
    String[] randomStrings = {"apple", "yellow", "fire", "wood", "zinc", 
            "ram", "mouse", "fish", "cheese", "dirt"};

    // Save target arguments for global access(console printing purposes)
    String target;  
    String target2; 

    /**
     * 
     * @param target - the item you want to retrieve from array
     * @param sa - the name of the array
     * @return i - the target, otherwise return error code: -1
     */
    int linearStringSearch(String target, String[] sa) {
          this.target = target;  // set class variable for print access
          for(int i = 0; i < sa.length; ++i) {
             System.out.println("Searching array position: " + i);
             if (sa[i].equals(target)) {
              // System.out.println("Target found! ");
               return i;
             }   
          }
          return -1;
    }

    /**
     * 
     * @param target - the item you want to retrieve from array
     * @param sa - the name of the array
     * @return i - the target, otherwise return error code: -1
     */
    int backwardLinearStringSearch(String target, String[] sa) {
        this.target2 = target;  // set class variable for print access
        for(int i = 9; i < sa.length; --i) {
            System.out.println("Searching array position: " + i);
            if (sa[i].equals(target)) {
                return i;
            }
        }
        return -1; // -1 means that target was not found
    }

     /*
      * The target string is searched from the beginning of the array to the end of the array, then
      * from the end of the array to the beginning of the array. 
      */
    public static void main(String[] args) {

        LinearStringSearch lss = new LinearStringSearch();

        // Search array from beginning to end
        System.out.println("Linear search: ");                          // Print title  
        int index = lss.linearStringSearch("mouse", lss.randomStrings); // Pass arguments
        System.out.println("The target " + "'" + lss.target + "'" +     // Print to console
        " found at array index: "+index);    

        // Search array from end to beginning
        System.out.println("\nBackwards linear search: ");                       // Print title
        int index2 = lss.backwardLinearStringSearch("mouse", lss.randomStrings); // Pass arguments
        System.out.println("The target " + "'" + lss.target2 + "'" +             // Print to console
        " found at array index: "+index2); 
    }   
}

这是输出：

Linear search: 
Searching array position: 0
Searching array position: 1
Searching array position: 2
Searching array position: 3
Searching array position: 4
Searching array position: 5
Searching array position: 6
The target 'mouse' found at array index: 6

Backwards linear search: 
Searching array position: 9
Searching array position: 8
Searching array position: 7
Searching array position: 6
The target 'mouse' found at array index: 6

Answer 1

JVM 非常复杂，因此如果您想获得准确和真实的结果，您必须记住 JIT 的影响。这意味着您需要测试已经通过 JIT 优化的代码，并且不会在方法计时期间更改。所以你必须写microbenchmark - 你可以使用像Caliper 或JMH 这样的库。在 Caliper 的这种情况下，它看起来像这样：

public class MyBenchmark extends Benchmark {
    public void timeMyOperation(int reps) {
      for (int i = 0; i < reps; i++) {
        int index = lss.linearStringSearch("mouse", lss.randomStrings);;
      }
   }
}

Answer 2

看看Java Performance Testing。 System.currentTimeMillis() 或更好的 getCurrentThreadCpuTime() 是你的朋友。如果时间差太小，请考虑多次运行每个测试并比较需要多长时间。