JAVA进行时——数组

Rain_Marginal

已于 2023-09-07 15:41:00 修改

阅读量101

点赞数

文章标签：开发语言 java

于 2023-09-07 15:40:14 首次发布

本文链接：https://blog.csdn.net/Rain_Marginal/article/details/132735879

版权

1.数组的概述

数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

1.1 数组的概念

数组名
下标（或索引）
元素
数组的长度

具体内容如下图所示

数组的特点

数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
创建数组对象会在内存中开辟一整块连续的空间，占据的空间的大小，取决于数组的长度和数组中元素的类型。
数组中的元素在内存中是依次紧密排列的，有序的。
数组，一旦初始化完成，其长度就是确定的。数组的长度一旦确定，无法修改。
我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。
数组名中引用的是这块连续空间的首地址。

1.2 数组的分类

1、按照元素类型分

基本数据类型元素的数组：每个元素位置存储基本数据类型的值

引用数据类型元素的数组：每个元素位置存储对象（本质是存储对象的首地址）

2、按照维度分

一维数组：存储一组数据

二维数组：存储多组数据，相当于二维表，一行代表一组数据，且每行数据不要求长度完全相同

2. 一维数组的使用

2.1 一维数组的声明

格式

方式一（推荐）

元素的数据类型[] 一维数组的名称;

方式二（不推荐）

元素的数据类型一维数组的名称[];

// 举例
int[] arr1;
int arr2[];
String arr3[]; // 此时为引用数据类型的数组

数组声明时需明确

数组的维度：在Java中数组的符号是[]，[]表示一维，[][]表示二维
数组的元素类型：即创建的数组容器可以存储什么数据类型的数据。
数组名：就是代表某个数组的标识符，数组名是变量名，按照变量的命名规范来命名。数组名是个引用数据类型的变量，因为它代表一组数据。

2.2 一维数组的初始化

2.2.1 静态初始化

如果数组变量的初始化和数组元素的赋值操作同时进行，那就称为静态初始化。

静态初始化，本质是用静态数据（编译时已知）为数组初始化。此时数组的长度由静态数据的个数决定。

一维数组声明和静态初始化格式

方式1

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

方式2

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

必须在一个语句中完成，不能分成两个语句写

注

new：关键字，创建数组使用的关键字。因为数组本身是引用数据类型，所以要用new创建数组实体。

正确写法

int[] arr1 = new int[]{1,2,3,4,5};
// 或
int[] arr2;
arr2 = new int[]{1,2,3,4,5};
// 或
int[] arr3 = {1,2,3,4,5};

错误写法

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

2.2.2 动态初始化

数组变量的初始化和数组元素的赋值操作分开进行，即为动态初始化。

动态初始化中，只确定了元素的个数（即数组的长度），而元素值此时只是默认值，还并未真正赋自己期望的值。真正期望的数据需要后续单独一个一个赋值。

一维数组声明和动态初始化格式

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

或

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

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

注

数组有定长属性，长度一旦确定无法再次更改

正确写法

int[] arr1 = new int[5];

int[] arr;
arr= new int[5];

错误写法：后面有{}指定元素列表，就不需要在[]中指定元素个数了。

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

2.3 一维数组的使用

2.3.1 数组的长度

数组的元素总个数，即数组的长度

每个数组都有一个属性length指明它的长度，例如：arr.length 指明数组arr的长度(即元素个数)

每个数组都具有长度，而且一旦初始化，其长度就是确定，且是不可变的。

2.3.2 数组元素的引用

每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称数组索引（index）或下标，可以通过数组的索引/下标访问到数组中的元素。

数组名[索引/下标]

数组的下标范围

数组的下标是从0开始算起，因此数组的下标范围为 [0，数组名.length-1]

2.4 一维数组的遍历

将数组中的每个元素分别获取出来，就是遍历

不赘述，上代码

public class ArraysTest {
    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5};
        //打印数组的属性，输出结果是5
        System.out.println("数组的长度：" + arr.length);

        //遍历输出数组中的元素
        System.out.println("数组的元素有：");
        for(int i=0; i<arr.length; i++){
            System.out.println(arr[i]);
        }
    }
}

结果如下所示

2.5 数组元素的默认值

数组是引用类型，当我们使用动态初始化方式创建数组时，元素值只是默认值

基本数据类型：默认初始化值各有不同

引用数据类型：默认初始化值为null（注意null与0不同）

具体如下所示

3. 一维数组的应用

以下简单举一个例子

输出英文星期几

用一个数组，保存星期一到星期天的7个英语单词，从键盘输入1-7，显示对应的单词 {"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"}

代码如下

import java.util.Scanner;

