在Java中，要實現穩定排序，可以使用歸并排序（Merge Sort）或計數排序（Counting Sort）。這里我將為您介紹這兩種排序方法。

1. 歸并排序（Merge Sort）：

歸并排序是一種分治算法，它將數組分成兩半，然后遞歸地對每一半進行排序，最后將兩個已排序的半部分合并成一個有序數組。歸并排序是穩定的排序算法，因為在合并過程中，相等的元素會保持它們原始的順序。

以下是歸并排序的Java實現：

public class MergeSort {
    public static void main(String[] args) {
        int[] arr = {38, 27, 43, 3, 9, 82, 10};
        mergeSort(arr, 0, arr.length - 1);
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }

    public static void mergeSort(int[] arr, int left, int right) {
        if (left < right) {
            int mid = (left + right) / 2;
            mergeSort(arr, left, mid);
            mergeSort(arr, mid + 1, right);
            merge(arr, left, mid, right);
        }
    }

    public static void merge(int[] arr, int left, int mid, int right) {
        int[] temp = new int[right - left + 1];
        int i = left;
        int j = mid + 1;
        int k = 0;

        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
            }
        }

        while (i <= mid) {
            temp[k++] = arr[i++];
        }

        while (j <= right) {
            temp[k++] = arr[j++];
        }

        System.arraycopy(temp, 0, arr, left, temp.length);
    }
}

2. 計數排序（Counting Sort）：

計數排序是一種非比較排序算法，它通過計算數組中每個元素的出現次數來實現排序。計數排序是穩定的排序算法，因為在處理相等元素時，它們的相對順序不會改變。

以下是計數排序的Java實現：

public class CountingSort {
    public static void main(String[] args) {
        int[] arr = {38, 27, 43, 3, 9, 82, 10};
        countingSort(arr);
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }

    public static void countingSort(int[] arr) {
        if (arr == null || arr.length == 0) {
            return;
        }

        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for (int num : arr) {
            max = Math.max(max, num);
            min = Math.min(min, num);
        }

        int[] count = new int[max - min + 1];
        for (int num : arr) {
            count[num - min]++;
        }

        int index = 0;
        for (int i = 0; i < count.length; i++) {
            while (count[i] > 0) {
                arr[index++] = i + min;
                count[i]--;
            }
        }
    }
}

請注意，計數排序僅適用于整數數組，并且最大值與最小值之間的差值不能過大，否則計數數組將占用大量內存。