java基础-第6章-java数组与异常-阿里云开发者社区

一、数组

数组的概念

概念：具有一组相同数据类型的数据结构。（理解为容器，就是装数据的）

相同数据类型

数据结构：在内存中是连续的内存空间。

数组的使用

使用：

step1：创建数组

step2：操作数据：存储数据，获取数据

数组中可以存储任意类型的数据，但是数组本身是引用类型的。

语法：

动态创建数组：创建和赋值分开写。

数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];

数组定义格式详解：

数组存储的数据类型：创建的数组容器可以存储什么数据类型。

[] : 表示数组。

数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。

new ：关键字，创建数组使用的关键字。

数组存储的数据类型：创建的数组容器可以存储什么数据类型。

[ 长度]：数组的长度，表示数组容器中可以存储多少个元素。

注意：创建数组时要指明数组的大小(长度，容量)，然后再使用,数组有定长特性，长度一旦指定，不可更改。

int [] arr = new int[5]; //先创建
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;

静态创建数组：创建数组和赋值写一起

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
数据类型[] 数组名 = {元素1,元素2,元素3...};

int[] arr = {1,2,3,4,5}

示例：

package com.tuling.part1;
public class Demo1 {
    public static void main(String[] args) {
        int i = 100;
        /*
        数组的标识是[];arr=Array
        语法：
        数据类型[] 数组名 = new 数据类型[数组的长度];
        数组是引用类型
        数组声明之后，没有赋值，那么他的默认值和成员变量一样。。。
         */
        //第一种定义方式：动态初始化，
        int[] arr = new int[3];
        //System.out.println(arr);
        //方法数组元素的语法：数组名[下标]
        arr[0]  =1;//存数据
        arr[1] =2;
        arr[2]= 5;
        System.out.println(arr[0]);//取数据
        System.out.println("arr[1]--->"+arr[1]);
        System.out.println("arr[2]---->"+arr[2]);
        //System.out.println("arr[2]---->"+arr[3]);//访问数组的元素的时候，下标超过了边界，那么会报异常
        //java.lang.ArrayIndexOutOfBoundsException: 3,这个叫数组越界异常
//        String[] arr2 = new String[3];
//        System.out.println("arr2[0]---->"+arr2[0]);
        //可以新建任意类型的数组，但是数组本身是引用类型
        //Object[] arr2 = new Object[3];
        //第二种：静态初始化
        /*
        左边是声明数组，开辟内存；
        右边里面大括号{}包含的元素个数，顺序，会自动计算长度，还有元素的位置
         */
        int[] arr2 = {1,4,5,6,7};//
        //访问数组的长度:数组名.length
        System.out.println("arr2.length="+arr2.length);
    }
}

数组名(arrName)，数组的类型(type)，长度(容量length)，下标(index)，元素(element)

注意点：

数组只有一个名称，即标识符

元素索引标明了元素在数组中的位置，下标从0开始

数组中的每个元素都可以通过下标来访问

数组的长度固定不变，避免数组越界

数组变量属于引用类型

数组元素的默认值和成员变量的默认值一样

数组的遍历

方法一

普通for循环：

for(int i =0 ;i < arr.length;i++){
    System.out.println(arr[i]);
}

方法二

增强for循环(jdk1.5)：

//语法：
for(type element : array){
        System.out.println(element);
}
//示例代码：
for (int e : arr) {
    System.out.println("--->" + e);
}

缺陷：遍历数组或集合时无法访问索引(下标)值

用途：一般用于遍历显示数组或集合中元素的内容。

增强for能不能给数组赋值？

int[] arr = {1,3,4};
        int[] arr2=  new int[3];
        int i=0;
        for(int e:arr){
            //e = 10;//不可以；
            arr2[i] =  e;
            i++;
        }
        for(int a:arr2){
            System.out.println(a);
        }

示例：

