今日完成

1.做了一道面试题，冒泡，选择排序，快速排序

public class Oderdemo {
    public static void main(String[] args) {
        int[] a = new int[]{2, 4, 1, 8, 0, 14, 7};
        
        //1.冒泡排序
//        sort1(a);
//        System.out.println(Arrays.toString(a));
        //2.选择排序,插入排序
//        sort2(a);
//        System.out.println(Arrays.toString(a));
        //3.快速排序
//        sort3(a, 0, a.length - 1);
//        System.out.println(Arrays.toString(a));
        
        sort4(a, 0, a.length - 1);
        System.out.println(Arrays.toString(a));
        
    }
    
    private static void sort4(int[] a, int low, int high) {
        if (low > high) {
            return;
        }
        int i, j, temp, t;
        i = low;
        j = high;
        temp = a[low];
        while (i < j) {
            while (i < j && a[i] <= temp) {
                i++;
            }
            while (i < j && a[j] >= temp) {
                j--;
            }
            if (i < j) {
                t = a[i];
                a[i] = a[j];
                a[j] = t;
                
            }
            
        }
        a[low] = a[i];
        a[i] = temp;
        sort4(a,low,j-1);
        sort4(a,j+1,high);
        
        
    }
    
    private static void sort3(int[] a, int low, int high) {
        int i, j, temp, t;
        if (low > high) {
            return;
        }
        i = low;
        j = high;
        //定义基准位
        temp = a[low];
        while (i < j) {
            while (temp <= a[j] && i < j) {
                j--;
            }
            
            while (temp >= a[i] && i < j) {
                i++;
            }
            if (i < j) {
                t = a[j];
                a[j] = a[i];
                a[i] = t;
            }
            
        }
        a[low] = a[i];
        a[i] = temp;
        System.out.println(Arrays.toString(a));
        sort3(a, low, j - 1);
        sort3(a, j + 1, high);
    }
    
    private static void sort2(int[] a) {
        int minIndex;
        for (int i = 0; i < a.length; i++) {
            minIndex = i;
            for (int j = i + 1; j < a.length; j++) {
                if (a[j] < a[minIndex]) {
                    minIndex = j;
                }
            }
            if (minIndex != i) {
                int temp;
                temp = a[i];
                a[i] = a[minIndex];
                a[minIndex] = temp;
                
            }
        }
    }
    
    private static void sort1(int[] a) {
        int temp = 0;
        for (int i = 0; i < a.length - 1; i++) {
            for (int j = 0; j < a.length - 1 - i; j++) {
                if (a[j] > a[j + 1]) {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
    }
    
    
}

2.在排序的基础上做的二分查找

public static int select(int[] a, int select) {
    int low = 0;
    int high = a.length;
    int mid;
    
    while (low < high) {
        mid = (low + high) / 2;
        if (a[mid] == select) {
            return mid + 1;
        } else if (a[mid] < select) {
            high = mid -1;
            
        } else {
            low = mid - 1;
        }
        
    }
    return -1;
}

3.完善禅道。

4.学习fail-fast

fail-fast产生原因

        通过上面的示例和讲解，我初步知道fail-fast产生的原因就在于程序在对 collection 进行迭代时，某个线程对该 collection 在结构上对其做了修改，这时迭代器就会抛出 ConcurrentModificationException 异常信息，从而产生 fail-fast。

        要了解fail-fast机制，我们首先要对ConcurrentModificationException 异常有所了解。当方法检测到对象的并发修改，但不允许这种修改时就抛出该异常。同时需要注意的是，该异常不会始终指出对象已经由不同线程并发修改，如果单线程违反了规则，同样也有可能会抛出改异常。

        诚然，迭代器的快速失败行为无法得到保证，它不能保证一定会出现该错误，但是快速失败操作会尽最大努力抛出ConcurrentModificationException异常，所以因此，为提高此类操作的正确性而编写一个依赖于此异常的程序是错误的做法，正确做法是：ConcurrentModificationException 应该仅用于检测 bug。下面我将以ArrayList为例进一步分析fail-fast产生的原因。

fail-fast解决办法

        通过前面的实例、源码分析，我想各位已经基本了解了fail-fast的机制，下面我就产生的原因提出解决方案。这里有两种解决方案：

        方案一：在遍历过程中所有涉及到改变modCount值得地方全部加上synchronized或者直接使用Collections.synchronizedList，这样就可以解决。但是不推荐，因为增删造成的同步锁可能会阻塞遍历操作。

        方案二：使用CopyOnWriteArrayList来替换ArrayList。推荐使用该方案。

        CopyOnWriteArrayList为何物？ArrayList 的一个线程安全的变体，其中所有可变操作（add、set 等等）都是通过对底层数组进行一次新的复制来实现的。 该类产生的开销比较大，但是在两种情况下，它非常适合使用。1：在不能或不想进行同步遍历，但又需要从并发线程中排除冲突时。2：当遍历操作的数量大大超过可变操作的数量时。遇到这两种情况使用CopyOnWriteArrayList来替代ArrayList再适合不过了。那么为什么CopyOnWriterArrayList可以替代ArrayList呢？

        第一、CopyOnWriterArrayList的无论是从数据结构、定义都和ArrayList一样。它和ArrayList一样，同样是实现List接口，底层使用数组实现。在方法上也包含add、remove、clear、iterator等方法。

明日计划

1.用户管理，我的页面完善

2.银行限额管理

遇到问题

1.支付demo