(JavaSE) 数组

1. 数组的作用


当我们要对打印几位学生其中一门科目的成绩时

public class Blogs {
    public static void main(String[] args) {
        int score1 = 60;
        int score2 = 69;
        int score3 = 79;
        int score4 = 83;
        int score5 = 99;
        System.out.println(score1);
        System.out.println(score2);
        System.out.println(score3);
        System.out.println(score4);
        System.out.println(score5);
    }
}

在这里插入图片描述这样写是没问题的,但是当我们要打印全校的学生成绩呢,那就会很麻烦,
值得注意的是成绩的类型都是一样的,这时我们就可以使用数组进行打印。


2. 数组的创建及初始化


2.1 数组的创建

在这里插入图片描述

int[] array1 = new int[5];  //创建一个可以容纳5个 int 类型元素的数组
double[] array2 = new double[5]; //创建一个可以容纳5个double类型元素的数组
char[] array3 = new char[5]; //创建一个可以容纳5个char类型元素的数组


2.2 数组的初始化

初始化的三种方式

public class Blogs2 {
    public static void main(String[] args) {
        //第一种初始化方式
        int[] array1 = {1, 2, 3, 4, 5, 6, 10};
        //第二种初始化方式
        int[] array2 = new int[]{1, 2, 3, 4, 5, 6, 10};
        //第三种初始化方式
        int[] array3 = new int[7];
        System.out.println(array1.length); //同过 数组名.length 计算数组长度
    }
}
  1. 第一、二种初始化方式为静态初始化,静态初始化即在创建数组时不直接指定数据元素个数,而直接将具体的数据内容进行指定,即在初始化时编译器会根据 {} 中元素个数确定数组长度,第二种中 T[] 的 [] 中不能输入具体的数字。
  2. 第一种其实是和第二种是一样的,这样写就是省略了 new int[] 但是编译器在编译代码时会还原。
  3. 第三种为动态初始化,动态初始化即在创建数组时,直接指定数组中元素的个数,T[] 的 [] 中必须指明数组长度,当我们没有对其进行赋值时,默认为类型对应的 0 值,如果数组中存储元素类型为引用类型,默认值为null。
  4. 计算数组长度方法,数组名.length

注意:使用静态初始化分两行写时不可以省略 new T[]

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

3. 数组的使用


3.1 数组中元素的访问

数组的下标是从 0 开始的,通过下标可以访问和修改元素,如下图:

在这里插入图片描述

public class Main {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        array[2] = 19; //下标为2的元素变为19
        System.out.println(array[2]); //打印下标为2的元素
    }
}

下标为 2 的元素被改变了,即元素 3 变为 19
在这里插入图片描述



3.2 遍历数组方法

所谓 “遍历” 是指将数组中的所有元素都访问一遍, 访问是指对数组中的元素进行某种操作

1. 使用 for 循环进行遍历。

public class Main {
	public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
}

在这里插入图片描述


2. 使用 for-each 进行遍历

public class Main{
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        for (int x : array) { //将 array 中元素值从0下标开始逐一赋值给x
            System.out.print(x + " ");
        }
    }
}

在这里插入图片描述

这个意思是每循环一次 array 就会把一个值赋给 x ,直到数组中元素都赋值一遍,需要注意的是冒号左边的类型需要和 array 数组类型一致

3. 使用 Arrays 工具类的方法进行遍历


toString()用法

import java.util.Arrays;
public class Main{
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        String ret = Arrays.toString(array); //会返回一个字符串,需要接收
        System.out.println(ret);
    }
}

结果

1. 传入数组会返回一个字符串的表达方式
2. 使用 Arrays.toString(); 时需要在开头写 import java.util.Arrays; 原因是使用库的工具类时需要说明。
3. 使用时会返回一个字符串,所以要用一个 String 引用类型进行接收



4. 数组是引用类型


4.1 JVM中的内存有那些

内存是一段连续的存储空间,主要用来存储程序运行时数据的。比如:

  1. 程序运行时代码需要加载到内存
  2. 程序运行产生的中间数据要存放在内存
  3. 程序中的常量也要保存
  4. 有些数据可能需要长时间存储,而有些数据当方法运行结束后就要被销毁
  5. 如果对内存中存储的数据不加区分的随意存储,那对内存管理起来将会非常麻烦。

