Arrays.sort和快速排序

今天在写快排和冒泡的时间比较，后来发现碾压，没办法我就召唤出了Java自带的Arrays.sort想与它一较高低。

首先贴代码：

快排：

//快排
	public static void QuickSort(int array[], int low, int high)
	{
	    int i = low; 
	    int j = high;
	    int x;
	    if(i > j)
	        return;
	    int temp = array[low];
	    while(i != j)
	    {
	        while(array[j] >= temp && i < j)
	            j--;
	        while(array[i] <= temp && i < j)
	            i++;
	        if(i < j){
	        	qsum+=1;
	        	x=array[i];
	        	array[i]=array[j];
	        	array[j]=x;
	        }
	    }
	    //将基准temp放于自己的位置，（第i个位置）
	    x=array[low];
	    array[low]=array[i];
	    array[i]=x;
	    qsum+=1;
	    QuickSort(array, low, i - 1);
	    QuickSort(array, i + 1, high);
	}

冒泡：

//冒泡
    static void maopao(int array[]){
    //循环的次数为数组长度减一，剩下的一个数不需要排序
    for(int i=0;i<array.length-1;++i){
        boolean noswap=true;
        //循环次数为待排序数第一位数冒泡至最高位的比较次数
        for(int j=0;j<array.length-i-1;++j){
            if(array[j]>array[j+1]){
                array[j]=array[j]+array[j+1];
                array[j+1]=array[j]-array[j+1];
                array[j]=array[j]-array[j+1];
                //交换或者使用如下方式
                //a=a^b;
                //b=b^a;
                //a=a^b;
                msum+=1;
                noswap=false;
            }
        }
        if(noswap) break;
    }
    }

Main：

public static void main(String args[]){
		int alen=10000;
		int[] a=new int[alen];
		int[] b=new int[alen];
		int[] c=new int[alen];
		int d;
		for(int i=0;i<alen;i++){
			d=(int)(Math.random()*alen*1000+1);
			a[i]=d;
			b[i]=d;
			c[i]=d;
		}
		//快排
		long qstart=System.nanoTime();
	    QuickSort(a, 0, a.length-1);
	    long qt=System.nanoTime()-qstart;
	    //冒泡
	    long mstart=System.nanoTime();
		maopao(b);
		long mt=System.nanoTime()-mstart;
		//Arrays.sort
		long zstart=System.nanoTime();
	    Arrays.sort(c);
	    long zt=System.nanoTime()-zstart;
		
	    System.out.println("快排交换次数： "+qsum+" ,用时： "+qt/1000.0+"ms");
	    System.out.println("冒泡交换次数： "+msum+" ,用时： "+mt/1000.0+"ms");
	    System.out.println("Java自带排序用时: "+zt/1000.0+"ms");
	}

用Math.random()随机产生了一些数字让数组去排序，因为java数组对象用的是引用，所以就很蠢的创建了三个数组。冒泡是炮灰不用管它。

结果是这样的：

上面代码需要手动按Ctrl+F11，比较样本比较少，所以我改造了一下Main，顺便让冒泡也休息了。

New Main：

public static void main(String args[]){
		int qwin=0;
		for(int q=0;q<10000;q++){
			int alen=10000;
			int[] a=new int[alen];
			int[] b=new int[alen];
			int[] c=new int[alen];
			int d;
			for(int i=0;i<alen;i++){
				d=(int)(Math.random()*alen*1000+1);
				a[i]=d;
				b[i]=d;
				c[i]=d;
			}
			//快排
			long qstart=System.nanoTime();
		    QuickSort(a, 0, a.length-1);
		    long qt=System.nanoTime()-qstart;

			//Arrays.sort
			long zstart=System.nanoTime();
		    Arrays.sort(c);
		    long zt=System.nanoTime()-zstart;
		    qsum=0;
		    if(qt>zt){
		    	qwin+=1;
		    }
		}
		System.out.println("快排胜利几率： "+qwin/10000.0);
	}

结果是这样的：

所以大部分情况下都是自己写的快排快，难道是我打开的方式不对？

还是说JAVA出于某种考虑（用快排比较浪费空间)还是什么其他的原因？

希望有大佬可以看到这个解读一下我的疑问。我用的是JDK8。