Java学习笔记-基础day-3-数组

数组定义和访问

1、 容器的概念

变量中只能存储一个数据,新的数据进来,老的数据将被替换,如果需要存储多个数据,需要使用容器。

2、数组

概念：java中的数组就是一个容器，可以存储多个数据，但是数据的类型必须一致

特点：

	(1)可以存储多个数据
    (2)多个数据的类型必须保持一致
    (3)数组一旦创建,长度是永远不可以发生改变

public class Box {		
    public static void main(String[] args) {
        //一个变量中只能存储一个数据
        int num = 10;
        System.out.println(num);

        //新的数据进来,老的数据将被替换
        num = 20;
        System.out.println(num);

        //比如我们班有8个学生需要参加考试,每个学生对应一个成绩(整数)
        //可以定义8个int变量
        int a = 80;
        int b = 90;
        int c = 70;
        int d = 50;
        int e = 85;
        int f = 95;
        int g = 59;
        int h = 63;

        //需要求总分
        int sum = a + b + c + d + e + f + g + h;
        //需要求平均分
        int avg = sum/8;
        //需要求最高分和最低分: 实现起来非常麻烦
    }
} 

3、 数组的定义和初始化

定义

1.数组变量定义格式一
数据类型[] 数组名称;	

2.数组变量定义格式二：
数据类型 数组名称[];

public class Array {
    public static void main(String[] args) {
        //定义int变量num
        int num;
        //System.out.println(num);//错误:变量未初始化,不能使用

        //(1)定义一个存储int类型数组的变量arrayInt
        //int类型数组: 该容器中只能存储的是int类型的数字
        int[] arrayInt;
        //System.out.println(arrayA);//错误: arrayInt只是一个用来存储数组的变量,但是目前没有向arrayA中存储数组(未开辟内存空间)

        //(2)定义一个存储double类型数组的变量arrayDouble
        //double类型数组: 该数组容器中只能存储double类型的数据
        double arrayDouble[];

        //(3)定义一个存储char类型数组的变量arrayChar
        //char类型数组: 该数组容器中只能存储char类型的数据
        char[] arrayChar;
    }
}

初始化

数组的第一种初始化方式(动态初始化: 指定数组的长度)
1.格式:
	数据类型[] 数组名称 = new 数据类型[长度];

2.格式解释:
	(1)左侧数据类型: 规定了数组中可以存储哪种类型的数据
    (2)左侧[]: 表示数组的意思
    (3)数组名称: 就是给数组起个名字(相当于门牌号)
    (4)=: 表示赋值,把具体的=右边new出来的数组容器,
            存储到=左边的数组变量中,但是存储的是数组在内存空间的地址值
    (5)new: 创建数组容器,开辟内存空间
    (6)右侧数据类型: 和左侧保持一致
    (7)右侧[]中长度: 是一个int数字,表示数组中可以存储数据的数量,也叫作数组长度

public class Array {
    public static void main(String[] args) {
        //(1)创建一个int类型的数组,可以存储3个int数据,给该数组起个名称叫做arrayInt 
        int[] arrayInt = new int[3];

        //(2)创建一个double类型的数组,可以存储7个double数据,给该数组起个名称叫做arrayDouble
        double[] arrayDouble = new double[7];

        //(3)创建一个char类型的数组,可以存储5个char数据,给该数组起个名称叫做arrayChar
        char[] arrayChar = new char[5];
    }
}    

数组的第二种初始化方式(标准格式静态初始化:指定数组中的每个元素)
1.格式:
	数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3,...元素n};

2.注意:
	(1)右侧[]中不能写长度: JVM会根据{}中元素的数量计算/推导出数组的长度
    	只要右侧[]中写长度,就会报错

    (2){}中的每个元素之间有逗号(英文状态)隔开,最后一个元素后面没有逗号

public class Array {
    public static void main(String[] args) {
        //(1)创建一个int类型的数组,可以存储多个int数据100,200,300,给该数组起个名称叫做arrayInt 
        int[] arrayInt = new int[]{100,200,300};

        //(2)创建一个double类型的数组,可以存储多个double数据1.1,2.2,3.3,4.4,给该数组起个名称叫做arrayDouble 
        double[] arrayDouble = new double[]{1.1,2.2,3.3,4.4};

        //(3)创建一个char类型的数组,可以存储多个char数据'好','想','你',给该数组起个名称叫做arrayChar
        char[] arrayChar = new char[]{'好','想','你'};
    }
}      

数组的第三种初始化方式(简化格式静态初始化:指定数组中的每个元素)
1.格式:
	数据类型[] 数组名称 = {元素1,元素2,元素3,...元素n};

注意:
	(1)右侧不用写长度,JVM根据{}中数组元素的数量推导长度
    (2)虽然没有写new,底层仍然有new的过程
    (3)动态初始化和标准格式的静态初始化,可以分两步完成
    (4)简化格式静态初始化,不能分成两步完成

public class Array {
    public static void main(String[] args) {
        //(1)创建一个int类型的数组,可以存储多个int数据100,200,300,给该数组起个名称叫做arrayInt
        int[] arrayInt = {100,200,300};

        //(2)创建一个double类型的数组,可以存储多个double数据1.1,2.2,3.3,4.4,给该数组起个名称叫做arrayDouble
        double[] arrayDouble = {1.1,2.2,3.3,4.4};

        //(3)创建一个char类型的数组,可以存储多个char数据'真','的','好','想','你',给该数组起个名称叫做arrayChar
        char[] arrayChar = {'好','想','你'};

        //定义数组变量,未赋值
        int[] arr;
        arr = new int[3];//动态初始化指定数组长度
        arr = new int[]{10,20,30};//标准格式静态初始化

        System.out.println("-------------------");
        int[] arr2;
        //arr2 = {100,200,300};//错误: 简化格式静态初始化,不能分成两步完成

    }
}

