Java中的数组

1      数组No11

数组：存放一组相同类型数据的数据结构

  数组本身是引用数据类型，数组中的元素可以是基本数据类型，也可以是引用数据类型

【

    Java中的数组以对象的形式存在，或者说数组本身是引用数据类型，数组中的元素(数组中的每一个数据)类型可以是基本数据类型，也可以是引用数据类型

】

1.1    声明

如何使用：

  1.声明：

        元素类型[] 引用名;   或   （引用声明，并未产生数组，等价）

         元素类型引用名[];

 

        元素类型变量名[10];不合法，不能在声明时指定数组长度

（因为引用中只是存放了对象的首地址，不可能存放长度信息）

1.2    创建

  2.创建：

        数组的动态初始化：

                          new 元素类型[数组长度]; （创建数组对象时会为每个元素开辟空间，并且赋以初值，

int 0   ，double 0.0,  float0.0F,    short  0 ,  long  0L    Boolean false, 

char 0,    引用类型  null）

 

（2）数组的静态初始化，声明、创建、初始化在一句语句中完成

元素类型【】引用名 = {值1,值2,值3………值n}；

这种方式同时完成创建和初始化，创建的数组的长度就是大括号中的值得个数，

         每一个值之间用逗号，分隔，每个元素的值就是大括号中的值

《注意：静态初始化声明必须和初始化写在一句语句中，否则会出错。》

 创建指定长度，指定元素类型的数组，创建好了的数组长度不能改变，可通过数组对象的length属性来获得长度，这种方式创建的数组，其中的元素的值为默认值（如：int为0，double为0.0,引用类型为null）

 

        数组的静态初始化：

                          元素类型[] 引用={元素1,元素2,元素3...};

                          虽然没有new关键字，但是创建了一个数组对象；创建后自动初始化为{}中的值；数组长度为大括号内元素的个数

                          元素为引用数据类型的数组每个元素都是引用

                      

1.3    访问

  3.访问：

        数组引用名[数字下标]（下标范围从0到length-1，超出范围，会报越界异常<会报数组指针越界异常：java.lang.ArrayIndexOutOfBoundsException>）

        可以通过这种方式访问打印，也可以进行对元素的初始化

访问数组可以对元素进行赋值：数组引用名【数组下标】=元素值

数组的访问和赋值可以用到循环赋值

数组的长度可以用其length属性来动态获得

数组的长度在数组创建后不能更改，如果实在需要一个长度不同的数组，

         只能再创建一个

1.4    排序

排序（升序：随着下标增加，元素越来越大；降序，越来越小）：

1.      冒泡排序

（排序，将原来没有顺序的杂乱数组，变成从小到大（升序）或从大到小(降序)的顺序。）

《升序：将相邻的元素进行比较，如果左边的大，则将它们互换位置，如此不断循环向右判断，直到最大的数字冒到最右边。》

2.      选择排序

 

3.      插入排序

 

【实际开发中，使用Arrays.sort(…..)进行排序】

查找：告诉你某个值，在数组中查找出这个值对应的下标

 

查找：在数组中根据值查找元素，返回找到的元素的下标，如果一个都不符合返回-1.

 

1、  顺序查找

从头到尾遍历数组，如果符合这个值就返回下标，如果一个都不符合返回-1.

 

2、  二分法查找（必须是排过序的数据）

找到数组中间位置的元素和目标值比较，如果目标值大，就扔掉小的那就扔掉小的那一半数据(中间位置左边的)，如果目标值小，就扔掉大的那一半(中间位置右边的)；接下来对以上操作进行循环执行，直到中间位置元素等于目标值，就将其下标返回。

 

【】可变长数组

元素类型………引用名

《表示在方法的形参中声明一个可变长的数组，实参是用逗号隔开的一个单个元素(元素类型是形参数组的元素类型，)，而是这个可变长数组形参使用时还是将其当作数组用》

 

【

main方法的参数

在应用程序启动时可以传入参数，这些参数会自动转换为字符串数组，

我们可以在main方法中通过main方法的形参数组访问这些参数

】

 

数组的拷贝

【用=号进行数组拷贝并不是真正的拷贝，只是将两个引用指向同一个对象

】

 

2      二维数组和异常机制N12

2.1    二维数组的使用

二维数组：数组中的元素也是数组

        1.声明：

                元素类型[][] 引用名; 或

                元素类型 引用名[][];

 

                在声明时不能在中括号中指定长度

 

        2.初始化：

                  ①静态初始化：

                               元素类型[][] 引用名={{元素1，元素2，元素3...},{...},{...}...};