package com.tuling.part2;
public class Demo2 {
    public static void main(String[] args) {
        int[] arr = {1,5,4,3,46};//定义一个数组
        System.out.println("数组的长度："+arr.length);
        System.out.println("访问数组的元素arr[0]:"+arr[0]);
        //第一种方式：for循环，通过下标。。。
        for(int i=0;i<arr.length;i++){
            //i=0;arr[0],访问第一个元素
            //i=1;arr[1],访问第二个元素
            //...
            //i=arr.length-1;访问最后一个元素
            System.out.print(arr[i]+"\t");
        }
        System.out.println();
        System.out.println("-----------------");
        //第二种方式：增强for循环，不再通过下标遍历
        /*
        //语法：
            for(type element : array){
                    System.out.println(element);
            }
         */
        for(int e:arr){//把数组arr里面的元素依次赋值给e,
            System.out.print(e+"\t");
        }
        System.out.println();
        System.out.println("----------------");
        //增强for给数组元素直接赋值
        int[] arr2 = new int[3];
        for(int e:arr2){
            e = 10;//不可以给数组的元素赋值
        }
        for(int e:arr2){//把数组arr里面的元素依次赋值给e,
            System.out.print(e+"\t");
        }
    }
}

可变参数

一个方法中，参数的类型确定，但是数量不确定。就可以使用可变参数。

方法当中可变参数，就是数组。

语法：参数类型 … 参数名

调用：参数的数量：0-多个

/**
     * 求多个整数的和：数量不确定，类型确定
     * 可变参数：
     * 语法：数据类型 ... 参数名
     *
     * @return
     */
    public int getSum(int... nums) {
        int sum = 0;
        for(int i= 0;i<nums.length;i++){
            sum += nums[i];
        }
        return sum;
    }

注意事项：

1.一个方法最多只能有一个可变参数。

2.如果形参列表中，除了可变参数，还有其他的参数，可变参数要位于参数列表的末尾。

数组拷贝

浅拷贝：拷贝的是内存地址，

深拷贝：拷贝的是数值。

package com.tuling.part2;

public class Demo2 {
    public static void main(String[] args) {
        int[] nums = new int[3];
        nums[0] = 1;
        nums[1] = 4;
        nums[2]  =5;
        for(int i=0;i<nums.length;i++){
            System.out.println("nums["+i+"]---->"+nums[i]);
        }
        System.out.println();
        int[] arr = nums;//拷贝的是内存地址，
        arr[0] = 20;
        System.out.println(arr[0]);
        System.out.println(nums[0]);
        int[] arr2 = new int[3];
       for(int i=0;i<nums.length;i++){
           arr2[i]  = nums[i];//拷贝的是数值。
       }
       arr2[0] = 90;
        System.out.println("arr2[0]--->"+arr2[0]);
        System.out.println("nums[0]--->"+nums[0]);
    }
}

Arrays数组的工具类

常用方法：

binarySearch(数组，key)–>int，二分搜索

sort(数组)–>void，排序

toString(数组)–>String，按照字符串打印数组中的内容

copyOf(原始数组，新数组长度)–>新数组，数组拷贝

equals(数组1，数组2)–>boolean

示例：

int[] arr1 = {1,3,4,5,8,3};
        int key = 5;
        System.out.println("5所在的下标："+Arrays.binarySearch(arr1,key));
        //Arrays.copyOf,从arr1数组中找打4个元素给新的数组
        int[] arr2 = Arrays.copyOf(arr1,15);//深拷贝
        System.out.println("遍历新的数组:");
        for(int e:arr2){
            System.out.print(e+"\t");
        }
        System.out.println();
        arr2[0] = 100;
        System.out.println("arr1[0]--->"+arr1[0]);
        System.out.println("arr2[0]--->"+arr2[0]);
        System.out.println("-------------");
        int[] arr3 = {1,3,4,5};
        int[] arr4 = {1,3,4,5};
        System.out.println("两个数组是否相等："+arr3.equals(arr4));
        System.out.println("两个数组是否相等："+Arrays.equals(arr3,arr4));
        System.out.println("---------");
        System.out.println(Arrays.toString(arr4));
        System.out.println("---------");
        boolean[] arr5 = new boolean[5];
        Arrays.fill(arr5,false);
        System.out.println("打印一下：");
        System.out.println(Arrays.toString(arr5));
