changing elapsed time by calling method order in java

Question

I found some issue when i code in java.

I coded Linear search and Binary search code by my self. This database already sorted. They have several duplicated value.

I wanted to check which searching algorithm is faster. (It might be Binary, I think.)

But when i changed the order of calling method in main method, the elapsed time is changed.

In this code, I measured elapsed time of binary search first,

The result is:

• BinarySearch : 70840459
• LinearSearch : 26856500

when i changed the order, the result also reversed.

• LinearSearch : 70661958
• BinarySearch : 80969208

Do you know why this happend?

import java.io.File;
import java.util.*;

public class Test {

    private static void quickSort(Object[] arrays, int start, int end) {

        int i = start;

        int j = end;

        if (j - i >= 1) {
            Object pivot = arrays[i];
            while (j > i) {
                while (arrays[i].compareTo(pivot) <= 0 && i < end && j > i) {
                    i++;
                }
                while (arrays[j].compareTo(pivot) >= 0 && j > start && j >= i) {
                    j--;
                }
                if (j > i)
                    swap(arrays, i, j);
            }

            swap(arrays, start, j);
            quickSort(arrays, start, j - 1);
            quickSort(arrays, j + 1, end);
        }
    }

    private static void swap(Object[] arrays, int i, int j) {
        Object temp = arrays[i];
        arrays[i] = arrays[j];
        arrays[j] = temp;
    }


    private static void BinarySearch(Object[] arrays, String key) {

        int start = binarySearchForDepartment(arrays, key);
        int end = binarySearchLastRecordForDepartment(arrays, key);

        if (start < 0) {
            start = -(start + 1);
            System.out.println("Not an existing " + key + "!");
        }

        for (int a = start; a < end+1; a++) {
            if (arrays[a].getDepartment().equals(key))
                System.out.println(arrays[a].toString());
        }
    

    }
    
    public static int binarySearchForDepartment(Object[] arrays, String key) {
        int left = 0;
        int right = arrays.length - 1;
        int index = -1;

        while (left <= right) {
            int mid = (left + right) / 2;
            if (arrays[mid].getDepartment().compareTo(key) < 0) {
                left = mid + 1;
            } else if (arrays[mid].getDepartment().compareTo(key) > 0) {
                right = mid - 1;
            } else {
                index = mid;
                right = mid - 1;
            }
        }

        return index;
    }
    
    public static int binarySearchLastRecordForDepartment(Object[] arrays, String key) {
        int left = 0;
        int right = arrays.length - 1;
        int index = -1;

        while (left <= right) {
            int mid = (left + right) / 2;
            if (arrays[mid].getDepartment().compareTo(arrays) < 0) {
                left = mid + 1;
            } else if (arrays[mid].getDepartment().compareTo(arrays) > 0) {
                right = mid - 1;
            } else {
                index = mid;
                left = mid + 1;
            }
        }

        return index;
    }


    private static void linearSearch(Object[] arrays, String key) { 
        
        for (int a = 0; a < arrays.length; a++) {
            if (key.equals(arrays[a].getDepartment())) {
                System.out.println(arrays[a].toString());
            }
        }
    }

    public static void main(String[] args) throws Exception {

        
        long startBin = System.nanoTime();
        
        
        Object[] arrayBin = new Object[arrays.length];
            
        for(int a = 0; a<arrayBin.length; a++) {
            arrayBin[a] = arrays[a];    
            }
            quickSort(arrayBin, 0, arrayBin.length-1);
            
            BinarySearch(arrayBin,"A");
            
            long endBin = System.nanoTime();
            long elapsedTimeBin = endBin - startBin;
            System.out.println("The average elapsed Time of BinarySearch : " + elapsedTimeBin + " nanoseconds");
        
    long startLin = System.nanoTime();
        
    Object[] arrayLin = new Object[arrays.length];
    
    for(int a = 0; a<arrayLin.length; a++) {
        arrayLin[a] = arrays[a];    
    }
    quickSort(arrayLin, 0, arrayLin.length-1);
    
    linearSearch(arrayLin,"B");
    
    long endLin = System.nanoTime();
    long elapsedTimeLin = endLin - startLin;
    System.out.println("The average elapsed Time of LinearSearch : " + elapsedTimeLin + " nanoseconds");


    }

}