写一段java 排序代码

### 回答1：
好的，以下是 Java 中的冒泡排序代码：

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        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]) {
                    // swap temp and arr[i]
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        System.out.println("排序后的数组:");
        for (int i=0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

这段代码使用了冒泡排序算法，它通过比较相邻元素的大小并交换位置来排序数组。

### 回答2：
以下是一个简单的Java排序代码，使用冒泡排序算法实现：

public class BubbleSort {
    public static void main(String[] args) {
        // 定义一个待排序的数组
        int[] array = {5, 2, 8, 4, 1};

        // 调用冒泡排序方法
        bubbleSort(array);

        // 打印排序结果
        System.out.println("排序后的数组：");
        for (int num : array) {
            System.out.print(num + " ");
        }
    }

    // 冒泡排序方法
    public static 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;
                }
            }
        }
    }
}

这段代码定义了一个名为`BubbleSort`的类，其中包含了`main`方法和`bubbleSort`方法。在`main`方法中，我们首先定义了一个待排序的数组，然后调用`bubbleSort`方法对数组进行排序，并最后打印排序后的结果。

`bubbleSort`方法使用了冒泡排序算法，其中外层循环控制排序的轮数，内层循环用于比较相邻元素并进行交换。如果发现前一个元素比后一个元素大，则交换它们的位置。通过多次迭代，最大的元素会逐渐移到数组的末尾，达到排序的目的。

以上就是一个简单的Java排序代码。

### 回答3：
以下是一段使用Java编写的排序代码示例：

public class SortAlgorithm {
   
   // 冒泡排序
   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]) {
                   // 交换arr[j]和arr[j + 1]
                   int temp = arr[j];
                   arr[j] = arr[j + 1];
                   arr[j + 1] = temp;
               }
           }
       }
   }

   // 快速排序
   public static void quickSort(int[] arr, int low, int high) {
       if (low < high) {
           int pivot = partition(arr, low, high); // 划分数组，获取基准值的下标
           quickSort(arr, low, pivot - 1); // 对基准值左侧的子数组进行快速排序
           quickSort(arr, pivot + 1, high); // 对基准值右侧的子数组进行快速排序
       }
   }

   private static int partition(int[] arr, int low, int high) {
       int pivot = arr[low]; // 选择第一个元素作为基准值
       int i = low, j = high;
       while (i < j) {
           // 从右向左找到第一个小于基准值的元素
           while (i < j && arr[j] >= pivot) {
               j--;
           }
           if (i < j) {
               arr[i] = arr[j];
               i++;
           }
           // 从左向右找到第一个大于基准值的元素
           while (i < j && arr[i] <= pivot) {
               i++;
           }
           if (i < j) {
               arr[j] = arr[i];
               j--;
           }
       }
       arr[i] = pivot; // 将基准值放入正确的位置
       return i;
   }

   public static void main(String[] args) {
       int[] arr = {6, 3, 8, 2, 9, 1};
       
       // 冒泡排序示例
       bubbleSort(arr);
       System.out.println("冒泡排序结果：");
       for (int num : arr) {
           System.out.print(num + " ");
       }
       System.out.println();

       // 快速排序示例
       quickSort(arr, 0, arr.length - 1);
       System.out.println("快速排序结果：");
       for (int num : arr) {
           System.out.print(num + " ");
       }
   }
}

该代码中包含了两种常见的排序算法：冒泡排序和快速排序。冒泡排序通过多次比较和交换相邻元素的方式将序列中的最大元素逐步移动到最后，从而达到排序的目的。快速排序则通过划分数组和递归操作实现，它选择一个基准值，然后将数组划分为左右两个子数组，再分别对这两个子数组进行快速排序。最终，通过不断将基准值移动到正确位置来实现整个数组的排序。在代码最后的示例中，我们可以看到冒泡排序和快速排序的结果分别打印出来。