在Java中实现八种常见的排序算法可以帮助你更好地理解这些算法的工作原理。以下是八种常见排序算法的Java实现：

1. 冒泡排序（Bubble Sort）：

public void bubbleSort(int[] array) {  
    int n = array.length;  
    for (int i = 0; i < n - 1; i++) {  
        for (int j = 0; j < n - i - 1; j++) {  
            if (array[j] > array[j + 1]) {  
                int temp = array[j];  
                array[j] = array[j + 1];  
                array[j + 1] = temp;  
            }  
        }  
    }  
}  

2. 选择排序（Selection Sort）:

public void selectionSort(int[] array) {  
    int n = array.length;  
    for (int i = 0; i < n - 1; i++) {  
        int minIndex = i;  
        for (int j = i + 1; j < n; j++) {  
            if (array[j] < array[minIndex]) {  
                minIndex = j;  
            }  
        }  
        int temp = array[minIndex];  
        array[minIndex] = array[i];  
        array[i] = temp;  
    }  
}  

3. 插入排序（Insertion Sort）:

public void insertionSort(int[] array) {  
    int n = array.length;  
    for (int i = 1; i < n; i++) {  
        int key = array[i];  
        int j = i - 1;  
        while (j >= 0 && array[j] > key) {  
            array[j + 1] = array[j];  
            j--;  
        }  
        array[j + 1] = key;  
    }  
}  

4. 希尔排序（Shell Sort）:

public void shellSort(int[] array) {  
    int n = array.length;  
    for (int gap = n / 2; gap > 0; gap /= 2) {  
        for (int i = gap; i < n; i++) {  
            int key = array[i];  
            int j = i;  
            while (j >= gap && array[j - gap] > key) {  
                array[j] = array[j - gap];  
                j -= gap;  
            }  
            array[j] = key;  
        }  
    }  
}  

5. 归并排序（Merge Sort）:

public void mergeSort(int[] array, int left, int right) {  
    if (left < right) {  
        int mid = (left + right) / 2;  
        mergeSort(array, left, mid);  
        mergeSort(array, mid + 1, right);  
        merge(array, left, mid, right);  
    }  
}  
private void merge(int[] array, int left, int mid, int right) {  
   int n1 = mid - left + 1;  
   int n2 = right - mid;  
   int[] L = new int[n1];  
   int[] R = new int[n2];  
   for (int i = 0; i < n1; ++i)  
       L[i] = array[left + i];  
   for (int j = 0; j < n2; ++j)  
       R[j] = array[mid + 1 + j];  
   int i = 0, j = 0;  
   int k = left;  
   while (i < n1 && j < n2) {  
       if (L[i] <= R[j]) {  
           array[k] = L[i];  
           i++;  
       } else {  
           array[k] = R[j];  
           j++;  
       }  
       k++;  
   }  
   while (i < n1) {  
       array[k] = L[i];  
       i++;  
       k++;  
   }  
   while (j < n2) {  
       array[k] = R[j];  
       j++;  
       k++;  
   }  
}  

6. 快速排序（Quick Sort）:

public void quickSort(int[] array, int low, int high) {  
    if (low < high) {  
        int pi = partition(array, low, high);  
        quickSort(array, low, pi - 1);  
        quickSort(array, pi + 1, high);  
    }  
}  
private int partition(int[] array, int low, int high) {  
    int pivot = array[high];  
    int i = (low - 1);  
    for (int j = low; j < high; j++) {  
        if (array[j] <= pivot) {  
            i++;  
            int temp = array[i];  
            array[i] = array[j];  
            array[j] = temp;  
        }  
    }  
    int temp = array[i + 1];  
    array[i + 1] = array[high];  
    array[high] = temp;  
    return i + 1;  
}  

7. 堆排序（Heap Sort）:

public void heapSort(int[] array) {  
    int n = array.length;  
    for (int i = n / 2 - 1; i >= 0; i--) {  
        heapify(array, n, i);  
    }  
    for (int i = n - 1; i >= 0; i--) {  
        int temp = array[0];  
        array[0] = array[i];  
        array[i] = temp;  
        heapify(array, i, 0);  
    }  
}  
private void heapify(int[] array, int n, int i) {  
    int largest = i;  
    int left = 2 * i + 1;  
    int right = 2 * i + 2;  
    if (left < n && array[left] > array[largest]) {  
        largest = left;  
    }  
    if (right < n && array[right] > array[largest]) {  
        largest = right;  
    }  
    if (largest != i) {  
        int swap = array[i];  
        array[i] = array[largest];  
        array[largest] = swap;  
        heapify(array, n, largest);  
    }  
}  

8. 计数排序（Counting Sort）:

public void countingSort(int[] array) {  
    int max = Arrays.stream(array).max().getAsInt();  
    int min = Arrays.stream(array).min().getAsInt();  
    int range = max - min + 1;  
    int[] count = new int[range];  
    int[] output = new int[array.length];  
    for (int i = 0; i < array.length; i++) {  
        count[array[i] - min]++;  
    }  
    for (int i = 1; i < count.length; i++) {  
        count[i] += count[i - 1];  
    }  
    for (int i = array.length - 1; i >= 0; i--) {  
        output[count[array[i] - min] - 1] = array[i];  
        count[array[i] - min]--;  
    }  
    for (int i = 0; i < array.length; i++) {  
        array[i] = output[i];  
    }  
}  

这些算法各有优缺点，选择使用哪种算法取决于你的数据集的特点和应用的要求。