//        for(int i=0;i<arr5.length;i++){
//            arr5[i] = true;
//        }
        System.out.println("------------");
        int[] arr6 = {4,43,6,4,7};
        Arrays.sort(arr6);
        System.out.println(Arrays.toString(arr6));

二维数组

一维数组，容器，存储了一组数据。数组名配合下标获取到的就是元素数据了，也就是数值。

二维数组，容器，存储一维的一维。二维数组中的元素，而是一维数组。

package com.tuling.part4;

public class Demo4 {
    public static void main(String[] args) {
        int[] arr = {1,3,5,6,6};
        int[][] arr2 = new int[3][4];
        System.out.println("arr2:"+arr2);//二维数组的地址
        System.out.println("arr2.length:"+arr2.length);//二维数组的长度
        System.out.println("arr2[0]:"+arr2[0]);//第一个一维数组的地址
        System.out.println("arr2[0].length:"+arr2[0].length);//第一个一维数组的长度
        System.out.println("arr2[0][0]:"+arr2[0][0]);//第一个一维数组的第一个元素；
        System.out.println("--------------------------");
        //二维的数组的静态声明
        int[][] arr3 = {{1,2,3},{4,5},{6,7}};
        System.out.println("二维数组的打印：");
        for(int i=0;i<arr3.length;i++){//外层控制二维里面有多少个一维
            for(int j=0;j<arr3[i].length;j++){
                System.out.print(arr3[i][j]+"\t");
            }
            System.out.println();
        }
        System.out.println("--------------");
        int[][] arr4 = new int[3][];
        System.out.println(arr4[0]);
        arr4[0] = new int[3];
        arr4[1] = new int[2];
        arr4[2] = new int[4];
    }
}

二、异常

概念

程序在运行时的时候，发生的不正常事件，就是所谓的异常。

异常分类

Throwable：可抛出的，一切错误或异常的父类，位于java.lang包中。

Error：JVM、硬件、执行逻辑错误，不能手动处理。常见错误： StackOverflowError、 OutOfMemoryError等。

Exception：程序在运行和配置中产生的问题，可处理。

RuntimeException：运行时异常，可处理，可不处理。

CheckedException：检查时异常，必须处理

package com.tuling.part5;
/**
 * 异常和错误的区别：
 */
public class Demo {
    public static void main(String[] args) {
        //int[] arr = new int[3];
        //System.out.println(arr[0]);
        //数组越界异常，可以处理
        //System.out.println(arr[3]);//java.lang.ArrayIndexOutOfBoundsException: 3
        //错误：
        int[] arr2 = new int[1024*1024*1024];
    }
}

检查异常：由编译器能够检查出来的异常。外部原因导致的异常，程序中必须处理。

FileNotFoundExcetpion

IOException

SQLException

运行时异常：RuntimeException，也叫非受检异常，编译器不检查的异常。往往一些代码的逻辑问题。

NullPointerException

ArrayIndexOutOfBoundsException//数组越界

ArithemicException

ClassCastException

NumberFormatException

示例：

package com.tuling.part5;
import java.io.File;
import java.io.FileInputStream;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo5 {
    public static void main(String[] args) {
        int i=10;
        int j = 0;
        try{
            //int div =i/j;//运行时异常，运行的过程中抛出的异常，
            //可能抛出异常的代码
            //System.out.println("div:"+div);
            int k = Integer.parseInt("wowo");
        }catch (ArithmeticException e){
            //异常的处理
            //System.out.println();
            e.printStackTrace();
        }catch (NumberFormatException e){
            e.printStackTrace();
        }
        System.out.println("end...........");
        //SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd");
        //sdf.parse("wowowwo");//检查异常
//        File file = new File("c:\\a.jpg");
//        FileInputStream fis = new FileInputStream(file);
    }
}

异常产生和传递

异常产生

自动抛出异常：当程序在运行时遇到不符合规范的代码或结果时，会产生异常。

手动抛出异常：语法：throw new 异常类型(“实际参数”)。

产生异常结果：相当于遇到 return语句，导致程序因异常而终止。

异常传递

异常的传递：

按照方法的调用链反向传递，如始终没有处理异常，最终会由JVM进行默认异常处理（打印堆栈跟踪信息）。

