Java数组 常见异常、获取最值、数组打印、逆序、排序（从小到大）

数组的基本操作

数组常见异常：

NullPointerException:空指针异常，数组未初始化，就直接操作数组

ArrayIndexOutOfBoundsException:索引越界异常

获取最大、最小值：

        int[] age =new int[]{1,8,10,4};
        int max = 0;
        for (int i = 0; i < age.length; i++) {
            if(max <= age[i]){
                max = age[i];
            }
        }
        System.out.println(max);

打印数组，打印出的格式为[a,b,c,d]：

方法1

        int[] age =new int[]{1,8,10,4};
        String start = "[";
        String end = "]";
        String result = "";
        for (int i = 0; i < age.length; i++) {
            if(i == 0){
                result = start + age[i]+ ",";
            }else if(0 < i  && i <  age.length-1){
                result += age[i] + ",";
            }else{
                result += age[i] + end;            
            }
        }
        System.out.println(result);//[1,8,10,4]

方法2

        int[] age =new int[]{1,8,10,4};
        String ret = "[";
        for (int i = 0; i < age.length; i++) {
            ret = ret + age[i];
            if(i != age.length-1){
                ret += ",";
            }
        }
        ret += "]";
        System.out.println(ret);//[1,8,10,4]

逆序排列数组元素：

        int[] num = new int[]{1,8,10,4};
        int[] array = new int[num.length];
        for (int i = num.length -1; i >= 0 ; i--) {
            array[num.length - 1 - i] = num[i];
        }

数组从小到大排序输出：

自创排序：

该排序我觉得类似选择排序，数组与自身比较，拿一个元素和数组中的所有元素比较，若小于其中一个元素，则他们两交换位置，这样生成一个新的数组

比如i = 0的时候，取到的数值是8，拿8与数组中的每一个元素比较，发现10>8，则他们两交换位置，则此时数组变为了[10,1,8,4]

i = 1的时候，取到的数值是1,1 < 10，替换位置数组变为[1,10,8,4],此时再取i = 1的数值为10,10>数组中的任何一个数值，所以数组变为[1,10,8,4]

i = 2 的时候，取到的数值是8，8< 10,替换位置后数组变为[1,8,10,4];

i = 3 的时候，取到的数值是4,4 < 8,替换位置后数组变为[1,4,10,8];再取i = 3的数值 8 < 10,替换位置，数组变为[1,4,8,10]

        int[] num = new int[]{8,1,10,4};
        for (int i = 0; i < num.length; i++) {
            for (int j = 0; j < num.length; j++) {
                if(num[i] < num[j]){
                    int tmp = num[i];
                    num[i] = num[j];
                    num[j] = tmp;
                }
            }
        }

冒泡排序（从大到小）：

简单来说冒泡排序就是数组与自己比较，比较相邻两个元素，如果第一个比第二个小就交换他们的位置（反之亦然）

循环第一轮就可以筛选出最大值

    private static void getNum1() {
        int[] str = new int[]{5,2,1,7,3,9};
        for (int i = 1; i < str.length; i++) {
            for (int j = 1; j <= str.length -i; j++) {
                if(str[j - 1] > str[j]){
                    int temp = str[j];
                    str[j] = str[j-1];
                    str[j -1 ] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(str));
    }

选择排序：

选择排序就是，拿数组的第一个元素和它后面的元素比较，若大于后面某一个元素，则他们两调换位置，此时第一个元素就变为了那个小的元素，然后再拿这个小的元素和后面的元素比较，若是还有比他小的，则再换位置，又得到一个小的，依次类推，则最后得到第一位为最小值

        private static void getNum2() {
        int[] str = new int[]{5,2,1,7,3,9};
        for (int i = 1; i < str.length; i++) {
            for (int j = i; j < str.length; j++) {
                if(str[i-1] > str[j]){
                    int temp = str[j];
                    str[j] = str[i - 1];
                    str[i -1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(str));
        }

插入排序：

        int[] num = new int[]{8,1,10,4};
        for (int i = 1; i < num.length; i++) {
            for (int j = i; j > 0; j--) {
                if(num[j] < num[j -1 ]){//判断当前元素是否小于上一个元素，若小于则换位置
                    int tmp = num[j -1 ];
                    num[j - 1] = num[j];
                    num[j] = tmp;
                }
            }
        }
        /*
        * 解析过程（内从for循环还是num数组，元素个数不变，解析只是假设过程）
        * i = 1，则 j = 1，内层for循环有2个元素{8,1}，比较两个元素，
        *       num[j]=num[1] < num[j-1]=num[0],交换元素位置，则最后数组变为{1,8}
        * i = 2，则 j = 2，内层for循环有3个元素{1,8,10}，比较两个元素，
        *       num[2]=10 > num[1]=8，不做交换
        *       num[1]=8 > num[0]=1，不做交换，则最后数组还是{1,8,10}
        * i = 3，则 j = 3，内层for循环有4个元素{1,8,10,4}，比较两个元素，
        *       num[3]=4 < num[2]=10，交换元素位置，则最后数组变为{1,8,4,10}
        *       num[2]=4 < num[1]=8，交换元素位置，则最后数组变为{1,4,8,10}
        *       num[1]=4 > num[0]=1，不交换元素位置，则最后数组变为{1,4,8,10}
        * */

Arrays类排序

        int[] num = new int[]{8,1,10,4};
        Arrays.sort(num);