（每个子数组的元素可以各不一样）

                    静态初始化必须和声明在同一语句中

 

           

                  ②动态初始化：

(1)    new 元素类型[长度1][长度2];

 

【长度1：表示这个二维数组中有几个子数组

  长度2：表示每个子数组中有几个元素(这样的话每个子数组长度一样)

(这样初始化出的每个元素的值为类型对应的默认值)】

 

【

New  元素类型[长度1][]

长度1表示

长度2没有写，表示这几个子数组并未创建出来

】

（注意：不能写成new[] [2]）

 

2.2    二维数组的拷贝

二维数组的拷贝：

【

System.arraycopy 是浅克隆，浅拷贝

深度克隆、深拷贝：将数组中的每个元素进行逐一拷贝。

】

                                  长度1表示子数组个数，可以简单认为是行数，长度2表示每个子数组的长度，可以简单认为是列数——————用这种方式初始化每个子数组的长度都一样

 

                               (2)new 元素类型[长度1][]

                                  长度1表示子数组个数，或者行数；长度2不写（不能只写长度2，不写长度1） 

                                  必须要手动创建各个子数组对象，并将各元素引用分别指向它们

                                  每个子数组的长度可以不一样

               

 

 

        3.访问：

                引用名[下标1][下标2]表示二维数组的下标1的子数组的下标2的元素，如arr[0][1]就是第一个子数组的第二个元素

 

                引用名[下标1]表示二维数组的下标为1的元素、子数组的对象

可以通过循环访问二维数组中的所有元素

 

 

2.3    异常机制

Throwale(是Java中所有的异常、错误的父类，直接子类有：Error、Exception)

异常Exception（广义、体系）

  Throwable 可抛的，是所有异常和错误的父类

  Error 严重的问题，不需要程序去处理(错误)

  Exception（狭义）是Throwable的子类，我们的应用程序需要去处理可能需要程序去处理

 

  RuntimeException 运行时异常，它和它的子类都是《非受检异常：unchecked exception》，它以及它的子类异常可以通过编写代码时严密的逻辑避免掉，不一定要通过要通过异常处理机制去处理

    非受检异常：可以不对其进行异常处理，通过严谨的编码逻辑就可以避免的异常

如：ArrayIndexOutofBoundsException数组指针越界、NullPointerException:空指针、ClassCastException：类型转换、AarithmaticException：数学...：

 

    受检异常<checked  exception>：只要是Exception的子类但不是RuntimeException的子类《支系》，都是受检异常，受检异常必须要进行异常处理<受检异常只能用异常处理机制来处理，否则编译不能通过>

如：FileFoundException、IOException、MalformedURLException、ClassNotFoundException...

 

【受检就是一定要检查要处理异常处理，非受检就是不一定要检查，这是辨别受检还是非受检的最直接途径】

 

异常处理：try    catch finally

  如何处理异常：try,catch,finally

try：尝试运行可能出现异常的代码

catch：捕捉某一类型的异常对其进行处理

 

  try{

      代码1

  }catch(异常类型异常引用名){        //catch片段可以有多个

      代码2

  }finally{

      代码3

  }

【尝试运行语句1，如果语句1执行中铺捉了catch小括号中所声明的类型的异常，

那么就中断try中语句的执行，而去执行语句2】

《

注意：

1：catch小括号中的异常类型可以是铺捉到的异常类型的父类

2:try后可跟多个catch

3:多个catch层级处理，异常层级要从想到大进行处理

》

Finally  最终

Try{

语句1

}catch(异常类型引用){

语句2

}finally{

语句3

}  //无论任何情况，语句3都会执行，一般在finally中进行释放资源的操作，因为finally

可以保证执行。

 

throws: 将方法定义中，将方法中产生的异常抛给方法的调用者去解决   (对外抛出)

【[修饰符] 返回类型  方法名(参数列表)  throws  异常类型{

 

}】

throw: 产生一个(创建好了的)异常  

 

异常可以自定义，定义一个类继承Exception(受检异常)、RuntimeException(非受检异常)

 

代码1是要尝试运行的可能出现异常的代码

代码2是捕捉到某种类型（小括号里的类型）异常要执行的处理逻辑

代码3是无论任何情况都会被最终执行的代码，用于收尾工作

 

1.catch()的异常类型可以是实际异常类型的父类

2.一个try可以对应多个并列的catch，表示出现某种类型异常要进行的对应的异常处理

3.如果多个catch中的异常类型有继承关系，那么父类必须写在后面