4、数组的使用

简化格式静态初始化数组的使用

1.数组名称: 代表数组在内存空间的地址值,是一个十六进制的整数
2.索引编号:是一个整数数字
        数组中的每个数据,称之为数组元素
        数组为每个元素进行编号(专业术语叫做索引),该编号从0开始到最大值(数组长度 减 1)
3.数组元素:
	数组名称[索引编号]
    举例:
    	array[3]: 数组array中索引编号为3的元素
4.获取数组长度:
	数组内部有个length属性,专门记录数组的长度
    数组名称.length: 是一个int数字,代表数组的长度

public class ArrayUse {
    public static void main(String[] args) {

        //创建int数组array,元素分别为10,20,30
        int[] array = {10,20,30};//10的索引编号是0,20的索引编号是1,30的索引编号是2

        System.out.println(array);//[I@1540e19d: 数组在内存空间的地址值,是一个十六进制的整数数字

        //打印10
        System.out.println(array[0]);//打印数组array中索引编号为0的元素值: 10

        //打印20
        System.out.println(array[1]);//打印数组array中索引编号为1的元素值: 20

        //打印30
        System.out.println(array[2]);//打印数组array中索引编号为2的元素值: 30

        System.out.println("-----对数组元素进行修改------");

        //把10 修改成 100
        array[0] = 100;//把整数数字100,存储到数组array中索引编号为0的元素中

        //把20 修改成 200
        array[1] = 200;//把整数数字200,存储到数组array中索引编号为1的元素中

        //把30 修改成 300
        array[2] = 300;//把整数数字200,存储到数组array中索引编号为2的元素中
		System.out.println("-----数组元素修改后的打印结果------");

        //打印100
        System.out.println(array[0]);//打印数组array中索引编号为0的元素值: 100

        //打印200
        System.out.println(array[1]);//打印数组array中索引编号为1的元素值: 200

        //打印300
        System.out.println(array[2]);//打印数组array中索引编号为2的元素值: 300

        //获取数组的长度
        int count = array.length;
        System.out.println("数组长度: "+count);

        System.out.println(array[array.length-1]);//30
    }
}

5、数组操作的常见问题

1、 数组越界异常

/*
    数组操作的常见问题一:
        数组索引越界(超出了范围)异常
        1.问题描述: java.lang.ArrayIndexOutOfBoundsException类,数组索引越界异常类
        2.产生原因:
            使用索引编号范围数组元素时,给出的索引编号不存在(超出了范围)
            索引编号范围: 最小值是0,最大值是数组长度 减 1 (one.length - 1)
        3.解决方案:
            根据控制台的打印信息,找到出现问题的索引,进行修改
 */
public class ArrayProblem {
    public static void main(String[] args) {
        //创建int数组array,并初始化
        //int[] one = new int[]{100,200,300};
        int[] one = {100,200,300};//100的索引编号是0,200的索引编号是1,300的索引编号是2
        System.out.println(one);//数组名称one代表数组的内存地址值:[I@1540e09d
        System.out.println(one[0]);//100
        System.out.println(one[1]);//200
        System.out.println(one[2]);//300
        //System.out.println(one[5]);//索引5: 不存在,报出数组索引越界异常
    }
}

2、 数组空指针异常

/*
    数组操作的常见问题二:
        空指针异常
        1.问题描述: java.lang.NullPointerException类,空指针异常类
        2.产生原因:
            null是一个引用类型的常量,可以给任意类型引用变量赋值,
            当把null赋值给数组变量one之后,数组变量one将不再指向堆内存空间的任何数组,
            也就不可以通过one再访问数组元素,只要访问,报出空指针异常

        3.解决方案:
            (1)不要通过值为null的数组变量,访问数组元素
            (2)根据控制台打印的相关异常信息,找到数组变量是null的地方进行修改,
                让数组变量指向一个堆内存空间的数组,就可以访问数组元素了
 */
public class ArrayProblem {
    public static void main(String[] args) {
        //创建int数组array,并初始化
        //int[] one = new int[]{100,200,300};
        int[] one = {100,200,300};//100的索引编号是0,200的索引编号是1,300的索引编号是2
        System.out.println(one);//数组名称one代表数组的内存地址值:[I@1540e19d
        System.out.println(one[0]);//100
        one = null;
        System.out.println(one);//null
        //System.out.println(one[0]);//错误: 空指针异常
    }
}

6、数组遍历

数组遍历：
	就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。
public class EachArray {
    public static void main(String[] args) {
        //创建int数组array,并初始化
        //10的索引编号是0,20的索引编号是1,30的索引编号是2,50的索引编号是3
        int[] array = {10,20,30,50};
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);
        System.out.println(array[3]);
        System.out.println("-----------");
        //发现: 以上代码重复,只有索引0到3是不同的
        //可以使用for循环打印0到3的数字
        for (int i = 0; i < 4; i++) {
            System.out.println("编号: "+i+", 对应的元素值: "+array[i]);
        }
        System.out.println("-----------");
        //发现: 以上for循环中数字4写死了,可以使用数组的长度代替
        for (int i = 0; i < array.length; i++) {
            //System.out.println("索引编号: "+i+", 对应的元素值: "+array[i]);
            System.out.println(array[i]);
        }
    }
}