声明式事务，编程式事务，二分查找法的某些变种

学习目标：

学习二分查找法的变种

学习配置并且使用Spring的事务管理

---

学习内容：

掌握了简单的Spring编程式事务的配置与简单应用，

了解了声明式事务的简单配置与应用，其基于SpringAOP环绕通知进行配置，是SpringAOP的一个典型的应用场景。

二分查找法的各种变种实现，其中lower方法未实现完成，还有bug：

public class BinarySearch {
    private BinarySearch(){}
    //非递归实现二分查找法
    public static <E extends Comparable<E>> int search(E[] data, E target) {
        int l = 0, r = data.length - 1;
        //在data[l,r]的范围中查找target
        while (l<=r){
            int mid=l+(r-l)/2;
            if(data[mid].compareTo(target)==0)
                return mid;
            if(data[mid].compareTo(target)<0)
                l=mid+1;
            else
                r=mid-1;
        }
        return -1;
    }
    //递归实现二分查找法
    public static <E extends Comparable<E>> int searchR(E[] data, E target) {
        return searchR(data, 0, data.length - 1, target);
    }

    private static <E extends Comparable<E>> int searchR(E[] data, int l, int r, E target) {
        if(l>r)return -1;
        int mid=l+(r-l)/2;
        if(data[mid].compareTo(target)==0)
            return mid;
        if(data[mid].compareTo(target)<0)
            return searchR(data, mid + 1, r, target);
        return searchR(data, l, mid - 1, target);
    }
    //>target的最小值索引
    public static <E extends Comparable<E>> int upper(E[] data,E target){
        int l=0,r=data.length;
        //在data[l,r]中寻找解
        while (l<r){
            int mid=l+(r-l)/2;
            if(data[mid].compareTo(target)<=0){
                l=mid+1;
            }else{
                r=mid;
            }
        }
        return l;
    }
    //>target，返回最小值索引
    //==target,返回最大索引
    public static <E extends Comparable<E>> int ceil(E[] data,E target){
        int u = upper(data, target);
        if(u-1>=0&&data[u-1].compareTo(target)==0)
            return u - 1;
        return u;
    }
    //>target，返回最小值索引
    //==target,返回最小索引
    public static <E  extends Comparable<E>> int lower_ceil(E[] data,E target){
        int u = upper(data, target);
        while (u-1>=0&&data[u-1].compareTo(target)==0){
            u-=1;
        }
        return u;
    }
    //方法未实现完
    public static <E extends Comparable<E>> int lower(E[] data,E target){
        int l=-1,r= data.length-1;
        while (l<=r){
            int mid=l+(r-l)/2;
            if(data[mid].compareTo(target)<0)
                l=mid;
            else
                return r=mid-1;
        }
        return l;
    }
    public static void main(String[] args) {
        Integer[] arr = {1, 1, 3, 3, 5, 5};
        for(int i=0;i<=6;i++){
            System.out.print(BinarySearch.lower(arr, i) + " ");
        }
        System.out.println();
    }
}

---

学习时间：

11：00-12：00 15：30-17：00

---

学习产出：

通过二分查找法解决了几个常见的关于查找的问题。

学习了Spring事务的配置，并且真实体会了AOP的应用场景，让我对SpringAOP的环绕通知有了进一步的认识。并且理解了事务对于数据库的某些操作具有重要的意义。