4.异常出现后同一层级的代码不会被运行

5.即使遇到不能处理的异常，finally中的代码也会被执行

 

 

throws：将方法或构造方法出现的异常向上抛到调用者那里，让它去处理

throw：产生异常的源头（和创建异常（newException()）不一样,throw是产生一个创建好了的异常，让其出现在运行的程序中）

2.4    代码片段总结

数组元素深度克隆、拷贝(循环拷贝数组中的每个元素)

1：【

      int[] array ={1,2,5,25,4,5};

      int[] array2 =new int[array.length];   //创建一个相同长度的数组

     

      for(int i=0;i<array2.length;i++ ){

//      将数组的每个元素赋值为旧数组对应的值

        array2[i] = array[i];

      }

array[0]=458;

】

2：【

int[] array ={1,2,5,25,4,5};

      int[] array2 =new int[array.length];

      //参数说明：

      //一：原数组

      //三：目标数组

      //2：原数组起始位置   4：目标数组起始位置

      //拷贝的长度

      System.arraycopy(array, 0, array2, 0, array.length);

      array[0]=458;

】

3：二维数组拷贝

【

int[][] array ={{1,2,3},{4,5,6}};

      int[][] array2=new int[array.length][array[0].length];

//    System.arraycopy(array, 0, array2, 0, array.length);

      for(int i=0;i<array.length;i++){

        System.arraycopy(array[i], 0, array2[i], 0, array[i].length);

      }

      array[0][0] = 7;

】

4：可变长数组

【

public static void main(String[] args) {

      // TODO Auto-generatedmethod stub

 

      int[] array={4,5,8,7,5,4,4,4,4,1,5,4};//可任意变

      test(array);

   }

   //这个方法的形参就是一个可变长数组

   public static void test(int... arr){

      System.out.println("arr的长度是:"+ arr.length);

      for(int i=0;i<arr.length;i++){

        System.out.println(i);

      }

   }

】

动态创建数组：

1：【

int[][] array = new int[3][4];

】

2：【

int[][] array = new int[4][];

      int ni =1;

      int k=1;

      for(int i=0;i<array.length;i++){//循环

   //每次都手动创建长度为4的子数组对象，并用二维数组的元素去指向

           array[i] = new int[ni]; 

           ni++;

      }

】

 

异常处理机制

1：【

public class TestExample {

   public static void main(String[] args) {

      county();

   }

  

   public static void county(){

      try{

        town();

      }catch(Exception e){

        System.out.println("给钱");

      }

   }

  

   public static void town() throws Exception{

      village();

   }

  

   public static void village() throws Exception{

      throw new Exception();

   }

}

】

2：【

public class TestThrow2 {

 

   public static void main(String[] args) {

      try{

        test();//调用者遇到异常则进行trycatch处理

      }catch(Exception e){

        e.printStackTrace();

      }

   }

   //让test的调用者处理，向上抛出

   public static  void test() throws Exception{

      //产生一个异常

      throw new Exception();

   }

 

}

】

3：【

public class IllegalArrayLengthException extends RuntimeException {

   public IllegalArrayLengthException(String msg){

      super(msg);

   }

}

   public static void main(String[] args) {

      int[] array = {};

      System.out.println(getMin(array));

   }

 

   public static int getMin(int[] array) throws IllegalArrayLengthException{

      if(array.length == 0){

        throw new IllegalArrayLengthException(

              "数组长度不能为0");

      }

      int minIndex = 0;

      for(int i=0;i<array.length;i++){

        if(array[i]<array[minIndex]){

           minIndex = i;

        }

      }

      return array[minIndex];

   }

】

4:自定义异常与综合应用

【

public class ViolentException extends Exception {

   private String name;

   private String address;

   public ViolentException(String message){

      super(message);

   }

   public String getName() {

      return name;

   }

   public void setName(String name) {

      this.name = name;

   }

   public String getAddress() {

      return address;

   }

   public void setAddress(String address) {

      this.address = address;

   }

}

public class TestViolent {

 

   public static void main(String[] args) {

      county();

   }

   public static void county(){

      try{

        town();

      }catch(ViolentException e){

        System.out.println("打听名字:"+ e.getName());

        System.out.println("打听地址:"+e.getAddress());

        System.out.println("给钱");

      }

   }

   public static void town()throws ViolentException{

      village();

   }

   public static void village() throws ViolentException{

      ViolentException e = new ViolentException("暴力抗拆");

      e.setName("张小龙");

      e.setAddress("北滨");

      throw e;

   }

}

】