里面的解释已经很清楚；以前上课的时候，看懂意思了，没看懂代码。现在大家还是先基础复习一下l

package pattern.sort;

/**
 * Created by ycy on 16/1/16.
 * 冒泡
 * 大得数字下沉,小的数字上浮
 * 详解:冒泡真谛,大的数据走后面,小的数据走前面
 * 第一次讲解;哎
 * 第一个循环是表示还有多少数据需要处理
 * 第二个循环是把最大的数据往最后移动
 *
 */
public class bubble {
    public static void main(String[] args) {
        int[] arr={1,3336,7,88,454,7556};
        for (int i = arr.length-1; i>0 ; i--) {
            //1'每一次需要排序的数量,因为2'里面每次都一个数据移动到最大,
            // 所以每次是递减的次数,2'执行一次,下次排序的数据就少一个了哦(因为最大的已经到最后了)
            for (int j = 0; j <i ; j++) {
                //2'每一次都是修改的j与j+1的值,下次判断j+1 一直到最后一个length位置;
                // -----全部走完就肯定有一个数据走到最后
                if (arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }

        for (int arrone:arr
             ) {
            System.out.println(arrone);
        }
    }
}

2.2 奇偶性排序

奇偶性：排序关键，奇数跟后面一个数据交换。接着进入偶数，也跟后面一个数据交换；就这样把数据所有的数据交互完毕；

    public static void oddEnventSort(int arr[]){
        int exchflag=1,start=0;
        while (exchflag==1||start==1){
            //表示是否发生了交换
            exchflag=0;
            for (int i = start; i <arr.length ; i+=2) {
                if (arr[i] > arr[i+1]) {
                    int temp=arr[i];
                    arr[i]=arr[i+1];
                    arr[i+1]=temp;
                    exchflag=1;

                }
            }
            //用来表示奇偶性,初始时候为0,表示偶数交换;1表示奇数交换
            if (start==0){
                start=1;

            }else {
                start=0;
            }
        }
    }

2.2 奇偶性排序的并行改造

  /////////////////////////修改为并行奇偶性///////////////////////////
    static int exchangeFlag=1;
    static ExecutorService pool= Executors.newCachedThreadPool();
    static int[] array={1,4,2,6,35,3};

    static synchronized void setExchangeFlag(int v){
        exchangeFlag=v;
    }
    static synchronized int getExchangeFlag(){
        return exchangeFlag;
    }
    public static class OddEventSortTask implements  Runnable{
        int i;
        CountDownLatch latch;
        public OddEventSortTask(int i,CountDownLatch latch){
            this.i=i;
            this.latch=latch;
        }


        public void run() {
            if (array[i]>array[i+1]){
                int temp=array[i];
                array[i]=array[i+1];
                array[i+1]=temp;
                setExchangeFlag(1);
            }
            latch.countDown();
        }
    }
    public static void pOddEventSort(int[] arr) throws InterruptedException {
        int start=0;
        while (getExchangeFlag()==1||start==1){
            setExchangeFlag(0);
            //偶数的数组长度,当start=1时候,只有len/2-1 个线程
            CountDownLatch latch=new CountDownLatch(arr.length/2-(arr.length%2==0?start:0));
            for (int i = start; i < arr.length; i+=2) {
                pool.submit(new OddEventSortTask(i,latch));
            }
            //等待所有县城结束
            latch.await();
            if (start==0){
                start=1;
            }else {
                start=0;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        pOddEventSort(array);
        for (int ar:array
             ) {
            System.out.println(ar);
        }
    }

排序的主体是pOddEventSort()方法，它使用ContLatch记录线程数量，每一次迭代，适用单独的线程对每一次元素比较和交换。一下次迭代钱，必须上一次迭代所有线程完毕。