冒泡排序的优化

                             **冒泡排序**+设计模式

1. **冒泡排序:**冒泡排序的关键是数组中的数依次比较,大的数往后排,排完
   轮以后接着排序.大的数往后排相当于小的数往前靠,就像水泡
   一样.小的水泡往上冒!故名思意叫做冒泡排序!
2. 策略模式: 策略模式的用意是针对一组算法，将每一个算法封装到具有共 同接口的独立类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。策略模式的结构,策略模式是对算法的包装，是把使用算法的责任和算法本身分开。策略模式通常是把一系列的算法包装到一系列的策略类里面， 作为一个抽象策略类的子类。

package JUC;

import java.util.Comparator;

/**
 * @author DQF
 */
public interface BubbleSortStrategy {
    public <T extends Comparable<T>> void BubbleSort(T[] list);

    public <T> void BulddeSort(T[] list, Comparator<T> comparator);
}


class BsStrategy implements BubbleSortStrategy {

    @Override
    public <T extends Comparable<T>> void BubbleSort(T[] list) {
        /**
         * swapper 为我们的优化量或者是交换变量.
         * 引入这个值的目的是如果我们哪次的排序
         * 已经完全拍好序了我们就不用再去比较直接
         * 结束就可以了.
         * 比如说: swapper  = true;
         * 然后再次进入 fori swapper = false;
         * 然后fork如果有交换我们就置为true 如果一次都没有
         * 交换就表示在某一次已经排好序了就没必要再去fori了
         * 直接退出,提高了代码的效率!
         */
        Boolean swapper = true;
        for (int i = 1, len = list.length; i < len && swapper; i++) {
            swapper = false;
            for (int j = 0; j < len - i; j++) {
                if (list[j].compareTo(list[j + 1]) > 1) {
                    T exchangeNumber = list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = exchangeNumber;
                    swapper = true;
                }

            }
        }
    }

    @Override
    public <T> void BulddeSort(T[] list, Comparator<T> comparator) {
        Boolean swapper = true;
        for (int i = 1, len = list.length; i < len && swapper; i++) {
            swapper = false;
            for (int j = 0; j < len - i; j++) {
                if (comparator.compare(list[j], list[j + 1]) > 0) {
                    T exchangeNumber = list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = exchangeNumber;
                    swapper = true;
                }
            }
        }
    }
}