用java写一段代码，比较内部排序算法它们在随机数据、有序数据、逆序数据等不同情况下的表现

以下是一个基于Java语言实现内部排序算法比较的示例代码：

import java.util.Arrays;
import java.util.Random;

public class SortCompare {
    public static void main(String[] args) {
        int[] arr1 = generateRandomArray(10000);
        int[] arr2 = Arrays.copyOf(arr1, arr1.length);
        int[] arr3 = Arrays.copyOf(arr1, arr1.length);
        long startTime, endTime;
        
        // 测试冒泡排序
        startTime = System.currentTimeMillis();
        bubbleSort(arr1);
        endTime = System.currentTimeMillis();
        System.out.println("冒泡排序耗时：" + (endTime - startTime) + "ms");
        
        // 测试选择排序
        startTime = System.currentTimeMillis();
        selectionSort(arr2);
        endTime = System.currentTimeMillis();
        System.out.println("选择排序耗时：" + (endTime - startTime) + "ms");
        
        // 测试快速排序
        startTime = System.currentTimeMillis();
        quickSort(arr3, 0, arr3.length-1);
        endTime = System.currentTimeMillis();
        System.out.println("快速排序耗时：" + (endTime - startTime) + "ms");
    }
    
    // 生成随机数组
    public static int[] generateRandomArray(int n) {
        int[] arr = new int[n];
        Random rand = new Random();
        for(int i=0; i<n; ++i) {
            arr[i] = rand.nextInt(n);
        }
        return arr;
    }
    
    // 冒泡排序
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        for(int i=0; i<n-1; ++i) {
            for(int j=0; j<n-i-1; ++j) {
                if(arr[j] > arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
    
    // 选择排序
    public static void selectionSort(int[] arr) {
        int n = arr.length;
        for(int i=0; i<n-1; ++i) {
            int minIndex = i;
            for(int j=i+1; j<n; ++j) {
                if(arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
    
    // 快速排序
    public static void quickSort(int[] arr, int left, int right) {
        if(left < right) {
            int pivot = partition(arr, left, right);
            quickSort(arr, left, pivot-1);
            quickSort(arr, pivot+1, right);
        }
    }
    
    public static int partition(int[] arr, int left, int right) {
        int pivot = arr[right];
        int i = left - 1;
        for(int j=left; j<right; ++j) {
            if(arr[j] < pivot) {
                ++i;
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        int temp = arr[i+1];
        arr[i+1] = arr[right];
        arr[right] = temp;
        return i+1;
    }
}

在该代码中，我们定义了一个`SortCompare`类，其中包含了三个内部排序算法：冒泡排序、选择排序、快速排序。我们首先通过`generateRandomArray`函数生成一个长度为10000的随机数组，并使用`Arrays.copyOf`复制该数组三次，分别作为三个排序算法的输入。

接下来，我们对三个数组分别使用三个排序算法进行排序，并记录每个算法的耗时。最终，我们将三个排序算法的耗时输出到控制台，以便比较它们在不同情况下的表现。

当然，如果需要比较更多的排序算法，可以在代码中添加相应的函数，并对它们进行相同的测试和比较。