1.冒泡排序：

两遍for，第一遍决定走几趟，第二遍是每趟交换的次数：

public static void bubbleSort(int [] nums){
    if (nums!=null){
        for(int i = 0;i<nums.length-1;i++){
            for (int j = 0;j<nums.length-1-i;j++){
                if (nums[j]>nums[j+1]){
                    int temp =nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=temp;

                }
            }
        }
    }
    for (int n :nums){
        System.out.println(n);
    }
}
public static void main(String[] args) {
    int []nums = {6,3,8,2,9,1};
    bubbleSort(nums);
}
2.快速排序：
public static void sort(int[] a,int low,int high){
        int start = low;
        int end = high;
        int key = a[low];


        while(end>start){
            //从后往前比较
            while(end>start&&a[end]>=key)  //如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
                end--;
            if(a[end]<key){
                int temp = a[end];
                a[end] = a[start];
                a[start] = temp;
            }
            //从前往后比较
            while(end>start&&a[start]<=key)//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
                start++;
            if(a[start]>key){
                int temp = a[start];
                a[start] = a[end];
                a[end] = temp;
            }
            //此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
        }
        //递归
        if(start>low) sort(a,low,start-1);//左边序列。第一个索引位置到关键值索引-1
        if(end<high) sort(a,end+1,high);//右边序列。从关键值索引+1到最后一个
    }

　　测试：

public static void main(String[] args) {
        int []nums = {6,3,8,2,9,1};
        int[] a = {12,20,5,16,15,1,30,45,23,9};
        int start = 0;
        int end = a.length-1;
        sort(a,start,end);
        System.out.println("快速排序结果：");
        for(int num:a){
            System.out.println(num);
        }
        System.out.println("冒泡排序结果：");
        bubbleSort(nums);
    }