数组定义格式

  • 一次性声明大量用于存储数据的变量
  • 要存储的数据通常都是同类型数据，例如：考试成绩

数组

（array）是一种用于存储多个相同类型数据的存储模型

  • 格式一：数据类型[] 变量名

    • 例： int[] arr
    • 定义了一个int类型的数组，数组名是arr 推荐

  • 格式二：数据类型 变量名[]

    • 例：int arr[]
    • 定义了一个int类型的变量，变量名是arr数组

数组初始化

  • java中的数组必须初始化后才能使用

    所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值

动态初始化

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值

  • 格式：数据类型[ ] 变量名 = new 数据类型[数组长度]；

  • 范例：int[ ] arr = new int[3];

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    public class ArrayDemo {
        public static void main(String[] args) {
            int[] arr = new int[3];
            /*
            * 左边:
            *   int:说明数组中的元素类型使int类型
            *   []:说明这是一个数组
            *   arr:这是数组的名称
            * 右边:
            *   new:为数组申请内存空间
            *   int:说明数组中的元素类型是int类型
            *   []:说明这是一个数组
            *   3:数组长度，其实就是数组中的元素个数
            * */
        }
    }

数组元素访问

  • 数组变量访问方式

    • 格式：数组名

  • 数组内部保存的数据访问方式

    • 格式：数组名[索引]

  • 索引时数组中数据的编号方式

  • 作用：索引用于访问数组中的数据使用，数组名[索引]等同于变量名，是一种特殊的变量名

    • 特征1：索引从0开始
    • 特征2：索引是连续的
    • 特征3：索引逐一增加，每次加1
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    public class ArrayDemo {
        public static void main(String[] args) {
            int[] arr = new int[3];

            //输出数组名
            System.out.println(arr);

            //输出数组中的元素
            System.out.println(arr[0]); //[I@1540e19d
            System.out.println(arr[1]);
            System.out.println(arr[2]);
        }
    }
    结果------------------------
        [I@1540e19d
    	0
    	0
    	0

内存分配

Java中内存分配

  • 栈内存：存储局部变量
    • 定义在方法中的变量，例如：arr
    • 使用完毕，立刻消失
  • 堆内存：存储new出来的内容（实体，对象）数组在初始化时，会为存储空间添加默认值
    • 整数：0
    • 浮点数：0.0
    • 布尔：false
    • 字符：空字符
    • 引用数据类型：null
  • 每一个new出来的东西都有一个地址值，使用完毕，会在垃圾回收器空闲时被回收

静态初始化

静态初始化：初始化时每个数组元素的初始值，由系统决定数组长度

  • 格式：数据类型 [ ] 变量名 = new 数据类型[ ]{数据1，数据2，数据3…}

    • 范例： int[ ] arr = new int[]{1，2，3};

  • 简化格式：数据类型[ ] 变量名 = {数据1，数据2，数据3…}
    int[ ] arr = {1,2,3};

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    public class Arraytest1 {
        public static void main(String[] args) {
            //定义一个数组
            int[] arr = {1,2,3};

            //输出数组名
            System.out.println(arr);
            
            //输出数组中的元素
            System.out.println(arr[0]);
            System.out.println(arr[1]);
            System.out.println(arr[2]);
        }
    }
    结果-------------------------------
    	[I@1540e19d
    	1
    	2
    	3

数组操作常见的小问题

  1. 索引越界
    索引越界

报错代码：arrayindexout of bounds exception

  1. 空指针异常
    空指针异常

    报错代码：null pointer exception

  2. null:空值，引用数据类型的默认值，表示不指向任何有效对象

数组常见操作

遍历

  • 遍历

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class BianLi {
        public static void main(String[] args) {
            //定义一个数组
            int[] arr = {2,6,9,8,7,5,2,4,6};
            //遍历循环
            for (int x = 0;x < arr.length;x++){
                System.out.println(arr[x]);
            };

        }
    }

获取数组元素数量

  • 格式：数组名.length
    • 范例：arr.length

获取最值

思路：

  1. 定义一个变量，用于保存最大值（或最小值）

    1
    int max

  2. 去数组中第一个数据作为变量的初始值

    1
    int max = arr[0]

  3. 与数组中剩余的数据逐个对比，每次对比将最大值保存到变量中

    1
    2
    3
    4
    5
    for(int x = 1;x < arr.length;x++){
    	if(arr[x] > max){
    		max = arr[x];
    	}
    }

  4. 循环语句结束后打印变量的值

    1
    System.out.println("max:"+max);
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    public class HuoQuMax {
        public static void main(String[] args) {
            //定义数组
            int[] arr = {15,11,6,42,49,4,41,5,151,1,51,51,21,3,46,12,8,498,4};

            //定义一个变量，用于保存最大值
            //取数组中第一个数据作为变量的初始值
            int max = arr[0];

            //与数组中剩余的数据数个对比，每次比对将最大值保存到变量中
            for(int x =1;x < arr.length;x++ ){
                if (arr[x] > max){
                    max = arr[x];
                }
            }

            //循环结束后打印变量的值
            System.out.println("max:"+max);
        }
    }