Java数组详解

最新推荐文章于 2024-06-12 11:59:04 发布

~小明学编程

最新推荐文章于 2024-06-12 11:59:04 发布

阅读量1.5k

点赞数 17

分类专栏： JavaSE基础文章标签： java 开发语言 jvm

本文链接：https://blog.csdn.net/m0_56911284/article/details/126426518

版权

JavaSE基础专栏收录该内容

16 篇文章 2 订阅

订阅专栏

作者：~小明学编程

文章专栏：JavaSE基础

目之所及皆为回忆，心之所想皆为过往

数组的基本概念

什么是数组

数组：可以看成是相同类型元素的一个集合。在内存中是一段连续的空间。

注意

1. 数组中存放的元素其类型相同。
2. 数组的空间是连在一起的。
3. 每个空间有自己的编号，其实位置的编号为0，即数组的下标。

数组的创建及初始化

数组的创建

T[] 数组名 = new T[N];

T：表示数组中存放元素的类型
T[]：表示数组的类型
N：表示数组的长度

int[] array1 = new int[10]; // 创建一个可以容纳10个int类型元素的数组
double[] array2 = new double[5]; // 创建一个可以容纳5个double类型元素的数组
String[] array3 = new double[3]; // 创建一个可以容纳3个字符串元素的数组

数组的初始化

1. 动态初始化：在创建数组时，直接指定数组中元素的个数

int[] array = new int[5];

2. 静态初始化：在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定

语法格式： T[] 数组名称 = {data1, data2, data3, ..., datan};

int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};
double[] array2 = new double[]{1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = new String[]{"hell", "Java", "!!!"};

我们的静态创建和动态创建的主要区别是静态创建不指定元素的个数，但是编译的时候会帮我们确定元素的个数，动态创建数组的时候我们是确定数据元素的个数的，切不了写成如下的代码

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

【注意事项】
1.静态初始化虽然没有指定数组的长度，编译器在编译时会根据{}中元素个数来确定数组的长度。
2.静态初始化时, {}中数据类型必须与[]前数据类型一致。
3.静态初始化可以简写，省去后面的new T[]。

// 注意：虽然省去了new T[], 但是编译器编译代码时还是会还原
int[] array1 = {0,1,2,3,4,5,6,7,8,9};
double[] array2 = {1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = {"hell", "Java", "!!!"};

4.数组也可以按照C语言的方式进行创建

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

如上述所示，但是这种方式不推荐，容易对数组的类型产生误解

5.静态和动态初始化也可以分为两步，但是省略格式不可以

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

也就是说在我们静态创建数组时是不能够省略我们的new int[]的。

6.1如果没有对数组进行初始化，数组中元素有其默认值如果数组中存储元素类型为基类类型，默认值为基类类型对应的默认值，比如：

类型	默认值
byte	0
short	0
int	0
long	0
float	0.0f
double	0.0
char	/u0000
boolean	false

6.2如果数组中存储元素类型为引用类型，默认值为null.

数组的使用

数组中元素访问

数组在内存中是一段连续的空间，空间的编号都是从0开始的，依次递增，该编号称为数组的下标，数组可以通过下标访问其任意位置的元素。

【注意事项】
1. 数组是一段连续的内存空间，因此支持随机访问，即通过下标访问快速访问数组中任意位置的元素
2. 下标从0开始，介于[0, N）之间不包含N，N为元素个数，不能越界，否则会报出下标越界异常。

        int[] array2 = new int[5];
        for (int i = 0; i < 6; i++) {
            array2[i] = i;
        }

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
at Dome.main(Dome.java:19)

我们看到这里已经抛出异常了，意思就是数组访问越界了，并且提示了越界的数组下标是5。

遍历数组

所谓 "遍历" 是指将数组中的所有元素都访问一遍, 访问是指对数组中的元素进行某种操作，比如：打印。

下面给大家介绍常见的3种遍历数组的方法

1.利用length获取数组长度遍历法

        int[] arr = {1,2,3,4,5,6,7};
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }

2.for-each

        for (int x:arr) {
            System.out.print(x+" ");
        }

3.借助Java操作数组的工具类Arrays.toString()将参数数组以字符串的形式进行输出。

        System.out.println(Arrays.toString(arr));//[1, 2, 3, 4, 5, 6, 7]

数组是引用类型

初始JVM的内存分布

程序计数器 (PC Register): 只是一个很小的空间, 保存下一条执行的指令的地址。

虚拟机栈(JVM Stack): 与方法调用相关的一些信息，每个方法在执行时，都会先创建一个栈帧，栈帧中包含有：局部变量表、操作数栈、动态链接、返回地址以及其他的一些信息，保存的都是与方法执行时相关的一些信息。比如：局部变量。当方法运行结束后，栈帧就被销毁了，即栈帧中保存的数据也被销毁了。

本地方法栈(Native Method Stack): 本地方法栈与虚拟机栈的作用类似. 只不过保存的内容是Native方法的局部变量. 在有些版本的 JVM 实现中(例如HotSpot), 本地方法栈和虚拟机栈是一起的。

堆(Heap): JVM所管理的最大内存区域. 使用 new 创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2,3} )，堆是随着程序开始运行时而创建，随着程序的退出而销毁，堆中的数据只要还有在使用，就不会被销毁。

