Java 为什么二进制搜索有时需要很长时间？

我编写了两个程序，创建随机整数[]，然后生成随机整数进行搜索。嗯，实际上我只写了一个程序，然后修改了搜索方法（就像我应该为OOP做的那样，对吧？）。我正在使用System.nanoTime（）计算搜索过程中经过的时间。对于线性搜索，我得到的值始终为10000-13000，对于二进制搜索，我得到的值通常小于5000倍（所有搜索的排序时间平均值，仅搜索一次通常小于4000倍）。不过，偶尔，它的返回时间会超过13000次，甚至比最长的线性搜索还要长

我在任务管理器（Windows）中将java优先级设置为实时。什么会导致搜索时间增加三倍或更多？FWIW，我得到大约1个线性尖峰，每3或4个二进制，线性尖峰大约是正常时间的两倍（22000是迄今为止最差的）。这与我编写代码的方式有关吗

如果您不想通读整个过程，在这两种情况下，我都会在调用搜索方法之前的一行和之后的一行中记录时间，因此如果您认为可能存在问题，可以跳到搜索方法。这个数字的报告是从一个程序复制/粘贴到另一个程序，但二进制搜索程序有更多的报告，我认为这会很有趣。提前谢谢

import java.util.Random;

public class LinearSearchTimer{

public static void main(String[] args){

    int[] numbers;
    final int MAX_RUNS;
    double time1, time2, timeSpent, timeTotal;
    int searchedNumber;
    Random rand = new Random();
    boolean result;
    boolean[] resultArr;
    int resultCounter;
    double pctTrue;

    MAX_RUNS = 1000;
    numbers = new int[MAX_RUNS];
    resultArr = new boolean[MAX_RUNS]; 
    resultCounter = 0;
    timeTotal = 0;


    //build array with random ints  
    for(int k = 0; k < numbers.length; k++){
        numbers[k] = rand.nextInt(10001);
    }


    //generate random number and search array for it, then store to result array
    for(int i = 0; i < numbers.length; i++){
        searchedNumber = rand.nextInt(10001);
        time1 = System.nanoTime();
        result = search(numbers, searchedNumber);
        time2 = System.nanoTime();
        resultArr[resultCounter] = result;
        resultCounter++;
        timeSpent = time2 - time1;
        timeTotal += timeSpent;

    }
    pctTrue = resultPercent(resultArr);
    System.out.println("Avg time : " + timeTotal / MAX_RUNS);
    System.out.println("Percent found: " + pctTrue * 100);


}

//search algorithm, returns true if found, false if not
public static boolean search(int[] numbers, int searchedNumber){
    int i = 0;
    boolean found = false;
    while (found == false && i < numbers.length){
        if (numbers[i] == searchedNumber)
            found = true;
    i++;
    }
    return found;
}

public static double resultPercent(boolean[] arr){
    int trueCount = 0;
    double result;
    double runs;
    for(boolean element : arr){
        if (element == true)
            trueCount++;
    }
    runs = arr.length;//for calculating percentage as a forced double
    result = trueCount / runs;
    return result;

}

    }

import java.util.Random；
公共类LinearSearchTimer{
公共静态void main（字符串[]args）{
int[]数字；
最终int MAX_运行；
double time1、time2、TimePent、timeTotal；
整数搜索数；
Random rand=新的Random（）；
布尔结果；
布尔[]结果器；
int结果计数器；
双光子晶体；
最大运行次数=1000；
数字=新整数[最大运行次数]；
resultArr=新布尔值[MAX_RUNS]；
结果计数器=0；
timeTotal=0；
//使用随机整数构建数组
for（int k=0；k

然后

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

public class BinarySearchTimer{

public static void main(String[] args){

    //declare variables
    int[] numbers;
    final int MAX_RUNS;
    double time1, time2, timeSpent, timeTotal;
    int searchedNumber;
    Random rand; 
    boolean result;
    boolean[] resultArr;
    int resultCounter;
    double pctTrue;
    double timeSort1, timeSort2, timeSortSpent;

    //instantiate variables
    MAX_RUNS = 1000;
    numbers = new int[MAX_RUNS];
    resultArr = new boolean[MAX_RUNS]; 
    resultCounter = 0;
    timeTotal = 0;
    rand = new Random();


    //build array with random ints  
    for(int k = 0; k < numbers.length; k++){
        numbers[k] = rand.nextInt(10001);
    }

    //sort array
    timeSort1 = System.nanoTime();
    Arrays.sort(numbers);
    timeSort2 = System.nanoTime();
    timeSortSpent = timeSort2 - timeSort1;


    //generate random number and call search method
    for(int i = 0; i < numbers.length; i++){
        searchedNumber = rand.nextInt(10001);

        //get start time
        time1 = System.nanoTime();
        result = search(numbers, searchedNumber, 0, numbers.length - 1);
        //get end time
        time2 = System.nanoTime();


        resultArr[resultCounter] = result;
        resultCounter++;
        timeSpent = time2 - time1;
        timeTotal += timeSpent;

    }
    pctTrue = resultPercent(resultArr);
    System.out.println("Avg time : " + timeTotal / MAX_RUNS);
    System.out.println("Percent found: " + pctTrue * 100);
    System.out.println("Actual sort time: " + timeSortSpent);
    System.out.println("Sort time shared per search: " + timeSortSpent / MAX_RUNS);
    System.out.println("Effective average search time: " + (timeTotal / MAX_RUNS + timeSortSpent / MAX_RUNS));

}

//search algorithm, returns true if found, false if not
public static boolean search(int[] numbers, int searchedNumber, int low, int high){
    int mid = (high + low) / 2;
    if(low > high)
        return false;
    if(numbers[mid] == searchedNumber){
        return true;
    }
    else if(searchedNumber < numbers[mid]){
        mid--;
        return search(numbers, searchedNumber, low, mid);
    }
    else if(searchedNumber > numbers[mid]){
        mid++;
        return search(numbers, searchedNumber, mid, high);
    }
    return false;
}


public static double resultPercent(boolean[] arr){
    int trueCount = 0;
    double result;
    double runs;
    for(boolean element : arr){
        if (element == true)
            trueCount++;
    }
    runs = arr.length;//for calculating percentage as a forced double
    result = trueCount / runs;
    return result;

}

导入java.util.array；
导入java.util.Random；
公共类二进制搜索计时器{
公共静态void main（字符串[]args）{
//声明变量
int[]数字；
最终int MAX_运行；
double time1、time2、TimePent、timeTotal；
整数搜索数；
随机兰德；
布尔结果；
布尔[]结果器；
int结果计数器；
双光子晶体；
双时差1，时差2，时差花费；
//实例化变量
最大运行次数=1000；
数字=新整数[最大运行次数]；
resultArr=新布尔值[MAX_RUNS]；
结果计数器=0；
timeTotal=0；
rand=新随机数（）；
//使用随机整数构建数组
for（int k=0；k高）
返回false；
如果（数字[mid]==搜索数字）{
返回true；
}
else if（searchedNumber<数字[mid]）{
中--；
返回搜索（数字、searchedNumber、low、mid）；
}
else if（searchedNumber>数字[mid]）{
mid++；
返回搜索（数字、searchedNumber、中、高）；
}
返回false；
}
公共静态双结果百分比（布尔值[]arr）{
int-trueCount=0；
双重结果；
双重运行；
for（布尔元素：arr）{
if（元素==true）
trueCount++；
}
runs=arr.length；//用于将百分比计算为强制双精度
结果=trueCount/次；
返回结果；
}

}

功能正常的bi