Java SE核心内容---异常与数组

一、异常

（一）运行时异常（非检测性异常）

1、算数异常

2、数组下标越界异常

3、空指针异常

4、类型转换异常

5、数字格式异常

（二）IO异常（检测性异常）

（三）异常的捕获格式

try{
//可能产生异常的代码
}catch(异常类型 变量名){
//针对该异常的处理语句块
}finally{
//无论异常是否出现，都会执行的代码
}

（四）手动抛出异常throws

异常一旦抛到的主方法中时，建议将异常捕获。因为在主方法中再次选择异常的抛出，则会将异常抛给JVH，JVN会消耗程序的资源，导致程序运行效率的降低。

（五）自定义异常

自定义异常的规则：

1、自定义异常类去继承于Exception类或其子类。

2、在自定义异常类中提供两个版本的构造器 (一个无参，一个有参)。

一对try、catch只能显示一个异常，如果两个异常同时出现，则会捕获第一个。

二、数组

（一）数组的特性

1.教组中的成员占用连续的存储空间。

⒉数组名实为该数组的首地址，打印格式-[I@6278DFE43

3.数组的成员访问时，注意不要下标越界。

4.数组中的成员数据类型必须相同。

5.Java中数组的长度一旦确定不能增减。

（二）数组的扩容以及拷贝

1、创建新数组长度为原数组的二倍，再将数据转移到新数组中。

int[] arr02 = new int[arr01.length * 2];
for (int i = 0; i < arr01.length; i++) {
       arr02[i]=arr01[i];
}

2、借助数组工类中的copyOf方法

int[] arr03 = Arrays.copy0f(arr01,newLength: arr01.length * 2);

（三）经典算法

1、求最值

2、寻找数组中的指定成员的位置

3、数组的逆序存储（对称互换，类似两数比较大小）

4、冒泡排序法

（四）回文

格式：1234554321、123454321、abccba、abcba

int i;
for (i = 0;i < str.length() / 2 ;i++){
       if(str.charAt(i) != str.charAt(str.length() - 1 - i)){
            break; //如果字符不相同，则跳出循环，并且通过i记录下循环的次数
       }
}

（五）双色球案例---数组

import java.util.Arrays;
import java.util.Random;

/***
 *@ClassName Demo03
 *@Description #TODO  双色球 - 数组版
 *@author zhang
 */
public class Demo03 {
    public static void main(String[] args) {
        /*
        * 红球：1 ~ 33  之间选择6个，不重复，升序
        * 蓝球：1 ~16   之间选择1个
        * */

        Random ran = new Random();//创建随机类对象
        int[] arr = new int[6];//用来存储红球

        int blueBall = ran.nextInt(16) + 1;//蓝球
        for (int i = 0; i < arr.length; i++) {
            int n = ran.nextInt(33) + 1;//生成一个红球
            arr[i] = n;//将红球放到数组中

            for (int j = 0; j < i; j++) {//内循环控制红球是否重复
                if(n == arr[j]){//有相同的情况
                    i--;//将外循环-1，重新摇一次红球
                    break;
                }
            }
        }
        //冒泡升序
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if(arr[j] > arr[j +1]){
                    int t = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = t;
                }
            }
        }
        System.out.println("红球：" + Arrays.toString(arr) + "蓝球：[" + blueBall + "]");
    }
}

三、二维数组

（一）创建

1、int[ ][ ] arr = new int[2][3];//定义了一个2行3列的数组

2、int[ ][ ] arr = {{1,2,3},{4,5,6}};//直接初始化，创建2行3列的数组

（二）访问与赋值

public class Demo05 {
    public static void main(String[] args) {
        //定义的方式创建二维数组
        int[][] arr01 = new int[5][5];//5行5列的二维数组
        //遍历二维数组
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                System.out.print(arr01[i][j] + "\t");
            }
            System.out.println();
        }
        //赋值
        arr01[3][3] = 3;
        arr01[2][4] = 5;
        //二维数组的访问与赋值同样是通过下标。
    }
}

（三）矩阵转置

1、转换前：

1	2	3
4	5	6
7	8	9

2、转换后：

1	4	7
2	5	8
3	6	9

3、代码实现：

public class Demo06 {
    public static void main(String[] args) {
        //初始化方式搭建原有矩阵
        int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};

        //转置前效果
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {//内层循环控制列
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }

        //转置算法
        for (int i = 0; i <3; i++) {
            for (int j = 0; j < 3; j++) {
                if(j > i){//当j > i时需要将位置对调即可
//                    int t = arr[i][j];
//                    arr[i][j] = arr[j][i];
//                    arr[j][i] = t;
//                  位运算中的方式（数值比较小时，可以使用）
                    arr[i][j] ^= arr[j][i];
                    arr[j][i] ^= arr[i][j];
                    arr[i][j] ^= arr[j][i];
                    /*
                    a ^= b;
                    b ^= a;
                    a ^= b;
                    * */
                }
            }
        }

        System.out.println("----------------------------------------");
        //转置后效果
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

（四）杨辉三角

1、效果图

2、代码实现

public class Demo07 {
    public static void main(String[] args) {
        //定义9行9列的数组
        int[][] sj = new int[9][9];
        //周边的1的设置方式
        for (int i = 0; i < 9; i++) {
            sj[i][0] = 1;
            sj[i][i] = 1;
        }

        for (int i = 2; i < 9; i++) {//横坐标的起点
            for (int j = 1; j < i; j++) {//纵坐标的起点
                //由它上一层前一列的值 + 上一层的值
                sj[i][j] = sj[i - 1][j - 1] + sj[i - 1][j];
            }
        }


        //遍历二维数组
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j <= i; j++) {
                System.out.print(sj[i][j] + "\t");
            }
            System.out.println();
        }
    }
}