冒泡排序真的性能差吗

import java.util.Arrays;

public class CombSort {//梳排序  基于冒泡排序的优化：分组冒泡排序
    private static final CombSort opt = new CombSort();

    public static void main(String[] args) {
        int[] arr = {2,1,2,5,4,3,3,6,7,8,6,5,4,3,5,2,1,2,5,4,3,3,6,7,8,6,5,4,3,5};
        System.out.println("原数组："+Arrays.toString(arr));
        opt.bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
        int[] arr1 = {2,1,2,5,4,3,3,6,7,8,6,5,4,3,5,2,1,2,5,4,3,3,6,7,8,6,5,4,3,5};
        opt.combSort(arr1);
        System.out.println(Arrays.toString(arr1));
    }
    //冒泡排序
    public void bubbleSort(int[] arr){//从小到大
        int count = 0;
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr.length-i-1;j++){//时间复杂度O(n^2)  （n-1）+（n-2）+...+2+1 = n(n-1)/2 等于n平方量阶
                if(arr[j]>arr[j+1]){
                    arr[j] = arr[j] ^ arr[j+1];
                    arr[j+1] = arr[j] ^ arr[j+1];
                    arr[j] = arr[j] ^ arr[j+1];
                    count++;
                }
            }
        }
        System.out.println("bubbleSort交换次数："+count);
    }

    //梳排序
    /*
    * 分组冒泡    类比希尔排序：希尔排序基于插入排序实现， 梳排序基于冒泡实现
    * 每次比较 i 和 i+j  以j跨步作冒泡排序
    * j 数组长度每次除以1.3向下取整
        *  同时设置一个标志位flag初始为true，每次进行内层判断时初始化false，只要内层进行了交换
        *  说明当前的元素还没有排序好，所以设置flag为true继续循环
    * */
    public void combSort(int[] arr){
        int step = arr.length;
        int count = 0;
        int count2 = 0;
                boolean flag = true;
        while (flag || step > 1){//step = 1 的时候 会做一次冒泡 只有在flagtrue时候才会执行
            int i=0;
                        flag = false;
            step = (step/1.3)>1?(int)(step/1.3):1;
            count2++;
            while(i+step<arr.length){
                if(arr[i]>arr[i+step]){
                    arr[i] = arr[i] ^ arr[i+step];
                    arr[i+step] = arr[i] ^ arr[i+step];
                    arr[i] = arr[i] ^ arr[i+step];
                                        flag = true;
                    count++;
                }
                i++;
            }
        }
        System.out.println("combSort交换次数："+count+";分组次数："+count2);
    }
}