比较两个整数数组的最快方法是使用并行计算。可以使用多线程或并行计算库来同时比较数组的元素。

以下是一个使用Java并行计算库的代码示例：

import java.util.Arrays;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

public class ArrayComparison {
    
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3, 4, 5};
        int[] array2 = {1, 2, 3, 4, 6};
        
        boolean isEqual = compareArrays(array1, array2);
        
        System.out.println("Arrays are equal: " + isEqual);
    }
    
    public static boolean compareArrays(int[] array1, int[] array2) {
        if (array1.length != array2.length) {
            return false;
        }
        
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        return forkJoinPool.invoke(new ArrayComparisonTask(array1, array2, 0, array1.length));
    }
    
    private static class ArrayComparisonTask extends RecursiveTask {
        private static final int THRESHOLD = 1000;
        
        private int[] array1;
        private int[] array2;
        private int start;
        private int end;
        
        public ArrayComparisonTask(int[] array1, int[] array2, int start, int end) {
            this.array1 = array1;
            this.array2 = array2;
            this.start = start;
            this.end = end;
        }
        
        @Override
        protected Boolean compute() {
            if (end - start <= THRESHOLD) {
                for (int i = start; i < end; i++) {
                    if (array1[i] != array2[i]) {
                        return false;
                    }
                }
                return true;
            } else {
                int mid = (start + end) / 2;
                ArrayComparisonTask leftTask = new ArrayComparisonTask(array1, array2, start, mid);
                ArrayComparisonTask rightTask = new ArrayComparisonTask(array1, array2, mid, end);
                
                leftTask.fork();
                boolean rightResult = rightTask.compute();
                boolean leftResult = leftTask.join();
                
                return leftResult && rightResult;
            }
        }
    }
}

这个示例中使用了Java的ForkJoinPool并行计算库来将比较任务拆分成更小的子任务，并使用递归方式进行计算。每个子任务比较数组的一部分元素，然后将结果合并，最终得出整个数组的比较结果。通过使用并行计算，可以同时比较数组的多个元素，从而提高比较速度。