受查异常：throws 声明异常，修饰在方法参数列表后端。

运行时异常：因可处理可不处理，无需声明异常。

异常的处理

捕获异常：try，catch，finally

语法规则：

try{
    //可能产生异常的代码
}catch(异常类型1 e){
    //捕获异常的处理
}catch(异常类型2 e){
    //捕获异常的处理
}finally{
     //无论程序是否产生异常，此处的代码一定会被执行。 
    //比如说：释放资源，删除临时文件等。。。
}

注意点：

1.一个try可以匹配多个catch语句

2.如果try中产生了异常对象，那么会跳出try，进到相应的catch中处理异常，从上向下匹配。

3.如果是多个catch语句，那么小的异常捕获处理写前面，大的异常捕获处理写后面。

4.finally是可选的

快捷键

ctrl+alt+t：try，catch，finally语句块

ctrl+alt+L：格式化代码

声明异常throws
方法级别上，向外抛出异常。
方法的声明上就要通过throws关键字声明抛出异常：
public static void test1(int i,int j)throws NullPointerException{
}
[修饰符1，修饰符2.。。] 返回值类型/void 方法名(参数列表) 异常的声明{
}

按照方法的调用链反向传递，如始终没有处理异常，最终会由JVM进行默认异常处理（打印堆栈跟踪信息）。

public static void test1() throws ArithmeticException{
        int i=10;
        int j =0;
        int div = i/j;
        System.out.println("div:"+div);
        System.out.println("test1.....end.....");
}
    public static void test2() throws ArithmeticException{
//        try {
//            test1();
//        } catch (ArithmeticException e) {
//            e.printStackTrace();
//        }
        test1();
        System.out.println("test2......end....");
    }
    public static void test3() throws FileNotFoundException {
        File file = new File("c:\\a.jpg");
        FileInputStream fis = new FileInputStream(file);
    }
    public static void test4() throws Exception{
        //FileNotFoundException
        test3();//检查异常一定要处理，强制处理
    }
    public static void test5() throws Exception{
    }
    public static void test6(){
        test5();
    }
    public static void main(String[] args) {
        try {
            test2();
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }
        System.out.println("main......end......");
    }

运行时异常的抛出，不一定要处理

检查异常的抛出，必须处理

Exception和RuntimeException的区别？

1.RuntimeException是Exception的子类。

2.Exception包含了受检异常，所以抛出Exception以及受检异常时，代码中一定要给与处理。如果抛出的是RuntimeException(运行时异常，非受检)以及它的子类异常，程序中不一定非要处理。

3.重写的时候，子类不能抛出比父类更大的异常

class Person{
    public void eat() throws FileNotFoundException{
    }
}
class Student extends Person{
    @Override
    public void eat() throws  Exception{
    }
}
public class Demo7 {
    public void test(Person p){
        p.eat();
    }
    public static void main(String[] args) {
    }
}

throw关键字

throw和throws的区别？

1.throws，用于定义方法的时候，声明该方法向外抛出异常。

2.throw，主动抛出一个异常的对象。打断程序的执行。配合trycatch，或者throws来使用。

Exception exception = new Exception("我自定义的异常。。");

try {
        throw exception;//自己主动抛出的异常
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("main......end.....");

自定义异常

需继承Exception或Exception的子类，代表特定问题。

异常类型名称望文生义，可在发生特定问题时抛出对应的异常。

常用构造方法：

无参数构造方法。

String message参数的构造方法。

public class AgeException extends RuntimeException{
  public AgeException() {
  super();
  // TODO Auto-generated constructor stub
  }
  public AgeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
  super(message, cause, enableSuppression, writableStackTrace);
  // TODO Auto-generated constructor stub
  }
  public AgeException(String message, Throwable cause) {
  super(message, cause);
  // TODO Auto-generated constructor stub
  }
  public AgeException(String message) {
  super(message);
  // TODO Auto-generated constructor stub
  }
  public AgeException(Throwable cause) {
  super(cause);
  // TODO Auto-generated constructor stub
  }
}

java基础-第6章-java数组与异常

热门文章

最新文章

相关课程

相关电子书

相关实验场景