java写出冒泡排序，快速排序的代码，并设置50个以上数组元素，验证哪个算法用时最短，

好的，我来为您提供冒泡排序和快速排序的Java代码，并进行比较。

1. 冒泡排序：

public static void bubbleSort(int[] arr) {
    int temp;
    int len = arr.length;

    for (int i = 0; i < len - 1; i++) {
        for (int j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换相邻两个元素的位置
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

2. 快速排序：

public static void quickSort(int[] arr, int left, int right) {
    if (left >= right) {
        return;
    }

    int i = left, j = right;
    int pivot = arr[left];

    while (i < j) {
        while (i < j && arr[j] >= pivot) {
            j--;
        }
        if (i < j) {
            arr[i++] = arr[j];
        }

        while (i < j && arr[i] < pivot) {
            i++;
        }
        if (i < j) {
            arr[j--] = arr[i];
        }
    }

    arr[i] = pivot;
    quickSort(arr, left, i - 1);
    quickSort(arr, i + 1, right);
}

为了比较冒泡排序和快速排序的用时，我们可以编写以下测试代码：

public static void main(String[] args) {
    int len = 50;
    int[] arr1 = new int[len];
    int[] arr2 = new int[len];

    Random random = new Random();
    for (int i = 0; i < len; i++) {
        arr1[i] = random.nextInt(100);
        arr2[i] = arr1[i];
    }

    long start1 = System.nanoTime();
    bubbleSort(arr1);
    long end1 = System.nanoTime();
    long time1 = end1 - start1;

    long start2 = System.nanoTime();
    quickSort(arr2, 0, len - 1);
    long end2 = System.nanoTime();
    long time2 = end2 - start2;

    System.out.println("冒泡排序用时：" + time1 + " ns");
    System.out.println("快速排序用时：" + time2 + " ns");
}

在测试代码中，我们生成了一个长度为50的随机整数数组，然后分别使用冒泡排序和快速排序对其进行排序，并计算排序用时。最后，我们将两种算法的用时进行比较。

您可以根据实际情况修改测试代码中的数组长度和随机数范围，以得到更准确的比较结果。

希望这个例子能够帮助您了解冒泡排序和快速排序，并进行比较它们的性能。