方法区(Method Area): 用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据. 方法编译出的的字节码就是保存在这个区域。

———————————————————————————————————————————

在学习数组这块内容的时候我们主要了解Java虚拟机栈和堆这两块的内容。

基本类型变量与引用类型变量的区别

public static void func() {
    int a = 10;
    int b = 20;
    int[] arr = new int[]{1,2,3};
}

我们来看一下这段代码在内存中是如何开辟空间的，

我们可以看到a,b作为Java内置类型的变量在栈中就给变量初始化并且赋值，但是array作为数组类型的引用变量是不会在栈中直接对数组初始化的，而是会在堆中对数组进行初始化并且赋值，然后array作为引用变量则是存储着在堆中开辟的地址，我们可以把堆中存储的东西看作为一个对象，然后通过我们的引用去操作对象。

从上图可以看到，引用变量并不直接存储对象本身，可以简单理解成存储的是对象在堆中空间的起始地址。通过该地址，引用变量便可以去操作对象。有点类似C语言中的指针，但是Java中引用要比指针的操作更简单

再谈引用变量

    public static void main(String[] args) {
        int[] array1 = new int[3];
        array1[0] = 10;
        array1[1] = 20;
        array1[2] = 30;
        int[] array2 = new int[]{1,2,3,4,5};
        array2[0] = 100;
        array2[1] = 200;
        array1 = array2;
        array1[2] = 300;
        array1[3] = 400;
        array2[4] = 500;
//        for (int x:array1) {
//            System.out.print(x+" ");
//        }
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);

        }
    }

首先我们创建了array1数组现在栈中开辟了一块空间存放我们的引用变量array1然后在堆中开辟空间存放我们的数组内容，引用变量array1则是存放数组在堆中的地址，接着我们通过array1的地址并通过下标解引用的方式对其进行赋值操作。

array2在开辟内存后就进行了赋值操作，其中array1=array2代表的是array1中的指向堆中的地址变成了array2此后无论是操作array1还是array2就都是操作array2所指向堆中的区域。

关于null

null 在 Java 中表示 "空引用" , 也就是一个不指向对象的引用.

    public static void main(String[] args) {
        int[] array = null;
        System.out.println(array[0]);
    }

Exception in thread "main" java.lang.NullPointerException
at Dome.main(Dome.java:13)

空指针异常

数组的应用场景

作为函数的参数

public static void main(String[] args) {
    int num = 0;
    func(num);
    System.out.println("num = " + num);
}
    public static void func(int x) {
    x = 10;
    System.out.println("x = " + x);
}
// 执行结果
x = 10
num = 0

发现在func方法中修改形参 x 的值, 不影响实参的 num 值

参数传数组类型(引用数据类型)

public static void main(String[] args) {
    int[] arr = {1, 2, 3};
    func(arr);
    System.out.println("arr[0] = " + arr[0]);
}
public static void func(int[] a) {
    a[0] = 10;
    System.out.println("a[0] = " + a[0]);
}
// 执行结果
a[0] = 10
arr[0] = 10

发现在func方法内部修改数组的内容, 方法外部的数组内容也发生改变.
因为数组是引用类型，按照引用类型来进行传递，是可以修改其中存放的内容的。

总结: 所谓的 "引用" 本质上只是存了一个地址. Java 将数组设定成引用类型, 这样的话后续进行数组参数传参, 其实只是将数组的地址传入到函数形参中. 这样可以避免对整个数组的拷贝(数组可能比较长, 那么拷贝开销就会很大).

作为函数的返回值

比如：获取斐波那契数列的前N项

public class TestArray {
    public static int[] fib(int n){
        if(n <= 0){
            return null;
        } in
        t[] array = new int[n];
        array[0] = array[1] = 1;
        for(int i = 2; i < n; ++i){
            array[i] = array[i-1] + array[i-2];
        } r
        eturn array;
    }
    public static void main(String[] args) {
        int[] array = fib(10);
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

我们方法的返回值也可以是一个数组类型。