二维数组最大值和二分查找以及泛型化

二维数组找最大，不会，要会就暴力搜索！

//二维数组最大值
    private int maxNum(int[][] arr) {
        int max = arr[0][0];
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j <= arr[i].length - 1; j++) {
                if (arr[i][j] >= max) {
                    max = arr[i][j];
                }
            }
        }
        return max;
    }

二分查找，就酱不要问，反正暂时也不会优化！

//二分搜索前提，数组必须有序
//下面算法按照数组升序实现
public int binarySearch(int[] list, int value) {
        int left = 0;
        int right = list.length;
        while (left <= right) {
            int middle = (left + right) / 2;
            if (value == list[middle]) {
                return middle;
            }
            if (value < list[middle]) {
                right = --middle;
            }
            if (value > list[middle]) {
                left = ++middle;
            }

        }
        return -1;
    }

好了…
改为泛型

//二维数组最大值，法1
 public <E extends Comparable<E>> E max(E[][] list) {

        E maxElement = list[0][0];
        for (int i = 0; i < list.length; i++) {
            for (int j = 0; j <= list[i].length - 1; j++) {
                if (list[i][j].compareTo(maxElement) > 0) {
                    maxElement = list[i][j];
                }
            }
        }

        return maxElement;
    }

//法2，来自百度大法
public <E extends Comparable<E>> E max(E[][] list) {
        E finalmax = list[0][0];
        for (int i = 0; i < list.length; i++) {
            E max = list[i][0];
            for (int j = 0; j < list[i].length; j++) {
                if (list[i][j].compareTo(max) > 0)
                    max = list[i][j];
            }
            if (max.compareTo(finalmax) > 0)
                finalmax = max;
        }
        return finalmax;
    }




//二分查找，数组升序
public <E extends Comparable<E>> int binarySearch(E[] list, E key) {
        int left = 0;
        int right = list.length - 1;
        while (left <= right){
            int middle = (left + right) / 2;
            if(key.compareTo(list[middle]) == 0){
                return middle;
            }
            if(key.compareTo(list[middle]) < 0){
                right = --middle;
            }
            if(key.compareTo(list[middle]) > 0){
                left = ++middle;
            }
        }
        return -1;
    }

对于上述二维数组最大元素和二分查找的泛型方法，如果类型变量 E 是基本类型的包装类，直接调用泛型方法即可（在这些包装类中已经实现compareTo()方法）；反之，如果所给定的类型变量是自己所定义的类，而且重写了compareTo()方法，方法才会被调用成功。

~~