public class WeekArrayTest {
    public static void main(String[] args) {
        //1. 声明并初始化星期的数组
        String[] weeks = {"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"};

        //2. 使用Scanner从键盘获取1-7范围的整数
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入[1-7]范围的整数：");
        int number = scan.nextInt();

        if(number < 1 || number > 7){
            System.out.println("你输入的输入非法");
        }else{
            //3. 根据输入的整数，到数组中相应的索引位置获取指定的元素（即：星期几）
            System.out.println("对应的星期为：" + weeks[number - 1]);
        }
        
        scanner.close();
    }
}

4 多维数组的使用

4.1 概述

Java 语言里提供了支持多维数组的语法。

如果说可以把一维数组当成几何中的线性图形，那么二维数组就相当于是一个表格。

举例如下

某公司对2023年每个月的销售额进行登记，我们应用一维数组

int[] monthData = new int[]{55, 44, 45, 55, 66, 66, 72, 61, 50, 60, 80, 78};

但如果是季度单位存储呢？那就得应用到二维数组

int[][] quarterData = new int[][]{{55, 44, 45}, {55, 66, 66}, {72, 61, 50}, {60, 80, 78}};

4.2 声明与初始化

4.2.1 声明

二维数组声明的语法格式

方式一：推荐
元素的数据类型[][] 二维数组的名称;

方式二：不推荐
元素的数据类型二维数组名[][];
方式三：不推荐
元素的数据类型[] 二维数组名[];

原因如下

若有一个题目，int[] x, y[]; 判断x， y分别是什么数组

此时容易将x和y都答为一维数组，但正确答案是 x是一维数组，y是二维数组

因此由Java代码规范，声明时不应将 [] 分开声明

4.2.2 静态初始化

格式

int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};

定义一个为arr的二维数组，此时二维数组中由三个一维数组

第二个一维数组的长度表示方式：arr[1].length;

举例

int[][] arr1 = {{1,2,3},{4,5,6},{7,8,9,10}};//声明与初始化必须在一句完成

int[][] arr2 = new int[][]{{1,2,3},{4,5,6},{7,8,9,10}};

int[][] arr3;
arr3 = new int[][]{{1,2,3},{4,5,6},{7,8,9,10}};

// 以上为正确写法
//以下为错误写法

arr = new int[3][3]{{1,2,3},{4,5,6},{7,8,9,10}}; // 静态初始化右边new 数据类型[][]中不能写数字

4.2.3 动态初始化

如果二维数组的每一个数据，甚至是每一行的列数，需要后期单独确定，那么就只能使用动态初始化方式了。动态初始化方式分为两种格式：

格式1：规则二维表：每一行的列数是相同的

（1）确定行数和列数

元素的数据类型[][] 二维数组名 = new 元素的数据类型[m][n];
m:表示这个二维数组有多少个一维数组。或者说一共二维表有几行
n:表示每一个一维数组的元素有多少个。或者说每一行共有一个单元格

创建完成了之后，数组的每个值都会是默认值

（2）再为元素赋新值
二维数组名[行下标][列下标] = 值;

格式2：不规则：每一行的列数不一样

（1）先确定总行数
元素的数据类型[][] 二维数组名 = new 元素的数据类型[总行数][];

此时只是确定了总行数，每一行里面现在是null

（2）再确定每一行的列数，创建每一行的一维数组
二维数组名[行下标] = new 元素的数据类型[该行的总列数];

(3)再为元素赋值
二维数组名[行下标][列下标] = 值;

举例

public class DifferentElementCount {
    public static void main(String[] args){
        //1、声明一个二维数组，并且确定行数
        //因为每一行的列数不同，这里无法直接确定列数
        int[][]  arr = new int[3][];

        //2、确定每一行的列数
        for(int i=0; i<arr.length; i++){
			// arr[0] 的列数是1
			// arr[1] 的列数是2
			// arr[2] 的列数是3
            arr[i] = new int[i+1];
        }

        //3、确定元素的值
        for(int i=0; i<arr.length; i++){
            for(int j=0; j<arr[i].length; j++){
                arr[i][j] = i+1;
            }
        }

        //4、遍历显示
        for(int i=0; i<arr.length; i++){
            for(int j=0; j<arr[i].length; j++){
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }

    }
}

结果如下所示

4.3 数组的长度和角标

二维数组的长度/行数：二维数组名.length
二维数组的某一行：二维数组名[行下标]，此时相当于获取其中一组数据。它本质上是一个一维数组。行下标的范围：[0, 二维数组名.length-1]。此时把二维数组看成一维数组的话，元素是行对象。
某一行的列数：二维数组名[行下标].length，因为二维数组的每一行是一个一维数组。
某一个元素：二维数组名[行下标][列下标]，即先确定行/组，再确定列。

4.4 二维数组的遍历

和一维数组相同，直接上格式，不再举例

for(int i=0; i<二维数组名.length; i++){ //二维数组对象.length
for(int j=0; j<二维数组名[i].length; j++){//二维数组行对象.length
System.out.print(二维数组名[i][j]);
}
System.out.println();
}