数组与异常

数组*****

变量：存储单个数据
数组：存储多个数据

数组：

一段连续的内存空间，线性序列
多个相同的数据类型数据的有序集合

特点：

引用数据类型
是定长的，长度一旦确定不可改变
存储的多个数据类型相同
有序的，索引

索引：

连续的内存空间中每一个小空间的序号
从0开始，每次+1
每个数组的第一个空间索引: 0
每个数组的最后一个空间索引: 数组名.length-1

数组长度

数组名.lengt-1

操作数组中的数据：

根据索引操作
数组名[索引]

数组的定义语法
声明：

数据类型[] 数组名；-->推荐
数据类型 数组名[];
数据类型:规定存储的数据的类型

初始化：第一次创建
动态初始化：先创建数组，后赋值

数据类型[] 数组名=new 数据类型[]；
数组只创建不赋值，存在默认值
整数-->0 小数-->0.0 ，布尔-->false 字符--> 空字符|u0000 引用数据类型-->null

静态初始化：创建数组的同时赋值

数据类型[] 数组名=new 数据类型 [] {值列表}；
数据类型[] 数组名={}；

注意

数组中能够存储任意类型的数据

代码：

  //声明
        int[] arr1;
        //动态初始化
        arr1 =new int[3];
        //静态初始化
        int[] arr2=new int[]{1,100,200};
        String[] arr3={"你好","中国"};
        arr1[0]=100;
        arr1[1]=102;
        arr1[2]=106;
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        System.out.println(arr2[0]);
        System.out.println(arr2[2]);
        System.out.println(arr2[3]);
        System.out.println(arr3[0]);
        System.out.println(arr3[1]);
        //变量重新赋值,arr1指向不同的数组
        arr1=new int[5];
        arr1=new int[]{1,2,3};

数组的遍历

1.普通for循环

条件i是索引，需要根据索引来操作数组中的数据

2.增强for循环|for …each

for（数据类型 变量名:数组名|集合名）{
变量名：存储数组中的每一个数据
}

增强for与普通for循环使用区别:

 普通for循环遍历的是索引,操作索引,使用索引,根据索引操作数组中的数据
 增强for只能从前到后的获取每一个数据,但是不能操作使用索引

代码：

char[] arr=new  char[]{'a','b','c','d'};
        //for循环遍历
        for (int i=0; i<=arr.length-1;i++){
            System.out.println(arr[i]);
        }
        //for each
        for (char ch:arr) {
            System.out.println(ch);
        }

集合：

ArrayList：长度可以跟随数组的增删进行改动，存储任意类型的数据，存在索引，可以跟随索引操作
HashSet：自动去重，跟随数组的增删自动改变长度，无序的

Arrays.toString(数组) 返回数组中数据字符串的表现形式

二维数组

一维数组：数组中直接存放数据
二维数组：数组中放数组
二维数组：了解
声明

数据类型 [] []  数组名；-->推荐
数据类型  数组名[] [] ；
数据类型[]  数组名 [] ；

初始化：
动态初始化：先创建数组，后赋值

  数据类型 [] []  数组名=new  数据类型 [外层的二维数组的长度] [内层的一维数组的长度]]；
  数据类型[][] 数组名 = new 数据类型[外层的二维数组的长度][];

静态初始化：创建数组的同时赋值

 数据类型[][] 数组名 = new 数据类型[][]{{1,2,3},{4,5},{6}...};
  数据类型[][] 数组名 = {{1,2,3},{4,5},{6}...};

操作数组中的数据：

数组名[外层索引]  [内层索引]    

二维数组遍历 :

双重for循环嵌套

普通for嵌套普通
普通for嵌套增强
增强for嵌套普通
增强for嵌套增强

使用数组过程中常遇到异常:

    空指针异常 NullPointerException
        引用没有真实指向一个数组对象,指向为null了,还要使用数组
    数组索引越界异常 ArrayIndexOutOfBoundsException
        根据索引使用数组,但是索引<0 || 索引>=数组.length

异常

异常：

程序生病了
非正常运行情况，可以通过程序猿手动解决的

异常体系：

          Throwable
    /       \
 Error     Exception
           /       \
       Runtime      Checked
       Exception    Exception

Error：错误一般为虚拟机生成并脱出的，不由程序猿管理
RuntimeException：运行时异常

运行时期所产生的异常
一般通过增强程序健壮性的代码处理-if

CheckedException：检查时异常|编译时异常

发生在编译期间
只能通过异常处理方案处理
如果不处理程序无法运行

注意 : 如果一旦遇到异常,如果不处理程序无法继续向下执行
说说常见的运行时异常:

    1.空指针异常 NullPointerException
    2.数组索引越界异常 ArrayIndexOutOfBoundsException
      字符串索引越界异常 StringIndexOutOfBoundsException
      索引越界异常 IndexOutOfBoundsException
    3.数学异常 ArithmeticException
    4.类型转换异常 ClassCastException
    5.数字转格式异常 NumberFormatException

异常处理方案 😗***

1.异常抛出 throws

        把异常抛出到上一层处理

2.异常捕获

        try {
            有可能出现异常的代码段;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (NullPointerException e) {
            e.printStackTrace();
        } ...
          catch (Exception e) { --> 接盘侠
            e.printStackTrace();
        } finally{
            一般为资源的关闭等等
        }
        
 如果try中的代码一旦出现异常,try后面的代码不执行,直接执行catch进行捕获
从上到下的判断catch,哪一个catch能够捕获当前异常对象,就执行对应catch后面的{}中的代码
 如果所有的catch都不满足,这个异常最终没有处理,依旧影响执行的继续执行
 一个try后面可以跟1~n个catch
 catch从上到下,要求类型范围从小到大
 finally : 无论try中是否遇到异常,最后都会执行finally中的代码

自定义异常：

自定义的异常类型都会直接或者间接的继承自Exception
直接继承自Exception为编译时异常
继承自RuntimeException为运行时异常
throw 制造异常