JVM内存分布

4.2 数组如何开辟空间

public class Main{
    public static void main(String[] args) {
        int[] array = {2, 3, 6, 19};
    }
}

以下是 array 开辟空间过程:
在这里插入图片描述

我们试着打印 array 这个变量,它会是一个地址。

public class Main{
    public static void main(String[] args) {
        int[] array = {2, 3, 6, 19};
        System.out.println(array);
    }
}

在这里插入图片描述


4.3 数组 null 的意思

int[] array = null; 代表这个引用 不指向任何对象
public class Main{
    public static void main(String[] args) {
        //int[] array = 0;   错误的,
        int[] array = null;   //代表 array 这个引用不指向任何对象
        System.out.println(array.length);	// 错误,array 不指向任何对象,没有长度
        System.out.println(array[0]);  // 错误,和上面一个道理
    }
}

让我们再来看看以下程序:

import java.util.Arrays;
public Main {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3, 4};
        int[] array2 = array1;
        System.out.println("array1=" + Arrays.toString(array1));
        System.out.println("array2=" + Arrays.toString(array2));
    }
}

在这里插入图片描述

int[] array2 = array1; 代表 array2这个引用 引用/指向了 array1 所引用/指向的对象,同时可以通过array2 来修改 array1,它们存着一样的地址,下面我们来画画图理解:

在这里插入图片描述

4.4 引用不能同时指向多个对象

我们来看看为什么

import java.util.Arrays;
public class Main{
    public static void main(String[] args) {
        int[] array = {1, 2, 4};
        array = new int[]{1, 3, 9};
        array = new int[]{2, 0, 3};
        System.out.println(Arrays.toString(array));
    }
}

可以猜猜这个数组最后打印了什么,下面我们来画画图,这里我们简略画一下就好

在这里插入图片描述

4.5 数组作为方法返回值

public class Main {
    public static int[] array() {
        int[] array = {1, 2, 4};
        return array;
    }
    public static void main(String[] args) {
        int[] ret = array();
        System.out.println(Arrays.toString(ret));
    }
}

我们来画图理解:
在这里插入图片描述


5. 二维数组


5.1 二维数组的使用

public class Main {
    public static void main(String[] args) {
        int[][] array1 = {{1, 2, 3}, {3, 2, 1}};
        
        int[][] array2 = new int[][]{{1, 2, 3}, {3, 2, 1}};
        
        int[][] array3 = new int[2][3];
    }
}

5.2 遍历打印二维数组

1. 使用 for 循环打印

    public static void main(String[] args) {
        int[][] array = {{1, 2, 3}, {3, 2, 1}};
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
    }

在这里插入图片描述

二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组。

在这里插入图片描述所以代码可改成

    public static void main(String[] args) {
        int[][] array = {{1, 2, 3}, {3, 2, 1}};
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
    }

2. 使用 for-each 进行遍历打印

    public static void main(String[] args) {
        int[][] array = {{1, 2, 3}, {3, 2, 1}};
     //因为二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组,所以我们用一维数组接收
        for (int[] array1 : array) {
            for (int x : array1) {
                System.out.print(x + " ");
            }
            System.out.println();
        }
    }

解释:因为二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组,所以我们用一维数组接收,一维数组接收后再经过每一次循环从 0 下标开始逐一将元素赋值给 x


3. 使用 Arrays.deepToString()

public class Main {
    public static void main(String[] args) {
        int[][] array = {{1, 2, 3}, {3, 2, 1}};
        System.out.println(Arrays.deepToString(array));
    }
}

在这里插入图片描述

5.3 不规则数组


当我们这样写时,编译器不会报错
int[][] array = new int[2][];

它是长这样的
在这里插入图片描述
那我们再来看看

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[][] array = new int[2][];
        array[0] = new int[]{1, 2};
        array[1] = new int[]{1, 2, 3, 4};
        System.out.println(Arrays.deepToString(array));
    }
}

在这里插入图片描述
我们可以看到这就是不规则数组。

我们来画图看看
在这里插入图片描述

好的,到这里本章节就结束了,如发现有错误,请各位大佬及时指出。

  • 10
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

没完没了的麦当

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值